//! Context menus, one look everywhere. //! //! The viewport's right-click opens a list of commands for the selection or the thing under the //! cursor: faces, edges, bodies, sketch entities or empty space. The optional radial marking //! menu adds eight commands around the cursor, with Repeat at the top. With that preference on, //! holding the right button opens it too; releasing over a direction picks a command (a flick). //! The browser's right-click //! opens the same list styling for a body, sketch or component. //! //! Items are commands (by id, with parameters filled from the target) or `ui.*` actions on view //! state; [`items`] lists them and [`run_item`] runs one, so the control channel (`ui.menu`, //! `ui.menuPick`) and tests reach everything a click does. use crate::ui_kit::{Container, Surface}; use egui::{Color32, Pos2, Rect, Sense, Vec2, pos2, vec2}; use serde::Serialize; use serde_json::{Value, json}; use solidcraft_engine::Sel; use crate::SolveApp; /// What a menu is about. #[derive(Clone, Debug, Default, PartialEq, Serialize, serde::Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum Target { /// The viewport: the selection, or empty space. #[default] Viewport, Body { name: String, }, Sketch { id: u64, }, /// Construction geometry (its feature id). Plane { id: u64, }, /// A native feature row in a component's Features folder. Feature { id: u64, }, /// An origin plane (XY, XZ or YZ). OriginPlane { name: String, }, Component { id: u64, }, Occurrence { path: Vec, }, /// A browser group of items, under the design (`scope` `c0`) or a placement (`o:`). Group { id: u64, scope: String, }, /// The Origin folder. Origin, /// Document Settings › Units. Units, /// An assembly joint. Joint { id: u64, }, /// A command (toolbar button, panel drop-down row, S box row). ToolbarCommand { id: String, }, /// The toolbar's empty space. Toolbar, /// The History controls (first, previous, next, last, and Play when shown). HistoryControls, /// The workspace switcher. Workspace, /// The Named Views folder, and one view (saved or standard) in it. NamedViews, NamedView { name: String, }, /// A canvas (reference image). Canvas { id: u64, }, /// A point cloud. PointCloud { id: u64, }, /// The Section Analysis in the browser's Analysis folder. Section, /// A component's Bodies, Sketches or Construction folder, under the design (`scope` `c0`) /// or a placement (`o:`). Folder { component: u64, folder: String, scope: String, }, } /// One menu entry: a command id (run with `params` when given, else started like a toolbar /// click) or a `ui.*` action. `-` is a separator, `#…` a section heading. #[derive(Clone, Debug, Serialize)] pub struct Item { pub id: String, pub label: String, pub shortcut: String, pub enabled: bool, pub icon: String, #[serde(skip_serializing_if = "Option::is_none")] pub params: Option, #[serde(skip_serializing_if = "Vec::is_empty")] pub children: Vec, #[serde(skip_serializing_if = "Option::is_none")] pub swatch: Option<[u8; 3]>, } impl 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, children: Vec::new(), swatch: None, } } pub(crate) fn heading(label: &str) -> Item { Item { id: format!("#{label}"), label: label.into(), shortcut: String::new(), enabled: false, icon: String::new(), params: None, children: Vec::new(), swatch: None, } } fn is_sep(&self) -> bool { self.id == "-" } fn is_heading(&self) -> bool { self.id.starts_with('#') } pub fn with(mut self, params: Value) -> Item { self.params = Some(params); self } pub fn on_if(self, enabled: bool) -> Item { self.on(enabled) } pub(crate) fn on(mut self, enabled: bool) -> Item { self.enabled &= enabled; self } pub fn key(mut self, k: &str) -> Item { self.shortcut = k.into(); self } } /// A command entry: label, icon, shortcut and enablement come from the registry. pub(crate) fn cmd(app: &SolveApp, id: &str, label: &str) -> Item { let info = solidcraft_engine::find_command(id).map(|c| c.info(&app.session)); let shortcut = match id { "edit.undo" => "Ctrl+Z".to_string(), "edit.redo" => "Ctrl+Y".to_string(), _ => crate::keymap::display_for(app, id).unwrap_or_default(), }; Item { id: id.into(), label: label.into(), shortcut, enabled: info.as_ref().is_some_and(|i| i.enabled), icon: info.map(|i| i.icon.to_string()).unwrap_or_default(), params: None, children: Vec::new(), swatch: None, } } /// A view action (`ui.*`). pub(crate) fn act(id: &str, label: &str, icon: &str) -> Item { Item { id: id.into(), label: label.into(), shortcut: String::new(), enabled: true, icon: icon.into(), params: None, children: Vec::new(), swatch: None, } } /// Menu state kept between frames. The anchor is `app.viewport.context_menu`. #[derive(Default)] pub struct MenuState { pub target: Target, /// The list row chosen with the arrow keys (Enter runs it). pub key_row: Option, submenu: Option, submenu_key: Option, /// When the pointer came to rest on another row while a flyout was open (it closes the /// flyout after [`SUBMENU_CLOSE_DELAY`]). submenu_leave: Option, /// The radial ring is shown (viewport menus). pub radial: bool, /// The right button is held through the menu: releasing over a direction picks it. pub flick: bool, /// A right press in the viewport that may become a press-and-hold: where and when. press: Option<(Pos2, f64)>, /// `ui.menu` asked to open at a point once the pointer got there. pending: Option<(Pos2, Target)>, /// An inline rename in progress. pub rename: Option, /// A delete waiting for its confirmation (it takes or breaks other features). pub confirm: Option, /// Identical copies Extract to File found, waiting to be linked too. pub link_copies: Option, /// The Properties window: title and measurements. pub props: Option<(String, Value)>, /// The viewport menu opened over something: it offers Select Other. pub over_geometry: bool, /// The plane under the cursor when the viewport menu opened: it offers a sketch on it. pub plane: Option, /// Where the viewport menu opened and the keys held at that click (Select Other adds with /// them). opened: Option<(Pos2, crate::tool_modifiers::Held)>, /// The viewport menu's right-click selected what was under it: where the menu opened, the /// selection before and the one it made. Select Other puts the one before back. picked: Option<(Pos2, Vec, Vec)>, /// The button that opened the menu, when it toggles it: a press there is not a press outside, /// so its click closes the menu instead of closing and reopening it (#1522). opener: Option, /// The menu was on screen in an earlier frame. Until then a press is the opening click's own. shown: bool, } #[derive(Clone, Debug, PartialEq)] pub enum RenameWhat { Body(String), Feature(u64), Component(u64), Group(u64), TimelineGroup(u64), Canvas(u64), View(String), Joint(u64), } #[derive(Clone, Debug)] pub struct Rename { pub what: RenameWhat, pub text: String, pub at: Pos2, pub(crate) focused: bool, /// Edited in the browser row itself (a double-click on a body), not in the floating box. pub(crate) inline: bool, } /// Radial slots, clockwise from the top. const DIRS: usize = 8; /// Half axes of the ring of radial items. const RX: f32 = crate::ui_kit::RADIAL_RADIUS; const RY: f32 = crate::ui_kit::RADIAL_RADIUS; /// Seconds the pointer rests on another row before an open flyout closes: a path to the flyout /// that crosses a neighbouring row keeps it open. const SUBMENU_CLOSE_DELAY: f64 = 0.3; // --------------------------------------------------------------------------------------------- // What the menus offer // --------------------------------------------------------------------------------------------- fn sel_bodies(app: &SolveApp) -> Vec { let mut v: Vec = Vec::new(); for s in &app.session.selection { if let Sel::Body { name } = s && !v.contains(name) { v.push(name.clone()); } } v } /// The sketch a selected sketch curve or point belongs to. Geometry of a sketch that is not /// being edited selects as `ExternalSketchCurve` or `ExternalSketchPoint` /// (`viewport::hit_candidate`). Those two carry the owning sketch's feature id. The entities of /// the sketch being edited are `SketchCurve` and `SketchPoint` instead. The sketch-editing menu /// already covers that case. fn sel_sketch(app: &SolveApp) -> Option { app.session.selection.iter().find_map(|s| match s { Sel::ExternalSketchCurve { sketch, .. } | Sel::ExternalSketchPoint { sketch, .. } => Some(*sketch), _ => None, }) } /// Bodies the selection touches (bodies, and the bodies of selected faces and edges). fn touched_bodies(app: &SolveApp) -> Vec { let mut v: Vec = Vec::new(); for s in &app.session.selection { let b = match s { Sel::Body { name } => name, Sel::Face { body, .. } | Sel::Edge { body, .. } | Sel::Vertex { body, .. } => body, _ => continue, }; if !v.contains(b) { v.push(b.clone()); } } v } fn body_feature(app: &SolveApp, body: &str) -> Option { app.session.world_state().body(body).map(|b| b.feature) } /// Bodies in a component and its subcomponents. pub fn component_bodies(app: &SolveApp, id: u64) -> Vec { let doc = &app.session.doc; app.session.model.state().bodies.iter().filter(|b| doc.component_within(doc.model_body_component(b), id)).map(|b| b.name.clone()).collect() } /// The eight radial commands, clockwise from the top. pub fn radial_items(app: &SolveApp) -> Vec { let key = crate::keymap::display_for(app, "edit.repeat").unwrap_or_default(); let repeat = match &app.last_command { Some((_, label)) => act("ui.repeat", &format!("Repeat {label}"), "redo").key(&key), None => act("ui.repeat", "Repeat", "redo").key(&key).on(false), }; let delete = act("ui.delete", "Delete", "delete").key("Del").on(!app.session.selection.is_empty()); if app.session.active_sketch.is_some() { return vec![ repeat, delete, cmd(app, "sketch.line", "Line"), cmd(app, "sketch.rectangle.two_point", "Rectangle"), act("ui.finishSketch", "Finish Sketch", "finish"), cmd(app, "sketch.circle.center", "Circle"), cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty()), cmd(app, "sketch.dimension", "Sketch Dimension"), ]; } vec![ repeat, delete, cmd(app, "solid.press_pull", "Press Pull"), cmd(app, "solid.hole", "Hole"), cmd(app, "sketch.create", "Create Sketch"), cmd(app, "solid.extrude", "Extrude"), cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty()), cmd(app, "solid.move", "Move/Copy"), ] } /// The list of a menu (under the ring for the viewport). pub fn items(app: &SolveApp, target: &Target) -> Vec { let mut v = match target { Target::Viewport => viewport_items(app), Target::Body { name } if crate::render_workspace::active(app) => vec![ cmd(app, "select.set", "Select").with(json!({"items":[Sel::Body {name:name.clone()}]})), cmd(app, "select.same_look", "Select Same Look").with(json!({"body":name})), Item::sep(), act("ui.isolate", "Isolate", "body").with(json!({"bodies":[name]})), act(if app.session.visibility.hidden_bodies.contains(name) { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye") .with(json!({"bodies":[name]})), ], Target::Body { name } => body_items(app, std::slice::from_ref(name), true), Target::Sketch { id } => sketch_items(app, *id), Target::Feature { id } => feature_items(app, *id), Target::Plane { id } => plane_items(app, *id), Target::OriginPlane { name } => origin_plane_items(app, name), Target::Component { id } => component_items(app, *id), Target::Occurrence { path } => occurrence_items(app, path), Target::Group { id, scope } => crate::browser::group_items(app, *id, scope), Target::Folder { component, folder, scope } => crate::browser::folder_items(app, *component, folder, scope), Target::Canvas { id } => crate::browser::canvas_items(app, *id), Target::PointCloud { id } => crate::browser::point_cloud_items(app, *id), Target::Origin => crate::browser::origin_items(app), Target::NamedViews => vec![act("ui.newView", "New Named View", "perspective")], Target::Section => crate::browser::section_items(app), Target::Joint { id } => joint_items(app, *id), Target::ToolbarCommand { id } => crate::toolbar_custom::command_items(app, id), Target::Toolbar => crate::toolbar_custom::toolbar_items(app), Target::HistoryControls => crate::timeline::transport_items(app), Target::Workspace => { let rendering = crate::render_workspace::active(app); let mut v = vec![ act("ui.workspace.design", "Design", "ws_design").with(json!({"workspace":"design"})).key(if rendering { "" } else { "current" }), act("ui.workspace.render", "Render", "ws_render") .with(json!({"workspace":"render"})) .key(if rendering { "current" } else { "" }) .on(app.session.active_sketch.is_none() && app.tool.is_none() && app.dialog.is_none() && !app.file_load.busy()), ]; for (w, icon) in [("Animation", "ws_animate"), ("Simulation", ""), ("Manufacture", ""), ("Drawing", "ws_drawing")] { v.push(act("ui.workspace", w, icon).key("coming later").on(false)); } v } Target::Units => crate::prefs::UNITS .iter() .map(|u| { let item = cmd(app, "document.units", u).with(json!({ "units": u })); if app.session.doc.units == *u { item.key("current") } else { item } }) .collect(), Target::NamedView { name } => crate::browser::view_items(app, name), }; if !crate::render_workspace::active(app) { v.extend(crate::browser::folded_folder_items(app, target)); } if crate::render_workspace::active(app) { let (bodies, selection) = match target { Target::Component { id } => { let bodies = component_bodies(app, *id); let selection: Vec = bodies.iter().map(|name| Sel::Body { name: name.clone() }).collect(); (bodies, selection) } Target::Occurrence { path } => { (app.session.occurrence_bodies(path, true).unwrap_or_default(), vec![Sel::Occurrence { path: path.clone() }]) } _ => (Vec::new(), Vec::new()), }; if let Some(body) = bodies.first() { v.insert(0, cmd(app, "select.set", "Select").with(json!({"items":selection}))); v.insert( 1, cmd(app, "select.same_look", "Select Same Look") .with(json!({"body":body})) .on(crate::render_workspace::scene::same_look(app, &bodies)), ); } } if crate::render_workspace::active(app) && let Target::Body { name } = target { v.push(crate::render_workspace::assign::menu(app, name)); } // 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)); } for item in &mut v { if item.id != "ui.appearance" { continue; } // A selected browser body keeps the selection for the editor and its quick choices. // A row outside the selection still targets only the body that was right-clicked. if let Target::Body { name } = target { let bodies = sel_bodies(app); if bodies.contains(name) { item.params = Some(json!({"bodies": bodies})); } } let original = item.clone(); let params = item.params.clone().unwrap_or_else(|| { let faces: Vec<_> = app .session .selection .iter() .filter_map(|s| match s { Sel::Face { body, point, .. } => Some(json!({"body":body,"point":[point.x, point.y, point.z]})), _ => None, }) .collect(); if faces.is_empty() { json!({"bodies": touched_bodies(app)}) } else { json!({"faces":faces}) } }); let targets = if let Some(component) = params.get("component").and_then(Value::as_u64).filter(|id| *id != 0) { json!({"components": [component.to_string()]}) } else { params }; item.children.push(original); if ["bodies", "components", "faces"].iter().any(|key| targets.get(key).and_then(Value::as_array).is_some_and(|v| !v.is_empty())) { for look in crate::dialogs_appearance::builtin() { let mut params = targets.clone(); params["appearance"] = json!(look.name); params["color"] = json!(crate::dialogs_appearance::hex(look.color)); params["opacity"] = json!(look.opacity); let mut child = cmd(app, "appearance.assign", &look.name).with(params); child.swatch = Some(look.color); item.children.push(child); } item.children.push(Item::sep()); item.children.push(cmd(app, "appearance.assign", "Remove override").with(targets)); } } v } /// Resolve the picked face's creator, rather than the feature that first made its body. /// Persistent face names retain their creator through later trims and placements. fn picked_face_feature(app: &SolveApp) -> Option { let (body, index) = app.session.selection.iter().find_map(|s| match s { Sel::Face { body, index, .. } => Some((body, *index)), _ => None, })?; face_feature(app, body, index) } /// The feature that made face `index` of `body` (by its world name). pub(crate) fn face_feature(app: &SolveApp, body: &str, index: usize) -> Option { let state = app.session.world_state(); let body = state.body(body)?; let names = solidcraft_engine::doc::naming::face_names(body); let name = names.get(index)?; let id = solidcraft_engine::doc::persistent_name::made_by(name)?; let owner = app.session.doc.feature(body.feature)?; if matches!(owner.kind, solidcraft_engine::doc::FeatureKind::Import { .. } | solidcraft_engine::doc::FeatureKind::MeshImport { .. }) && id != owner.id { return None; } app.session.doc.feature(id).filter(|f| f.component == app.session.doc.model_body_component(body)).map(|f| f.id) } /// A feature and its profile sketch, if it has one. fn feature_and_sketch(app: &SolveApp, f: Option) -> (Option, Option) { let sketch = f .and_then(|f| app.session.doc.feature(f)) .and_then(|f| serde_json::to_value(&f.kind).ok()) .and_then(|v| v.get("sketch").and_then(Value::as_u64).or_else(|| v.as_object()?.values().find_map(|x| x.get("sketch")?.as_u64()))); (f, sketch) } /// A browser feature row's menu: the timeline's feature actions, so the browser alone is enough /// to edit, suppress and roll back. fn feature_items(app: &SolveApp, id: u64) -> Vec { let feature = app.session.doc.feature(id); let exists = feature.is_some(); let sketch = feature.and_then(|f| crate::timeline::TimelineKind::of(&f.kind).profile_sketch()); let suppressed = feature.is_some_and(|f| f.suppressed); vec![ act("ui.editFeature", "Edit Feature", "edit").with(json!({"feature":id})).on(exists), act("ui.editSketch", "Edit Profile Sketch", "sketch").with(json!({"sketch": sketch.map(|s| s.0)})).on(sketch.is_some()), act("ui.rename", "Rename", "rename").with(json!({"feature":id})).on(exists), act("timeline.suppress", if suppressed { "Unsuppress" } else { "Suppress" }, "suppress") .with(json!({"feature":id, "suppressed": !suppressed})) .on(exists), act("timeline.roll_to", "Roll Back Here", "rollback").with(json!({"feature":id})).on(exists), act("ui.delete", "Delete", "delete").key("Del").with(json!({"items": [{"type": "feature", "id": id}]})).on(exists), Item::sep(), act("ui.findTimeline", "Find in Timeline", "rollback").with(json!({"feature":id})).on(exists), ] } /// The canvas menus put Repeat on /// top, then what fits the selection, our extras after a separator. fn viewport_items(app: &SolveApp) -> Vec { let sel = &app.session.selection; let has = |f: fn(&Sel) -> bool| sel.iter().any(f); let mut v = Vec::new(); if let Some((_, label)) = &app.last_command { let key = crate::keymap::display_for(app, "edit.repeat").unwrap_or_default(); v.push(act("ui.repeat", &format!("Repeat {label}"), "redo").key(&key)); v.push(Item::sep()); } // Everything under the cursor, for what lies beneath something else. if app.menu.over_geometry { v.push(act("ui.selectOther", "Select Other…", "select").key("Hold click")); v.push(Item::sep()); } if app.session.active_sketch.is_some() { v.extend(sketch_entity_items(app)); v.push(Item::sep()); v.push(cmd(app, "sketch.trim", "Trim")); v.push(cmd(app, "sketch.offset", "Offset")); v.push(Item::sep()); v.push(act("ui.finishSketch", "Finish Sketch", "finish")); v.push(act("ui.cancelSketch", "Cancel Sketch", "sketch_cancel")); v.push(Item::sep()); v.push(cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty())); v.push(cmd(app, "edit.redo", "Redo").on(!app.session.redo.is_empty())); return v; } // A sketch curve or point in the viewport gets the sketch's own menu, the one its browser row // opens, with Edit Sketch among it. Solid geometry in the selection keeps the body menu: a // right-click on a face still offers the face's commands. The picker already prefers a sketch // curve to the face it lies on (`pick_hits` offers curves before faces). A right-click that // resolved to a sketch curve therefore replaces any face in the selection with that curve. // The menu then follows the pick. let solid = has(|s| matches!(s, Sel::Face { .. } | Sel::Edge { .. } | Sel::Vertex { .. } | Sel::Body { .. })); if let Some(sketch) = sel_sketch(app).filter(|_| !solid) { v.extend(sketch_items(app, sketch)); } else if has(|s| matches!(s, Sel::Face { .. })) { let face = sel.iter().find_map(|s| if let Sel::Face { body, .. } = s { Some(body.clone()) } else { None }).unwrap_or_default(); let (feature, sketch) = feature_and_sketch(app, picked_face_feature(app)); let hidden = app.session.visibility.hidden_bodies.contains(&face); if app.preferences.nav == "solidworks" { v.push(cmd(app, "view.normal_to", "Normal to Selection").with(json!({"camera": app.cam}))); v.push(Item::sep()); } v.push(cmd(app, "sketch.create", "Create Sketch")); v.push(cmd(app, "solid.extrude", "Extrude")); v.push(cmd(app, "construct.plane.offset", "Offset Plane")); v.push(cmd(app, "solid.shell", "Shell")); v.push(act("ui.editFeature", "Edit Feature", "edit").with(json!({ "feature": feature })).on(feature.is_some())); v.push(act("ui.editSketch", "Edit Profile Sketch", "sketch").with(json!({ "sketch": sketch })).on(sketch.is_some())); let planar = sel.iter().any(|s| matches!(s, Sel::Face { body, index, .. } if crate::dialogs::planar_face(&app.session, body, *index).is_some())); v.push(act("ui.lookAt", "Look At", "lookat").on(planar)); v.push(Item::sep()); v.push(act("ui.appearance", "Appearance", "appearance").key("A")); v.push(act("ui.properties", "Properties", "measure").with(json!({ "bodies": [face] }))); v.push(act("ui.saveMesh", "Save As Mesh", "export").with(json!({ "bodies": [face] }))); v.push(Item::sep()); v.push(act("ui.delete", "Delete", "delete").key("Del")); v.push(act(if hidden { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye").key("V").with(json!({ "bodies": [face] }))); v.push(Item::sep()); v.push(act("ui.findBrowser", "Find in Browser", "list").with(json!({ "body": face }))); v.push(act("ui.findTimeline", "Find in Timeline", "rollback").with(json!({ "feature": feature, "body": face })).on(feature.is_some())); v.push(Item::sep()); v.push(cmd(app, "solid.press_pull", "Press Pull")); v.push(cmd(app, "inspect.measure", "Measure")); } else if has(|s| matches!(s, Sel::Edge { .. })) { let body = sel.iter().find_map(|s| if let Sel::Edge { body, .. } = s { Some(body.clone()) } else { None }).unwrap_or_default(); let hidden = app.session.visibility.hidden_bodies.contains(&body); v.push(cmd(app, "solid.fillet", "Fillet")); v.push(cmd(app, "solid.chamfer", "Chamfer")); v.push(Item::sep()); v.push(act("ui.delete", "Delete", "delete").key("Del")); v.push(act(if hidden { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye").key("V").with(json!({ "bodies": [body] }))); v.push(Item::sep()); v.push(act("ui.findBrowser", "Find in Browser", "list").with(json!({ "body": body }))); v.push(act("ui.saveMesh", "Save As Mesh", "export").with(json!({ "bodies": [body] }))); v.push(Item::sep()); v.push(act("ui.tangentChain", "Select Tangent Chain", "chain")); v.push(cmd(app, "inspect.measure", "Measure")); } else if has(|s| matches!(s, Sel::Body { .. })) { v.extend(body_items(app, &sel_bodies(app), false)); } else if has(|s| matches!(s, Sel::Profile { .. })) { v.push(cmd(app, "solid.extrude", "Extrude")); v.push(cmd(app, "solid.revolve", "Revolve")); } else { // Empty space, or a plane: both lead with Create Sketch (#3032). On a plane it sketches // there, with Look At beside it; on empty space it is the toolbar's, which asks for the // plane or face. let sketch = cmd(app, "sketch.create", "Create Sketch"); match &app.menu.plane { Some(plane) => { v.push(sketch.with(json!({ "plane": plane }))); v.push(act("ui.lookAt", "Look At", "lookat").with(json!({ "plane": plane }))); } None => v.push(sketch), } v.push(Item::sep()); v.push(act("ui.nav", "Pan", "pan").with(json!({ "mode": "pan" }))); v.push(act("ui.nav", "Zoom", "zoom").with(json!({ "mode": "zoom" }))); v.push(act("ui.nav", "Orbit", "orbit").with(json!({ "mode": "orbit" }))); v.push(act("ui.fit", "Fit", "fit")); v.push(act("ui.home", "Home View", "home")); v.push(Item::sep()); let anything_hidden = !app.session.visibility.hidden_bodies.is_empty() || !app.session.visibility.hidden_sketches.is_empty() || !app.session.visibility.hidden_folders.is_empty(); v.push(act("ui.showAll", "Show All", "eye").on(anything_hidden)); v.push(act("ui.showAll", "Unisolate", "eye").on(!app.session.visibility.hidden_bodies.is_empty())); v.push(Item::sep()); v.push(cmd(app, "solid.extrude", "Extrude")); v.push(cmd(app, "solid.fillet", "Fillet")); v.push(Item::sep()); v.push(cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty())); v.push(cmd(app, "edit.redo", "Redo").on(!app.session.redo.is_empty())); v.push(Item::sep()); if app.session.section.is_some() { v.push(act("ui.unsection", "Remove Section", "section")); } v.push(act("ui.origin", if app.origin_shown() { "Hide Origin" } else { "Show Origin" }, "origin")); return v; } if !sel.is_empty() { if !v.iter().any(|item| item.id == "parts.resize") && let Some(component) = crate::dialogs_part_size::selected_component(app) { v.push(cmd(app, "parts.resize", "Change Part Size").with(json!({"component":component}))); } v.push(Item::sep()); v.push(act("ui.clear", "Clear Selection", "close").key("Esc")); } v } fn body_items(app: &SolveApp, bodies: &[String], browser: bool) -> Vec { let names = json!(bodies); let all_hidden = bodies.iter().all(|b| app.session.visibility.hidden_bodies.contains(b)); let one = bodies.len() == 1; let locked = bodies.iter().all(|b| app.session.visibility.locked_bodies.contains(b)); let items = json!(bodies.iter().map(|b| json!({"type": "body", "name": b})).collect::>()); let mut v = vec![ act("ui.moveBodies", "Move/Copy", "move").key("M").with(json!({ "bodies": names })).on(!locked), cmd(app, "component.from_bodies", "Create Components from Bodies").with(json!({ "bodies": names })), Item::sep(), act("ui.material", "Physical Material", "material").with(json!({ "bodies": names })), act("ui.appearance", "Appearance", "appearance").key("A").with(json!({ "bodies": names })), act("ui.properties", "Properties", "measure").with(json!({ "bodies": names })), Item::sep(), act("ui.saveMesh", "Save As Mesh", "export").with(json!({ "bodies": names })), act("ui.sendToSlicer", "Send to Slicer", "export").with(json!({ "bodies": names })).on(crate::dialogs_save_mesh::available(app)), act("ui.export", "Export…", "export").with(json!({ "bodies": names })), Item::sep(), // The clipboard beside Delete, Remove and Rename, as in every menu. act("ui.cut", "Cut", "cut").key("Ctrl+X").on(crate::edit_clipboard::can_cut(app)), act("ui.copy", "Copy", "copy").key("Ctrl+C").on(crate::edit_clipboard::something_to_copy(app)), act("ui.paste", "Paste", "paste").key("Ctrl+V").on(crate::edit_clipboard::can_paste(app)), act("ui.delete", "Delete", "delete").key("Del").with(json!({ "items": items })).on(!locked), cmd(app, "solid.remove", "Remove").with(json!({ "bodies": names })).on(!locked), act("ui.rename", "Rename", "rename").with(json!({ "body": bodies.first() })).on(one), Item::sep(), act(if all_hidden { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye").key("V").with(json!({ "bodies": names })), act("ui.lock", if locked { "Unlock" } else { "Lock" }, "ground").with(json!({ "bodies": names })), act("ui.isolate", "Isolate", "body").with(json!({ "bodies": names })), ]; if one { let b = bodies.first().cloned().unwrap_or_default(); if let Some(component) = crate::dialogs_part_size::component_for_bodies(app, bodies) { v.push(cmd(app, "parts.resize", "Change Part Size").with(json!({"component":component}))); } v.push(Item::sep()); if !browser { v.push(act("ui.findBrowser", "Find in Browser", "list").with(json!({ "body": b }))); } v.push(act("ui.findTimeline", "Find in Timeline", "rollback").with(json!({ "body": b }))); } v } fn sketch_items(app: &SolveApp, id: u64) -> Vec { let visible = crate::browser::sketch_visible(app, id); let profiles = !app.session.visibility.hidden_profiles.contains(&id); let dims = app.session.visibility.shown_dimensions.contains(&id); let editing = app.session.active_sketch == Some(id); let has_profiles = app.session.world_state().sketch(id).is_some_and(|s| !s.profiles.is_empty()); vec![ act("ui.extrudeSketch", "Extrude", "extrude").key("E").with(json!({ "sketch": id })).on(has_profiles && !editing), Item::sep(), act("ui.editSketch", "Edit Sketch", "sketch").with(json!({ "sketch": id })).on(!editing), act("ui.redefineSketch", "Redefine Sketch Plane", "plane").with(json!({ "sketch": id })), act("ui.exportDxf", "Export DXF…", "export").with(json!({ "sketch": id })), Item::sep(), act("ui.copy", "Copy", "copy").key("Ctrl+C").on(crate::edit_clipboard::something_to_copy(app)), act("ui.paste", "Paste", "paste").key("Ctrl+V").on(crate::edit_clipboard::can_paste(app)), act("ui.delete", "Delete", "delete").key("Del").with(json!({ "items": [{"type": "feature", "id": id}] })), act("ui.rename", "Rename", "rename").with(json!({ "feature": id })), Item::sep(), act("ui.lookAt", "Look At", "lookat").with(json!({ "sketch": id })), act("ui.sketchProfile", if profiles { "Hide Profile" } else { "Show Profile" }, "sketch").with(json!({ "sketch": id })), act("ui.sketchDims", if dims { "Hide Dimension" } else { "Show Dimension" }, "dimension").with(json!({ "sketch": id })), act(if visible { "ui.hideSketch" } else { "ui.showSketch" }, "Show/Hide", "eye").key("V").with(json!({ "sketch": id })), Item::sep(), act("ui.findTimeline", "Find in Timeline", "rollback").with(json!({ "feature": id })), ] } /// Construction geometry's row: edit, delete, rename, show or hide; sketch on planes. fn plane_items(app: &SolveApp, id: u64) -> Vec { let Some(f) = app.session.doc.feature(id) else { return Vec::new() }; let visible = !app.session.visibility.hidden_origin.contains(&f.name); let mut items = Vec::new(); if matches!(f.kind, solidcraft_engine::doc::FeatureKind::ConstructionPlane { .. }) { items.push(cmd(app, "sketch.create", "Create Sketch").with(json!({ "plane": f.name }))); items.push(Item::sep()); } items.push(act("ui.editFeature", "Edit Feature", crate::timeline::icon_of(&f.kind)).with(json!({ "feature": id }))); items.push(Item::sep()); items.extend([ act("ui.delete", "Delete", "delete").key("Del").with(json!({ "items": [{"type": "feature", "id": id}] })), act("ui.rename", "Rename", "rename").with(json!({ "feature": id })), Item::sep(), act("ui.originPart", "Show/Hide", "eye").key("V").with(json!({ "keys": [f.name], "show": !visible })), Item::sep(), act("ui.findTimeline", "Find in Timeline", "rollback").with(json!({ "feature": id })), ]); items } /// An origin plane's row in the browser: sketch on it, show or hide. fn origin_plane_items(app: &SolveApp, name: &str) -> Vec { let visible = !app.session.visibility.hidden_origin.iter().any(|h| h == name); vec![ cmd(app, "sketch.create", "Create Sketch").with(json!({ "plane": name })), Item::sep(), act("ui.originPart", "Show/Hide", "eye").key("V").with(json!({ "keys": [name], "show": !visible })), ] } /// An assembly joint: edit, drive, suppress, delete. fn joint_items(app: &SolveApp, id: u64) -> Vec { let Some(j) = app.session.doc.assembly.joints.iter().find(|j| j.id == id) else { return Vec::new() }; let rigid = j.kind == solidcraft_engine::doc::joints::JointKind::Rigid; // Show/Hide acts on every joint picked in the browser (this one among them). let mut joints = app.tree.picked_joints.clone(); if !joints.contains(&id) { joints = vec![id]; } let hidden = !joints.iter().any(|j| app.session.joint_visible(*j)); vec![ act("ui.editJoint", "Edit Joint", "joint").with(json!({ "joint": id })), act("ui.editJoint", "Edit Joint Limits", "joint").with(json!({ "joint": id })).on(!rigid), act("ui.driveJoint", "Drive Joint", "drive").with(json!({ "joint": id })).on(!rigid), act("ui.animateJoint", "Animate Joint", "play").with(json!({ "joint": id })).on(!rigid && !j.suppressed), act("ui.findJoint", "Find in Window", "fit").with(json!({ "joint": id })), cmd(app, "joint.edit", if j.suppressed { "Unsuppress" } else { "Suppress" }).with(json!({ "joint": id, "suppressed": !j.suppressed })), Item::sep(), act("ui.delete", "Delete", "delete").key("Del").with(json!({ "joints": [id] })), act("ui.rename", "Rename", "rename").with(json!({ "joint": id })), Item::sep(), // Hiding a joint hides only its glyph: it still constrains and moves the parts. act("browser.visibility", "Show/Hide", "eye").key("V").with(json!({ "joints": joints, "visible": hidden })), ] } fn occurrence_items(app: &SolveApp, path: &[u64]) -> Vec { let Ok(placement) = app.session.occurrence_placement(path) else { return Vec::new() }; let mut entries = component_items(app, placement.component); if app.session.occurrence_scope_count(path).is_ok_and(|n| n > 1) { entries.insert(0, Item::heading("Shared child: edits affect all copies of its parent")); } let bodies = app.session.occurrence_bodies(path, true).unwrap_or_default(); for item in &mut entries { match item.id.as_str() { "ui.activate" => { item.params = Some(json!({"component": placement.component, "occurrence": placement.occurrence, "path": path})); item.enabled = app.session.active_occurrence_path.as_deref() != Some(path); } "ui.editInPlace" => item.params = Some(json!({"component": placement.component, "path": path})), "occurrence.ground" => { item.label = if placement.grounded { "Unground" } else { "Ground" }.into(); item.params = Some(json!({"occurrence": placement.occurrence, "grounded": !placement.grounded})); } "ui.moveOccurrence" => { item.params = Some(json!({"occurrence": placement.occurrence, "path": path})); item.enabled = !placement.grounded && app.session.held_by_rigid_group(placement.occurrence).is_none(); } "ui.properties" => item.params = Some(json!({"occurrence": placement.occurrence, "path": path})), "ui.turnUpAxis" => { for child in &mut item.children { if let Some(params) = child.params.as_mut() { params["occurrence"] = json!(placement.occurrence); } } } "occurrence.copy" => item.params = Some(json!({"occurrence": placement.occurrence, "translate": [10,10,0]})), "ui.paste" | "ui.pasteNew" => item.params = Some(json!({"component": placement.component, "path": path})), "component.create" => item.params = Some(json!({"parent": placement.component, "parent_path": path})), "ui.rename" => item.label = "Rename Component".into(), "ui.appearance" => item.label = "Component Appearance".into(), "ui.material" => item.label = "Component Physical Material".into(), "ui.delete" => item.params = Some(json!({"occurrences": [placement.occurrence]})), "ui.hide" | "ui.show" => { item.id = "browser.visibility".into(); item.params = Some(json!({"visible": app.session.occurrence_hidden(path), "paths": [path]})); item.enabled = true; } "ui.isolate" => { item.id = "ui.isolateOccurrence".into(); item.params = Some(json!({"path": path})); } "ui.export" | "ui.saveMesh" | "ui.sendToSlicer" => item.params = Some(json!({"bodies": bodies})), "browser.expand_all" | "browser.collapse_all" => item.params = Some(json!({"path": path})), _ => {} } } entries } /// "Turn Up Axis": a quarter turn about X of a component's occurrence for a file saved with the /// other axis up, one `occurrence.move` (one undo step). fn turn_up_axis(occurrence: u64, enabled: bool) -> Item { let mut item = act("ui.turnUpAxis", "Turn Up Axis", "move").on(enabled); item.children = [("Y up \u{2192} Z up", "90 deg"), ("Z up \u{2192} Y up", "-90 deg")] .into_iter() .map(|(label, angle)| { act("occurrence.move", label, "move").with(json!({"occurrence": occurrence, "axis": [1, 0, 0], "angle": angle})).on(enabled) }) .collect(); item } fn component_items(app: &SolveApp, id: u64) -> Vec { let doc = &app.session.doc; let occ = doc.occurrence_of(id); let active = app.session.active_component == id; let bodies = component_bodies(app, id); let hidden = !bodies.is_empty() && bodies.iter().all(|b| app.session.visibility.hidden_bodies.contains(b)); let names = json!(bodies); // The clipboard: Copy takes the selection (the row right-clicked); Paste puts what was copied // inside this component (never a component inside itself or what it holds); Paste New pastes // copied components as independent copies. let into = json!({ "component": id, "path": app.session.doc.first_path(id) }); let pastes_here = crate::edit_clipboard::can_paste_into(app, id); let mut v = Vec::new(); if doc.parts.contains_key(&id) { v.push(cmd(app, "parts.resize", "Edit").with(json!({"component":id}))); } if id != 0 { let grounded = occ.is_some_and(|o| o.grounded); let oid = occ.map(|o| o.id).unwrap_or(0); v.push(act("ui.activate", "Activate", "component").with(json!({ "component": id })).on(!active)); if doc.links.contains_key(&id) { v.push(act("ui.editInPlace", "Edit in Place", "edit").with(json!({ "component": id }))); v.push(act("ui.openLinkedDesign", "Open Linked Design", "open").with(json!({ "component": id }))); } v.push(cmd(app, "occurrence.ground", if grounded { "Unground" } else { "Ground" }).with(json!({ "occurrence": oid, "grounded": !grounded }))); v.push( act("ui.moveOccurrence", "Move/Copy", "move") .key("M") .with(json!({ "occurrence": oid })) .on(!grounded && occ.is_some() && app.session.held_by_rigid_group(oid).is_none()), ); v.push(turn_up_axis(oid, !grounded && occ.is_some() && app.session.held_by_rigid_group(oid).is_none())); v.push(cmd(app, "component.capture_position", "Capture Position").on(!app.session.pending_moves.is_empty())); v.push(cmd(app, "component.revert_position", "Revert Position").on(!app.session.pending_moves.is_empty())); // An imported assembly moves as one until its rigid group is released. if !app.session.contents_joints(id).is_empty() { v.push(cmd(app, "component.unlock", "Unlock Contents").with(json!({ "component": id }))); } v.push(Item::sep()); } else { v.push(act("ui.activate", "Activate", "component").with(json!({ "component": id })).on(!active)); } v.push(cmd(app, "component.create", "New Component").with(json!({ "parent": id }))); if id == 0 { v.push(cmd(app, "component.from_bodies", "Create Components from Bodies").with(json!({ "bodies": names })).on(!bodies.is_empty())); } v.push(Item::sep()); v.push(act("ui.material", "Physical Material", "material").with(json!({ "bodies": names })).on(!bodies.is_empty())); v.push( act("ui.appearance", "Appearance", "appearance") .key("A") .with(if id == 0 { json!({ "bodies": names }) } else { json!({"component": id}) }) .on(id != 0 || !bodies.is_empty()), ); if id != 0 { v.push(cmd(app, "component.cycle_color", "Cycle Component Color").with(json!({"component": id}))); } v.push(act("ui.properties", "Properties", "measure").with(json!({ "component": id }))); if doc.links.contains_key(&id) { v.push(act("ui.relinkSource", "Relink Source (All Instances)…", "update").with(json!({"component": id}))); } else if id != 0 && app.session.can_extract(id) { v.push(act("ui.extractComponent", "Extract to File…", "export").with(json!({"component": id}))); } if id == 0 { v.push(act("ui.designProperties", "Design Properties", "settings")); } v.push(Item::sep()); v.push(act("ui.export", "Export…", "export").with(json!({ "bodies": names })).on(!bodies.is_empty())); v.push(act("ui.saveMesh", "Save As Mesh", "export").with(json!({ "bodies": names })).on(!bodies.is_empty())); v.push( act("ui.sendToSlicer", "Send to Slicer", "export") .with(json!({ "bodies": names })) .on(!bodies.is_empty() && crate::dialogs_save_mesh::available(app)), ); v.push(Item::sep()); // The clipboard, then Delete and Rename, in the same place for the design and its components // (the design is copied as a saved design to link, and is neither cut nor deleted). if id == 0 { v.push(act("ui.copyDesign", "Copy", "copy").key("Ctrl+C")); } else { v.push(act("ui.cut", "Cut", "cut").key("Ctrl+X").on(crate::edit_clipboard::can_cut(app))); v.push(act("ui.copy", "Copy", "copy").key("Ctrl+C").on(crate::edit_clipboard::something_to_copy(app))); } v.push(act("ui.paste", "Paste", "paste").key("Ctrl+V").with(into.clone()).on(pastes_here)); v.push( act("ui.pasteNew", "Paste New", "paste") .key("Ctrl+Shift+V") .with(into.clone()) .on(pastes_here && crate::edit_clipboard::pasting_components(app)), ); if id != 0 { v.push(act("ui.delete", "Delete", "delete").key("Del").with(json!({ "occurrences": [occ.map(|o| o.id)] })).on(occ.is_some())); } v.push(act("ui.rename", "Rename", "rename").with(json!({ "component": id }))); v.push(Item::sep()); v.push(act(if hidden { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye").key("V").with(json!({ "bodies": names })).on(!bodies.is_empty())); v.push(act("ui.showAll", "Show All Bodies", "eye")); v.push(act("ui.isolate", "Isolate", "body").with(json!({ "bodies": names })).on(!bodies.is_empty() && id != 0)); v.push(act("ui.newGroup", "New Group", "folder").with(json!({ "component": id }))); v.push(Item::sep()); v.push(cmd(app, "browser.expand_all", "Expand All").with(json!({ "component": id }))); v.push(cmd(app, "browser.collapse_all", "Collapse All").with(json!({ "component": id }))); v } /// Explode Text (#1842): the selected text's outlines become normal sketch lines, arcs and /// curves, no longer tied to the text, so they can be picked, trimmed and edited one by one. fn explode_text(app: &SolveApp) -> Option { let link = crate::sketch_text::selected_link(app)?; Some(cmd(app, "sketch.break_link", "Explode Text").with(json!({ "link": link }))) } fn alignment_items(selection: &[Sel]) -> Vec { let Some(points) = crate::selection::alignment_points(selection) else { return Vec::new() }; vec![ act("ui.horizontalConstraint", "Horizontal Constraint", "c_hv") .with(json!({"points": points, "mode": "horizontal", "if_redundant": "refuse"})), act("ui.verticalConstraint", "Vertical Constraint", "c_hv").with(json!({"points": points, "mode": "vertical", "if_redundant": "refuse"})), ] } /// Sketch entity items: construction, fix, delete, dimension and the constraints the selection /// can take. fn sketch_entity_items(app: &SolveApp) -> Vec { use solidcraft_engine::sketch::{ConstraintKind, CurveKind}; let Some(sid) = app.session.active_sketch else { return Vec::new() }; let st = app.session.world_state(); let Some(ss) = st.sketch(sid) else { return Vec::new() }; if app.session.selection.iter().any(|sel| matches!(sel, Sel::SketchMidpoint { .. })) { return alignment_items(&app.session.selection); } let mut lines = Vec::new(); let mut rounds = Vec::new(); let mut curves = Vec::new(); let mut points = Vec::new(); // Selection order: a two-entity constraint keeps the first and moves the second. let mut picked: Vec = Vec::new(); for s in &app.session.selection { match s { Sel::SketchCurve { id, .. } => { picked.push(id.clone()); curves.push(id.clone()); match ss.sketch.curve_index(id).and_then(|i| ss.sketch.curves.get(i)).map(|c| &c.kind) { Some(CurveKind::Line { .. }) => lines.push(id.clone()), Some(CurveKind::Circle { .. } | CurveKind::Arc { .. }) => rounds.push(id.clone()), _ => {} } } Sel::SketchPoint { id } => { picked.push(id.clone()); points.push(id.clone()); } _ => {} } } // Dimensions (#320): a selected dimension switches between driving and driven through the // engine's `sketch.toggle_driven`, which takes one constraint, so the item appears for a // single selected dimension. Non-dimension constraints (coincident, tangent, ...) have no // driven state and get no item. let dims: Vec = app .session .selection .iter() .filter_map(|s| match s { Sel::SketchConstraint { id } => Some(id.clone()), _ => None, }) .filter(|id| ss.sketch.constraints.iter().any(|c| &c.id == id && c.kind.value().is_some())) .collect(); let mut v = Vec::new(); if curves.is_empty() && points.is_empty() { if dims.len() == 1 { v.push(cmd(app, "sketch.toggle_driven", "Toggle Driven Dimension").with(json!({ "constraint": dims[0] }))); // A circle's or an arc's radius or diameter switches to the other one (#7499). let round = |c: usize| matches!(ss.sketch.curves.get(c).map(|c| &c.kind), Some(CurveKind::Circle { .. } | CurveKind::Arc { .. })); if ss .sketch .constraints .iter() .any(|k| k.id == dims[0] && matches!(k.kind, ConstraintKind::Radius { c, .. } | ConstraintKind::Diameter { c, .. } if round(c))) { v.push(cmd(app, "sketch.toggle_diameter", "Toggle Radius / Diameter").with(json!({ "constraint": dims[0] }))); } } if app.session.selection.iter().any(|s| matches!(s, Sel::SketchConstraint { .. })) { v.push(act("ui.delete", "Delete", "delete").key("Del")); v.push(Item::sep()); } if crate::sketch_text::selected_entity(app).is_some() { v.push(cmd(app, "sketch.edit_text", "Edit Text")); v.extend(explode_text(app)); } v.push(cmd(app, "sketch.line", "Line")); v.push(cmd(app, "sketch.rectangle.two_point", "Rectangle")); v.push(cmd(app, "sketch.circle.center", "Circle")); v.push(cmd(app, "sketch.dimension", "Sketch Dimension")); v.push(Item::sep()); v.push(act("ui.paste", "Paste", "paste").key("Ctrl+V").on(app.session.sketch_clipboard.is_some())); return v; } let ents: Vec = curves.iter().chain(points.iter()).cloned().collect(); for pattern in &ss.sketch.patterns { if ents.iter().any(|id| pattern.contains(id)) || app.session.selection.iter().filter_map(|sel| crate::sketch_modify_ui::point_id(&app.session, sel)).any(|id| pattern.contains(id)) { v.push(act("ui.editSketchPattern", "Edit Sketch Pattern", "sketch_circ_pattern").with(json!({"pattern":pattern.id}))); } } if crate::sketch_text::selected_entity(app).is_some() { v.push(cmd(app, "sketch.edit_text", "Edit Text")); v.extend(explode_text(app)); } v.push(cmd(app, "sketch.move", "Move/Copy").key("M")); v.push(cmd(app, "sketch.transform", "Transform").key("G")); if !curves.is_empty() { v.push(cmd(app, "sketch.construction", "Normal / Construction").with(json!({ "curves": curves }))); } // Infinite lines (#1359): the selected lines switch together. let lines: Vec = curves .iter() .filter(|id| { ss.sketch .curve_index(id) .and_then(|i| ss.sketch.curves.get(i)) .is_some_and(|c| matches!(c.kind, solidcraft_engine::sketch::CurveKind::Line { .. })) }) .cloned() .collect(); if !lines.is_empty() { v.push(cmd(app, "sketch.infinite", "Infinite Line").with(json!({ "curves": lines }))); } if curves.len() == 1 && ss.sketch.offset_distance(&curves[0]).is_some() { v.push(cmd(app, "sketch.offset.break", "Break Offset Association").with(json!({"curve":curves[0]}))); } // #6533: a fit point on a fit point spline, where the menu was opened over it. if let [curve] = curves.as_slice() && ss .sketch .curve_index(curve) .and_then(|i| ss.sketch.curves.get(i)) .is_some_and(|c| matches!(c.kind, CurveKind::Spline { control: false, .. })) && let Some(at) = menu_sketch_point(app, &ss.plane) { v.push(cmd(app, "sketch.spline.insert_point", "Add Spline Point").with(json!({"curve": curve, "at": [at.x, at.y]}))); } // #8224: any spline of the sketch's own runs the other way. if let [curve] = curves.as_slice() && ss .sketch .curve_index(curve) .and_then(|i| ss.sketch.curves.get(i)) .is_some_and(|c| matches!(c.kind, CurveKind::Spline { .. }) && c.link.is_none()) { v.push(cmd(app, "sketch.spline.reverse", "Reverse Spline Direction").with(json!({ "curve": curve }))); } v.push(act("ui.fix", "Fix/Unfix", "c_fix").with(json!({ "entities": ents }))); // The clipboard beside Delete, as in every menu. v.push(act("ui.cut", "Cut", "cut").key("Ctrl+X")); v.push(act("ui.copy", "Copy", "copy").key("Ctrl+C")); v.push(act("ui.paste", "Paste", "paste").key("Ctrl+V").on(app.session.sketch_clipboard.is_some())); v.push(act("ui.delete", "Delete", "delete").key("Del")); v.push(cmd(app, "sketch.dimension", "Sketch Dimension").with(json!({ "entities": ents })).on(ents.len() <= 2)); // One arc alone: Sketch Dimension gives its radius, this its length along the curve (#6039). if let [arc] = ents.as_slice() && ss.sketch.curve_index(arc).and_then(|i| ss.sketch.curves.get(i)).is_some_and(|c| matches!(c.kind, CurveKind::Arc { .. })) { v.push(cmd(app, "sketch.dimension", "Arc Length Dimension").with(json!({ "entities": [arc], "type": "arc_length" }))); } let mut c = Vec::new(); let n = ents.len(); let (l, r, p) = (lines.len(), rounds.len(), points.len()); if l == 1 && n == 1 { c.push(cmd(app, "sketch.constraint.horizontal_vertical", "Horizontal/Vertical").with(json!({ "line": lines[0] }))); } if p == 2 && n == 2 { c.push(cmd(app, "sketch.constraint.coincident", "Coincident").with(json!({ "a": points[0], "b": points[1] }))); c.extend(alignment_items(&app.session.selection)); } if p == 1 && curves.len() == 1 && n == 2 { c.push(cmd(app, "sketch.constraint.coincident", "Coincident").with(json!({ "a": picked[0], "b": picked[1] }))); if l == 1 { c.push(cmd(app, "sketch.constraint.midpoint", "MidPoint").with(json!({ "point": points[0], "line": lines[0] }))); // #617: the point can also be aligned with the line (a circle's centre with a square's edge). if let Some(align) = crate::tools::point_line_points(&ss.sketch, &json!(points[0]), &lines[0]) { c.push( act("ui.horizontalConstraint", "Horizontal Constraint", "c_hv") .with(json!({"points": align, "mode": "horizontal", "if_redundant": "refuse"})), ); c.push( act("ui.verticalConstraint", "Vertical Constraint", "c_hv") .with(json!({"points": align, "mode": "vertical", "if_redundant": "refuse"})), ); } } } if l == 2 && n == 2 { let ab = json!({ "a": lines[0], "b": lines[1] }); c.push(cmd(app, "sketch.constraint.parallel", "Parallel").with(ab.clone())); c.push(cmd(app, "sketch.constraint.perpendicular", "Perpendicular").with(ab.clone())); c.push(cmd(app, "sketch.constraint.collinear", "Collinear").with(ab.clone())); c.push(cmd(app, "sketch.constraint.equal", "Equal").with(ab.clone())); c.push(cmd(app, "sketch.constraint.midpoint", "MidPoint").with(ab)); } if r == 2 && n == 2 { let ab = json!({ "a": rounds[0], "b": rounds[1] }); c.push(cmd(app, "sketch.constraint.concentric", "Concentric").with(ab.clone())); c.push(cmd(app, "sketch.constraint.equal", "Equal").with(ab.clone())); c.push(cmd(app, "sketch.constraint.tangent", "Tangent").with(ab)); } if l == 1 && r == 1 && n == 2 { c.push(cmd(app, "sketch.constraint.tangent", "Tangent").with(json!({ "a": picked[0], "b": picked[1] }))); } if p == 2 && l == 1 && n == 3 { c.push(cmd(app, "sketch.constraint.symmetry", "Symmetry").with(json!({ "a": points[0], "b": points[1], "line": lines[0] }))); } if !c.is_empty() { v.push(Item::heading("Constraints")); v.extend(c); } v } /// Where on the active sketch's plane the viewport menu was opened (sketch coordinates). fn menu_sketch_point(app: &SolveApp, plane: &solidcraft_engine::geom::Plane) -> Option { let (at, _) = app.menu.opened?; let proj = crate::viewport::projection(app, app.viewport.rect?); let (o, d) = proj.ray(at); Some(plane.to_local(plane.intersect_ray(o, d)?)) } // --------------------------------------------------------------------------------------------- // Running an item // --------------------------------------------------------------------------------------------- fn strs(p: &Value, k: &str) -> Vec { p.get(k).and_then(Value::as_array).map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default() } fn id_of(p: &Value, k: &str) -> Option { p.get(k).and_then(Value::as_u64) } /// Run a menu item (what a click on it does). `at` places a rename box. pub fn run_item(app: &mut SolveApp, item: &Item, at: Pos2) { if !item.enabled || item.is_sep() || item.is_heading() { return; } let p = item.params.clone().unwrap_or(Value::Null); let bodies = strs(&p, "bodies"); match item.id.as_str() { "appearance.library" if crate::render_workspace::active(app) => { app.start("appearance.library"); } "parts.resize" => { if let Some(component) = id_of(&p, "component") { crate::dialogs_part_size::open(app, component); } else { app.start("parts.resize"); } } "ui.repeat" => { app.repeat_last(); } "ui.selectOther" => { // The list picks instead of the right-click. if let Some((opened, before, made)) = app.menu.picked.take() && opened == at && app.session.selection == made { let _ = app.run("select.set", json!({ "items": before })); } let held = app.menu.opened.filter(|(opened, _)| *opened == at).map(|(_, held)| held).unwrap_or_default(); crate::select_other::open(app, at, held); } "ui.delete" if item.params.is_some() => crate::delete::request(app, p), "ui.delete" => delete(app), "ui.horizontalConstraint" | "ui.verticalConstraint" => { let selection = app.session.selection.clone(); let keep_midpoints = selection.iter().any(|s| matches!(s, Sel::SketchMidpoint { .. })); if app.run("sketch.constraint.horizontal_vertical", p).is_ok() && keep_midpoints { let _ = app.run("select.set", json!({"items": selection})); } } "ui.finishSketch" => app.finish_sketch(), "ui.cancelSketch" => app.cancel_sketch(), "ui.relinkSource" => { if let Some(component) = id_of(&p, "component") { crate::linked_source::start(app, component); } } "ui.extractComponent" => { if let Some(component) = id_of(&p, "component") { crate::linked_source::extract(app, component); } } "ui.copy" => drop(crate::edit_clipboard::copy(app)), "ui.copyDesign" => drop(crate::edit_clipboard::copy_design(app)), "ui.cut" => drop(crate::edit_clipboard::cut(app)), "ui.paste" | "ui.pasteNew" => { // A component's menu pastes into it (that placement); the others into the active one. let into = id_of(&p, "component").map(|c| { let path = p.get("path").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_u64).collect()); (c, path.unwrap_or_else(|| app.session.doc.first_path(c))) }); match id_of(&p, "group") { // A Bodies group's menu: into the group too. Some(group) => { let folder = p.get("folder").and_then(Value::as_str).unwrap_or("bodies"); let _ = crate::edit_clipboard::paste_into_group(app, Some(at), into, Some(group), folder); } None => drop(crate::edit_clipboard::paste_into(app, Some(at), item.id == "ui.pasteNew", into)), } } "ui.editSketchPattern" => { if let Some(id) = p.get("pattern").and_then(Value::as_str) { crate::sketch_modify_ui::edit_pattern(app, id); } } "ui.hide" => { // Through the command, so hiding is one undo step (#2219). let _ = app.run("browser.visibility", json!({ "items": bodies, "visible": false })); } "ui.show" => { let _ = app.run("browser.visibility", json!({ "items": bodies, "visible": true })); } "ui.showAll" => { // One command and so one undo step: everything shown, folders and placements included. let _ = app.run("browser.visibility", json!({ "folder": "all", "visible": true })); } "ui.isolate" => { // The picked bodies stay (shown first if they were hidden), everything else goes. let others: Vec = app.session.world_state().bodies.iter().map(|b| b.name.clone()).filter(|b| !bodies.contains(b)).collect(); if !bodies.is_empty() { let _ = app.run("browser.visibility", json!({ "items": bodies, "visible": true })); } if !others.is_empty() { let _ = app.run("browser.visibility", json!({ "items": others, "visible": false })); } } "ui.lock" => { let locked = bodies.iter().all(|b| app.session.visibility.locked_bodies.contains(b)); if locked { app.session.visibility.locked_bodies.retain(|b| !bodies.contains(b)); } else { app.session .visibility .locked_bodies .extend(bodies.into_iter().filter(|b| !app.session.visibility.locked_bodies.contains(b)).collect::>()); } } "ui.moveBodies" => { let items: Vec = bodies.iter().map(|b| json!({"type": "body", "name": b})).collect(); let _ = app.run("select.set", json!({ "items": items })); app.start("solid.move"); } "ui.rename" => { let what = if let Some(b) = p.get("body").and_then(Value::as_str) { RenameWhat::Body(b.to_string()) } else if let Some(f) = id_of(&p, "feature") { RenameWhat::Feature(f) } else if let Some(c) = id_of(&p, "component") { RenameWhat::Component(c) } else if let Some(g) = id_of(&p, "group") { RenameWhat::Group(g) } else if let Some(c) = id_of(&p, "canvas") { RenameWhat::Canvas(c) } else if let Some(v) = p.get("view").and_then(Value::as_str) { RenameWhat::View(v.to_string()) } else if let Some(j) = id_of(&p, "joint") { RenameWhat::Joint(j) } else { return; }; start_rename(app, what, at); } "ui.properties" => { let command = if p.get("occurrence").is_some() { "occurrence.properties" } else if p.get("component").is_some() { "component.properties" } else { "inspect.measure" }; let params = if command == "inspect.measure" { json!({ "bodies": bodies }) } else { p.clone() }; match app.session.execute(command, ¶ms) { Ok(v) => { let title = v["name"] .as_str() .map(str::to_string) .unwrap_or_else(|| if bodies.len() == 1 { bodies.join("") } else { format!("{} bodies", bodies.len()) }); app.menu.props = Some((title, v)); } Err(e) => app.set_status(e.to_string(), true), } } "ui.designProperties" => app.start("document.metadata"), "ui.export" => { let name = bodies.first().cloned().unwrap_or_else(|| app.session.doc.name.clone()); app.pick_save_command(&format!("{name}.step"), &["step", "stp", "igs", "stl", "3mf", "obj"], "file.export", json!({"bodies": bodies})); } "ui.findBrowser" => { if let Some(b) = p.get("body").and_then(Value::as_str) { crate::browser::reveal_body(app, b); let _ = app.run("select.set", json!({"items": [{"type": "body", "name": b}]})); } } "ui.findTimeline" => { let body = p.get("body").and_then(Value::as_str); let f = id_of(&p, "feature").or_else(|| body.and_then(|b| body_feature(app, b))); if let Some(f) = f { if app.preferences.history_in_browser { crate::browser::reveal_in_history(app, f); } else { app.ui.show_timeline = true; crate::timeline_left::reveal_feature(app, f); // From a face or body, the Browser shows the feature in that body's copy. From a // sketch, plane or feature row there is no body: that row is the Browser's view. if let Some(body) = body { crate::browser::reveal_feature(app, f, body); } } let _ = app.run("select.set", json!({"items": [{"type": "feature", "id": f}]})); app.tree.timeline_reveal = Some(f); } } "ui.tangentChain" => tangent_chain(app), "ui.origin" => app.set_origin_shown(!app.origin_shown()), "ui.clear" => drop(app.run("select.clear", json!({}))), "ui.unsection" => { app.tree.hidden_section = None; drop(app.run("inspect.section", json!({"clear": true}))); } "ui.editSection" => crate::dialogs::edit_section(app), "ui.sectionVisible" => crate::browser::set_section_shown(app, p.get("visible").and_then(Value::as_bool).unwrap_or(true)), "ui.fit" => app.animate_view("fit"), "ui.home" => app.animate_view("home"), // One command for the whole selection: all fixed unless all already are. "ui.fix" => drop(app.run("sketch.constraint.fix", json!({ "entities": strs(&p, "entities") }))), "ui.editSketch" => { if let Some(id) = id_of(&p, "sketch") { app.edit_sketch(id); } } "ui.redefineSketch" => { if let Some(id) = id_of(&p, "sketch") { crate::browser::redefine_sketch(app, id); } } "ui.hideSketch" | "ui.showSketch" => { if let Some(id) = id_of(&p, "sketch") { crate::browser::set_sketch_visible(app, id, item.id == "ui.showSketch"); } } "ui.sketchDims" => { if let Some(id) = id_of(&p, "sketch") { if app.session.visibility.shown_dimensions.contains(&id) { app.session.visibility.shown_dimensions.retain(|x| *x != id); } else { app.session.visibility.shown_dimensions.push(id); } } } "ui.sketchProfile" => { if let Some(id) = id_of(&p, "sketch") { if app.session.visibility.hidden_profiles.contains(&id) { app.session.visibility.hidden_profiles.retain(|x| *x != id); } else { app.session.visibility.hidden_profiles.push(id); } } } "ui.activate" => { if id_of(&p, "component").is_some() { let _ = app.run("component.activate", p); } } "ui.editInPlace" => { if let Some(component) = id_of(&p, "component") { let path = p["path"].as_array().map(|path| path.iter().filter_map(Value::as_u64).collect()); crate::edit_in_place::open(app, component, path); } } "ui.openLinkedDesign" => { let Some(component) = id_of(&p, "component") else { return }; let links = match app.session.execute("component.links", &json!({})) { Ok(links) => links, Err(e) => { app.set_status(e.to_string(), true); return; } }; let Some(link) = links["links"].as_array().and_then(|links| links.iter().find(|link| link["component"] == component)) else { app.set_status("This component is no longer linked to a design", true); return; }; // A link on a network server not allowed yet asks first. crate::network_prompt::open_linked(app, link); } "ui.moveOccurrence" => { if let Some(o) = id_of(&p, "occurrence") { let mut movement = crate::browser::OccMove::new(o); movement.had_pending = app.session.pending_moves.contains_key(&o); movement.path = p.get("path").and_then(Value::as_array).map(|p| p.iter().filter_map(Value::as_u64).collect()).unwrap_or_default(); movement.baseline = app .session .pending_moves .get(&o) .copied() .or_else(|| app.session.doc.occurrences.iter().find(|occ| occ.id == o).map(|occ| occ.transform)); app.tree.occurrence_move = Some(movement); } } "ui.isolateOccurrence" => { let _ = app.run("browser.visibility", json!({"visible": true, "paths": [p["path"]], "isolate": true})); } "ui.canvasVisible" => drop(app.run("canvas.edit", p)), "ui.toolbarPin" | "ui.toolbarRemove" | "ui.toolbarReset" | "ui.toolbarCustomize" | "ui.shortcutPin" => { crate::toolbar_custom::run(app, &item.id, &p) } "ui.historyPlayButton" => { if let Err(e) = crate::prefs::set(app, &json!({ "history_play_button": p["show"] })) { app.set_status(e, true); } } "ui.workspace" | "ui.workspace.design" | "ui.workspace.render" => { if let Some(workspace) = p.get("workspace").and_then(Value::as_str) && let Err(e) = crate::render_workspace::enter(app, workspace == "render") { app.set_status(e, true); } } "ui.findJoint" => { if let Some(id) = id_of(&p, "joint") { crate::dialogs_assembly::find_joint(app, id); } } "ui.editJoint" | "ui.driveJoint" | "ui.animateJoint" => { if let Some(id) = id_of(&p, "joint") { let d = match item.id.as_str() { "ui.editJoint" => crate::dialogs_assembly::edit_joint(app, id), "ui.animateJoint" => crate::dialogs_assembly::animate_joint(app, id), _ => crate::dialogs_assembly::drive_joint(app, id), }; if let Some(d) = d { app.tool = None; app.dialog = Some(d); } } } "ui.newView" => drop(crate::browser::save_view(app, None)), "ui.restoreView" => { if let Some(v) = p.get("view").and_then(Value::as_str) { crate::browser::restore_view(app, v); } } "ui.updateView" => { if let Some(v) = p.get("view").and_then(Value::as_str) { crate::browser::save_view(app, Some(v)); } } "ui.folderVisible" => { if let Some(key) = p.get("key").and_then(Value::as_str) { crate::browser::toggle_folder(app, key); } } "ui.originAll" => { app.set_origin_shown(true); let _ = app.run("browser.visibility", json!({ "items": ["O", "X", "Y", "Z", "XY", "XZ", "YZ"], "visible": true })); } "ui.originPart" => { let show = p.get("show").and_then(Value::as_bool).unwrap_or(true); let keys = strs(&p, "keys"); if !keys.is_empty() { let _ = app.run("browser.visibility", json!({ "items": keys, "visible": show })); } } "ui.editFeature" => { if let Some(f) = id_of(&p, "feature") { app.edit_feature(f); } } "ui.appearance" => { if item.params.is_some() { let items: Vec = bodies.iter().map(|b| json!({"type": "body", "name": b})).collect(); let _ = app.run("select.set", json!({ "items": items })); } app.start("appearance.assign"); if let Some(name) = id_of(&p, "component").and_then(|id| app.session.doc.components.iter().find(|c| c.id == id).map(|c| c.name.clone())) && let Some(d) = app.dialog.as_mut() && let crate::dialogs::Kind::Appearance(k) = &mut d.kind { if let Some(id) = id_of(&p, "component") && let Some(look) = app.session.doc.appearances.components.get(&id) { k.color = look.color; k.opacity = look.opacity; k.pbr = look.pbr; k.look = Some(look.name.clone()); } k.component = Some(name); } } "ui.material" => { let items: Vec = bodies.iter().map(|b| json!({"type": "body", "name": b})).collect(); let _ = app.run("select.set", json!({ "items": items })); app.start("material.assign"); } "ui.saveMesh" | "ui.sendToSlicer" => { let items: Vec = bodies.iter().map(|b| json!({"type": "body", "name": b})).collect(); let _ = app.run("select.set", json!({ "items": items })); app.start(if item.id == "ui.saveMesh" { "file.save_mesh" } else { "file.send_to_slicer" }); } "ui.exportDxf" => { if let Some(id) = id_of(&p, "sketch") { let name = app.session.doc.feature(id).map(|f| f.name.clone()).unwrap_or_default(); app.pick_save_command(&format!("{name}.dxf"), &["dxf"], "sketch.export_dxf", json!({"sketch": id})); } } "ui.extrudeSketch" => { if let Some(id) = id_of(&p, "sketch") { let n = app.session.world_state().sketch(id).map_or(0, |s| s.profiles.len()); let items: Vec = (0..n).map(|i| json!({"type": "profile", "sketch": id, "index": i})).collect(); let _ = app.run("select.set", json!({ "items": items })); app.start("solid.extrude"); } } "ui.lookAt" => { let st = app.session.world_state(); if let Some(ss) = id_of(&p, "sketch").and_then(|id| st.sketch(id)) { let to = crate::dialogs::onto_sketch(app.cam.looking_from(ss.plane.normal()), ss); app.animate_to(to); } else if let Some(plane) = p.get("plane").and_then(Value::as_str).and_then(solidcraft_engine::geom::Plane::named) { let mut to = app.cam.looking_from(crate::dialogs::facing(app, plane.normal(), true)); to.target = plane.origin; app.animate_to(to); } else if p.get("sketch").is_none() { crate::viewport::look_at_selection(app); } } "ui.nav" => { app.viewport.nav = match p.get("mode").and_then(Value::as_str) { Some("pan") => Some(crate::viewport::NavMode::Pan), Some("zoom") => Some(crate::viewport::NavMode::Zoom), Some("orbit") => Some(crate::viewport::NavMode::Orbit), _ => None, }; } "ui.editPointCloud" => { if let Some(c) = id_of(&p, "cloud") { app.tree.cloud_panel = Some(crate::browser::CloudPanel::new(app, c)); } } "ui.editCanvas" | "ui.calibrateCanvas" => { if let Some(c) = id_of(&p, "canvas") { app.tree.canvas_panel = Some(crate::browser::CanvasPanel::new(app, c, item.id == "ui.calibrateCanvas")); } } "ui.newGroup" | "ui.ungroup" | "ui.groupSelected" => crate::browser::group_action(app, &item.id, &p), // A plane's Create Sketch is the toolbar's with that plane picked first: it replaces a // dialog in progress, and the dialog starts the sketch at once, facing the plane. "sketch.create" if item.params.is_some() => { if app.run("select.set", json!({ "items": [{"type": "plane", "name": p.get("plane")}] })).is_ok() { app.start("sketch.create"); } } // They recompute the history from the changed feature on: off the frame, as the timeline does. "timeline.suppress" | "timeline.roll_to" if item.params.is_some() => drop(app.run_heavy(&item.id, p)), id if item.params.is_some() => { let _ = app.run(id, p); } id => app.start(id), } } /// Delete what is selected: sketch entities, features, and bodies (a Remove feature). pub fn delete(app: &mut SolveApp) { crate::delete::delete_selection(app); } /// A shortcut key pressed while a menu is open: the row of that menu showing `key` runs on the /// menu's target, as a click on it would, and the menu closes. A folder, the Origin folder or an /// origin plane is not selected by the right-click that opens its menu, so the key's own action /// (V on the selection) would miss it. Returns whether the open menu has a row for the key; a /// disabled row takes the key and does nothing, as a click on it does. pub fn press_shortcut(app: &mut SolveApp, key: &str) -> bool { let Some(at) = app.viewport.context_menu else { return false }; let target = app.menu.target.clone(); let Some(item) = items(app, &target).into_iter().find(|i| i.shortcut == key && i.children.is_empty()) else { return false }; if item.enabled { close(app); run_item(app, &item, at); } true } /// Show/Hide (the V key): what is selected in the viewport or picked in the browser flips its /// visibility (bodies, faces' and edges' bodies, sketches, construction and origin planes and /// axes, components' bodies, canvases, joints' glyphs). When some are shown and some hidden, all are hidden. pub fn toggle_visibility(app: &mut SolveApp) { use solidcraft_engine::doc::FeatureKind; let paths: Vec> = app.session.selection.iter().filter_map(|s| if let Sel::Occurrence { path } = s { Some(path.clone()) } else { None }).collect(); if !paths.is_empty() { let visible = !paths.iter().any(|p| !app.session.occurrence_hidden(p)); let _ = app.run("browser.visibility", json!({"visible": visible, "paths": paths})); } let mut bodies: Vec = touched_bodies(app); for c in app.tree.picked_components.clone() { bodies.extend(component_bodies(app, c)); } let sketches: Vec = app .session .selection .iter() .filter_map(|s| if let Sel::Feature { id } = s { Some(*id) } else { None }) .filter(|id| app.session.doc.feature(*id).is_some_and(|f| matches!(f.kind, FeatureKind::Sketch { .. }))) .collect(); let origin: Vec = app .session .selection .iter() .filter_map(|s| match s { Sel::Plane { name } | Sel::Axis { name } | Sel::ConstructionPoint { name } => Some(name.clone()), _ => None, }) .collect(); let canvases = app.tree.picked_canvases.clone(); let joints = app.tree.picked_joints.clone(); let any_visible = bodies.iter().any(|b| !app.session.visibility.hidden_bodies.contains(b)) || joints.iter().any(|j| app.session.joint_visible(*j)) || sketches.iter().any(|s| crate::browser::sketch_visible(app, *s)) || origin.iter().any(|o| !app.session.visibility.hidden_origin.contains(o)) || app.session.doc.canvases.iter().any(|c| canvases.contains(&c.id) && c.visible); let hide = any_visible; // One command for the picked bodies, construction items and sketches: the same step the // menus run, so hiding from the viewport (V) is undone like any other hide (#2219). let mut items: Vec = bodies.iter().map(|b| json!(b)).collect(); items.extend(origin.iter().map(|o| json!(o))); items.extend(sketches.iter().map(|s| json!(s))); if !items.is_empty() { let _ = app.run("browser.visibility", json!({ "items": items, "visible": !hide })); } if !joints.is_empty() { let _ = app.run("browser.visibility", json!({ "joints": joints, "visible": !hide })); } for c in canvases { let _ = app.run("canvas.edit", json!({ "canvas": c, "visible": !hide })); } } /// Rename what is selected (F2): one body, sketch or feature, construction plane, component /// picked in the browser, or canvas. pub fn rename_selection(app: &mut SolveApp, at: Pos2) -> bool { let what = match (app.session.selection.as_slice(), app.tree.picked_components.as_slice(), app.tree.picked_canvases.as_slice()) { ([Sel::Body { name }], [], []) => RenameWhat::Body(name.clone()), ([Sel::Feature { id }], [], []) => RenameWhat::Feature(*id), ([Sel::Occurrence { path }], [], []) => match app.session.occurrence_placement(path) { Ok(p) => RenameWhat::Component(p.component), Err(_) => return false, }, ([Sel::Plane { name } | Sel::Axis { name } | Sel::ConstructionPoint { name }], [], []) => match app.session.doc.find_feature(name) { Some(f) => RenameWhat::Feature(f.id), None => return false, }, ([], [c], []) => RenameWhat::Component(*c), ([], [], [c]) => RenameWhat::Canvas(*c), _ => return false, }; start_rename(app, what, at); true } /// Add the edges that continue the selected edges smoothly to the selection. fn tangent_chain(app: &mut SolveApp) { let st = app.session.world_state(); let mut out: Vec = Vec::new(); for s in &app.session.selection { let Sel::Edge { body, index, .. } = s else { continue }; let Some(b) = st.body(body) else { continue }; let m = b.mesh(); for i in m.tangent_chain(*index, 2f64.to_radians()) { let Some(e) = m.edges.get(i) else { continue }; let Some(mid) = e.get(e.len() / 2).copied() else { continue }; let x = Sel::Edge { body: body.clone(), index: i, point: mid }; if !out.iter().any(|y| matches!(y, Sel::Edge { body: bb, index: ii, .. } if bb == body && *ii == i)) { out.push(x); } } } if !out.is_empty() { let _ = app.run("select.set", json!({ "items": out })); } } pub fn start_rename(app: &mut SolveApp, what: RenameWhat, at: Pos2) { let doc = &app.session.doc; let text = match &what { RenameWhat::Body(b) => b.clone(), RenameWhat::Feature(f) => doc.feature(*f).map(|f| f.name.clone()).unwrap_or_default(), RenameWhat::Component(0) => doc.name.clone(), RenameWhat::Component(c) => doc.components.iter().find(|x| x.id == *c).map(|x| x.name.clone()).unwrap_or_default(), RenameWhat::Group(g) => crate::browser::group_name(app, *g).unwrap_or_default(), RenameWhat::TimelineGroup(g) => doc.timeline_groups.iter().find(|group| group.id == *g).map(|group| group.name.clone()).unwrap_or_default(), RenameWhat::Canvas(c) => doc.canvases.iter().find(|x| x.id == *c).map(|x| x.name.clone()).unwrap_or_default(), RenameWhat::View(v) => v.clone(), RenameWhat::Joint(j) => doc.assembly.joints.iter().find(|x| x.id == *j).map(|x| x.name.clone()).unwrap_or_default(), }; app.menu.rename = Some(Rename { what, text, at, focused: false, inline: false }); } pub(crate) fn commit_rename(app: &mut SolveApp, r: &Rename) { let name = r.text.trim().to_string(); if name.is_empty() { return; } match &r.what { RenameWhat::Body(old) => { // The command renames the body where it is hidden or locked too. drop(app.run_heavy("body.rename", json!({ "body": old, "name": name }))); } RenameWhat::Feature(f) => drop(app.run("timeline.rename", json!({ "feature": f, "name": name }))), RenameWhat::Component(c) => drop(app.run("component.rename", json!({ "component": c, "name": name }))), RenameWhat::Group(g) => crate::browser::group_action(app, "ui.renameGroup", &json!({ "group": g, "name": name })), RenameWhat::TimelineGroup(g) => drop(app.run("timeline.rename_group", json!({ "group": g, "name": name }))), RenameWhat::Canvas(c) => drop(app.run("canvas.edit", json!({ "canvas": c, "name": name }))), RenameWhat::View(v) => drop(app.run("view.rename", json!({ "view": v, "name": name }))), RenameWhat::Joint(j) => drop(app.run("joint.edit", json!({ "joint": j, "name": name }))), } } // --------------------------------------------------------------------------------------------- // Opening and showing // --------------------------------------------------------------------------------------------- /// Right-clicking the MID of an already selected edge keeps that geometry selection. fn context_target_selected(selection: &[Sel], target: &Sel) -> bool { selection.iter().any(|selected| { crate::selection::same_item(selected, target) || matches!((selected, target), (Sel::SketchCurve { id: a, .. }, Sel::SketchMidpoint { id: b }) if a == b) }) } /// The body a viewport pick belongs to: a face, edge or vertex carries its body's name. The /// origin point is a vertex of no body, so an empty name is not a body. fn pick_body(sel: &Sel) -> Option<&str> { match sel { Sel::Face { body, .. } | Sel::Edge { body, .. } | Sel::Vertex { body, .. } if !body.is_empty() => Some(body), _ => None, } } /// Is the pick already part of the selection? Beside the item itself (and an edge's midpoint, /// above), a face, edge or vertex of a selected body counts, whether the body is selected on its /// own or through an occurrence: the menu is then about the bodies, and the right-click leaves /// the selection alone (#5849). fn in_selection(app: &SolveApp, sel: &Sel) -> bool { if context_target_selected(&app.session.selection, sel) { return true; } let Some(body) = pick_body(sel) else { return false }; app.session.selection.iter().any(|x| match x { Sel::Body { name } => name == body, Sel::Occurrence { path } => app.session.occurrence_bodies(path, true).is_ok_and(|b| b.iter().any(|n| n == body)), _ => false, }) } /// Open the viewport menu at a screen position. A right-click on something not selected /// selects it first, so the menu is about what is under the cursor; a face or edge already in a /// multi-selection keeps the whole selection (#3733), as does one of a selected body (#5849). `held`: the keys held at that click. pub fn open(app: &mut SolveApp, at: Pos2, held: crate::tool_modifiers::Held) { app.menu.opened = Some((at, held)); app.menu.picked = None; let before = app.session.selection.clone(); app.menu.over_geometry = app.viewport.hover.is_some(); // A right-click leaves a plane unselected, but the menu offers a sketch on it. app.menu.plane = app.viewport.hover.clone().and_then(|h| crate::viewport::candidate(app, &[h])).and_then(|(_, sel)| match sel { Sel::Plane { name } => Some(name), _ => None, }); crate::select_other::close(app); if let Some(sel) = crate::viewport::sketch_constraint_at(app, at, app.viewport.hover.as_ref()) { if !in_selection(app, &sel) { let _ = app.run("select.set", json!({ "items": [sel] })); app.menu.picked = Some((at, before, app.session.selection.clone())); } } else if app.session.active_sketch.is_none() && let Some(h) = app.viewport.hover.clone() && let Some((_, sel)) = crate::viewport::candidate(app, &[h]) && !in_selection(app, &sel) && !matches!(sel, Sel::Plane { .. } | Sel::Axis { .. }) { let _ = app.run("select.set", json!({ "items": [sel] })); app.menu.picked = Some((at, before, app.session.selection.clone())); } else if app.session.active_sketch.is_some() && let Some(h) = app.viewport.hover.clone() && let Some((_, sel)) = crate::viewport::candidate(app, &[h]) && (matches!(sel, Sel::SketchCurve { .. } | Sel::SketchPoint { .. } | Sel::SketchMidpoint { .. }) || crate::sketch_text::entity_for_selection(app, &sel).is_some()) && !in_selection(app, &sel) { let _ = app.run("select.set", json!({ "items": [sel] })); app.menu.picked = Some((at, before, app.session.selection.clone())); } open_for(app, at, Target::Viewport); } /// Open a menu for a target (the radial ring only for the viewport). pub fn open_for(app: &mut SolveApp, at: Pos2, target: Target) { app.menu.key_row = None; app.menu.submenu = None; app.menu.submenu_key = None; app.menu.submenu_leave = None; app.menu.radial = target == Target::Viewport && app.preferences.radial_context_menu; app.menu.target = target; app.menu.flick = false; app.menu.opener = None; app.menu.shown = false; app.viewport.context_menu = Some(at); } /// A button's menu: a click opens it, and a click on the same button while it is open closes it. pub fn toggle_for(app: &mut SolveApp, opener: Rect, at: Pos2, target: Target) { if app.viewport.context_menu.is_some() && app.menu.target == target && app.menu.opener == Some(opener) { close(app); } else { open_for(app, at, target); app.menu.opener = Some(opener); } } pub fn close(app: &mut SolveApp) { app.viewport.context_menu = None; app.menu.flick = false; app.menu.opener = None; } /// Open the menu at a point for automation: the pointer moves there first so what is under it /// counts, then the menu opens on a later frame. pub fn request_open(app: &mut SolveApp, at: Pos2, target: Target) { app.synthetic.push(egui::Event::PointerMoved(at)); app.menu.pending = Some((at, target)); } /// The open menu as JSON (for `ui.menu`). pub fn describe(app: &SolveApp) -> Value { let Some(at) = app.viewport.context_menu else { return json!({ "open": false, "pending": app.menu.pending.is_some() }); }; let radial = if app.menu.radial { radial_items(app) } else { Vec::new() }; let describe_items = |items: Vec| { items .into_iter() .map(|item| { let placeholder = !item.icon.is_empty() && crate::icon_svg::resolve(&item.icon).placeholder; let mut value = json!(item); value["placeholder"] = json!(placeholder); value }) .collect::>() }; json!({ "open": true, "at": [at.x, at.y], "target": app.menu.target, "radial": describe_items(radial), "items": describe_items(items(app, &app.menu.target)), "rename": app.menu.rename.as_ref().map(|r| r.text.clone()), }) } /// Pick an item of the open menu by id or label (for `ui.menuPick`). pub fn pick(app: &mut SolveApp, key: &str) -> Result { let Some(at) = app.viewport.context_menu else { return Err("no menu is open".into()) }; let target = app.menu.target.clone(); let mut all = if app.menu.radial { radial_items(app) } else { Vec::new() }; let roots = items(app, &target); all.extend(roots.iter().cloned()); all.extend(roots.into_iter().flat_map(|item| item.children)); let item = all.into_iter().find(|i| !i.is_sep() && !i.is_heading() && (i.id == key || i.label == key)).ok_or_else(|| format!("no menu item `{key}`"))?; if !item.enabled { return Err(format!("`{}` is disabled", item.label)); } close(app); run_item(app, &item, at); Ok(json!({ "ran": item.id, "label": item.label })) } /// Where the radial menu goes so its ring stays on screen. fn radial_center(at: Pos2, screen: Rect) -> Pos2 { let mx = RX + 4.0; let my = RY + 4.0; let x = if screen.width() > 2.0 * mx { at.x.clamp(screen.left() + mx, screen.right() - mx) } else { screen.center().x }; let y = if screen.height() > 2.0 * my { at.y.clamp(screen.top() + my, screen.bottom() - my) } else { screen.center().y }; pos2(x, y) } /// Height of a list of items as [`list_row`] draws them in [`menu_frame`] (margins and border). fn list_height(items: &[Item]) -> f32 { 14.0 + items .iter() .map(|i| { if i.is_sep() { 11.0 } else if i.is_heading() { 24.0 } else { 30.0 } }) .sum::() } /// Where the list goes next to a ring centred at `c`: below it when it fits, otherwise beside /// it (right, else left), kept on screen. fn list_place(c: Pos2, h: f32, screen: Rect) -> Pos2 { let below = c.y + RY + 12.0; if below + h <= screen.bottom() - 4.0 { return pos2((c.x - LIST_W / 2.0).clamp(screen.left() + 4.0, (screen.right() - LIST_W - 4.0).max(screen.left())), below); } let y = (c.y - h / 2.0).clamp(screen.top() + 4.0, (screen.bottom() - h - 4.0).max(screen.top())); let right = c.x + RX + 12.0; if right + LIST_W <= screen.right() - 4.0 { return pos2(right, y); } pos2((c.x - RX - 12.0 - LIST_W).max(screen.left() + 4.0), y) } /// Width of list menus. pub const LIST_W: f32 = 250.0; /// Where a menu of `size` opened at `at` goes: right of and below the point (`gap` away) when it /// fits in `screen`, flipped to the left or above it when it would run past that edge, and /// against the far edge when it fits on neither side. A flipped menu ends at the cursor, so it /// stays in view even when the window reaches past the screen (#1354). pub fn place(at: Pos2, gap: Vec2, size: Vec2, screen: Rect) -> Pos2 { let axis = |at: f32, gap: f32, len: f32, lo: f32, hi: f32| { if at + gap + len <= hi { at + gap } else if at - gap - len >= lo { at - gap - len } else { (hi - len).max(lo) } }; pos2(axis(at.x, gap.x, size.x, screen.left(), screen.right()), axis(at.y, gap.y, size.y, screen.top(), screen.bottom())) } /// The radial slot a pointer offset points at (none near the centre). fn sector(d: Vec2) -> Option { if d.length() < 22.0 { return None; } // Clockwise from the top (screen y points down). let a = d.x.atan2(-d.y).to_degrees(); let k = ((a + 360.0 + 22.5) / 45.0).floor() as i64; Some((k.rem_euclid(DIRS as i64)) as usize) } /// Press-and-hold of the right button in the viewport opens the menu; releasing over a /// direction picks it. fn track_hold(app: &mut SolveApp, ctx: &egui::Context) { if !app.preferences.radial_context_menu || crate::mouse_gesture::active(app) { app.menu.press = None; app.menu.flick = false; app.menu.radial = false; return; } let (pressed, down, released, pos, time) = ctx.input(|i| { ( i.pointer.button_pressed(egui::PointerButton::Secondary), i.pointer.secondary_down(), i.pointer.button_released(egui::PointerButton::Secondary), i.pointer.latest_pos(), i.time, ) }); let free = app.tool.is_none() && app.dialog.is_none() && app.preferences.nav != crate::prefs::OPENSCAD_NAV; if pressed && free && app.viewport.context_menu.is_none() && app.viewport.mouse.is_some() { app.menu.press = pos.map(|p| (p, time)); } if let Some((p0, t0)) = app.menu.press { let moved = pos.is_some_and(|p| p.distance(p0) > 5.0); if !down || moved { app.menu.press = None; } else if time - t0 > 0.35 { app.menu.press = None; open(app, p0, crate::tool_modifiers::Held::from_modifiers(ctx.input(|i| i.modifiers))); app.menu.flick = true; } else { ctx.request_repaint_after(std::time::Duration::from_millis(30)); } } if released && app.menu.flick { app.menu.flick = false; if let (Some(at), Some(p)) = (app.viewport.context_menu, pos) { let c = radial_center(at, ctx.content_rect()); if app.menu.radial && let Some(k) = sector(p - c) && p.distance(c) > 36.0 && let Some(item) = radial_items(app).into_iter().nth(k).filter(|i| i.enabled) { close(app); run_item(app, &item, at); } } } } /// Show the open menu, the rename box and the Properties window. pub fn show(app: &mut SolveApp, ctx: &egui::Context) { if let Some((at, target)) = app.menu.pending.clone() && app.synthetic.is_empty() { app.menu.pending = None; if target == Target::Viewport { open(app, at, crate::tool_modifiers::Held::default()) } else { open_for(app, at, target) } } crate::browser::dims_overlay(app, ctx); track_hold(app, ctx); show_rename(app, ctx); crate::design_properties::show_object(app, ctx); let Some(at) = app.viewport.context_menu else { return }; let screen = ctx.content_rect(); let target = app.menu.target.clone(); let list = items(app, &target); let mut picked: Option = None; let pointer = ctx.input(|i| i.pointer.latest_pos()); let mut inside = app.menu.opener.is_some_and(|r| pointer.is_some_and(|p| r.contains(p))); let list_at = if target == Target::Workspace { pos2(at.x.clamp(screen.left(), (screen.right() - 470.0).max(screen.left())), at.y) } else if app.menu.radial { let c = radial_center(at, screen); let radial = radial_items(app); let area = Rect::from_center_size(c, vec2(2.0 * (RX + 4.0), 2.0 * (RY + 4.0))); inside |= pointer.is_some_and(|p| area.contains(p)); let hot = pointer.and_then(|p| sector(p - c)); let resp = Container::new(ctx, Surface::Popup) .area(egui::Id::new("sc_marking_menu")) .fixed_pos(area.min) .order(egui::Order::Foreground) .show(ctx, |ui| { let _ = ui.allocate_exact_size(area.size(), Sense::hover()); picked = crate::ui_kit::radial_menu(ui, c, &radial, hot).or(picked.take()); }); inside |= resp.response.contains_pointer(); list_place(c, list_height(&list), screen) } else { place(at, Vec2::ZERO, vec2(LIST_W, list_height(&list)), screen) }; let had_submenu = app.menu.submenu.is_some(); let leaving = app.menu.submenu_leave.is_some(); let enabled: Vec<_> = list.iter().map(|i| i.enabled && !i.is_sep() && !i.is_heading()).collect(); if app.menu.submenu.is_none() { let enter = crate::ui_kit::Menu::navigate(ctx, &enabled, &mut app.menu.key_row); let right = ctx.input(|i| i.key_pressed(egui::Key::ArrowRight)); if let Some(k) = app.menu.key_row && let Some(item) = list.get(k) { if (right || enter) && !item.children.is_empty() { app.menu.submenu = Some(k); app.menu.submenu_key = item.children.iter().position(|c| c.enabled); } else if enter { picked = Some(item.clone()); } } } else if ctx.input(|i| i.key_pressed(egui::Key::ArrowLeft)) { app.menu.submenu = None; app.menu.submenu_key = None; } let mut submenu_row = None; let mut other_row = false; let key_row = app.menu.key_row; let resp = Container::new(ctx, Surface::Popup) .area(egui::Id::new("sc_context_menu")) .fixed_pos(list_at) .constrain(true) .order(egui::Order::Foreground) .show(ctx, |ui| { if target == Target::Workspace { picked = crate::ui_kit::workspace_menu(ui, &list, key_row, (screen.bottom() - list_at.y).max(160.0)).or(picked.take()); } else { menu_frame(ui, |ui| { for (k, item) in list.iter().enumerate() { if item.is_sep() || item.is_heading() { let _ = list_row_lit(ui, item, false); } else if item.children.is_empty() { let row = kit_item(item, key_row == Some(k)).show(ui); if row.clicked() && item.enabled { picked = Some(item.clone()); } other_row |= row.hovered(); } else { let row = kit_item(item, key_row == Some(k) || (app.menu.submenu == Some(k) && !leaving)).show(ui); // Appearance keeps its direct editor action as well as hover shortcuts. if item.enabled && row.clicked() && item.id == "ui.appearance" { picked = Some(item.clone()); } else if item.enabled && ((row.hovered() && ctx.input(|i| i.pointer.delta() != Vec2::ZERO)) || row.clicked()) { if app.menu.submenu != Some(k) { app.menu.submenu_key = None; } app.menu.submenu = Some(k); } if app.menu.submenu == Some(k) { submenu_row = Some((k, row.rect)); } } } }); } }); inside |= resp.response.contains_pointer() || resp.response.rect.contains(pointer.unwrap_or(Pos2::ZERO)); // A flyout closes once the pointer moves on to another row of its menu and rests there // (#6657). A pointer that is still (the flyout opened with the keys) leaves it open. let moved = ctx.input(|i| i.pointer.delta() != Vec2::ZERO); if app.menu.submenu.is_some() && other_row && (moved || app.menu.submenu_leave.is_some()) { let now = ctx.input(|i| i.time); let since = *app.menu.submenu_leave.get_or_insert(now); let left = SUBMENU_CLOSE_DELAY - (now - since); if left <= 0.0 || !left.is_finite() { app.menu.submenu = None; app.menu.submenu_key = None; app.menu.submenu_leave = None; submenu_row = None; } else { ctx.request_repaint_after(std::time::Duration::from_secs_f64(left)); } } else { app.menu.submenu_leave = None; } if let Some((k, row)) = submenu_row && let Some(parent) = list.get(k) { let enabled: Vec<_> = parent.children.iter().map(|i| i.enabled && !i.is_sep() && !i.is_heading()).collect(); if had_submenu && crate::ui_kit::Menu::navigate(ctx, &enabled, &mut app.menu.submenu_key) && let Some(child) = app.menu.submenu_key.and_then(|r| parent.children.get(r)) { picked = Some(child.clone()); } let sub = crate::ui_kit::Menu::submenu(ctx, egui::Id::new("sc_context_submenu"), row, list_height(&parent.children), |ui| { egui::ScrollArea::vertical().max_height((screen.height() - 28.0).max(30.0)).show(ui, |ui| { for (n, child) in parent.children.iter().enumerate() { if child.is_sep() { crate::ui_kit::Menu::separator(ui); continue; } if child.is_heading() { crate::ui_kit::Menu::heading(ui, &child.label); continue; } // Child commands may share an id (swatches); preserve the parent handle // and publish a distinct identity for every adjacent submenu action. let handle = format!("{}:{}", child.id, child.label); let mut row = kit_item(child, app.menu.submenu_key == Some(n)); row.id = &handle; if row.show(ui).clicked() && child.enabled { picked = Some(child.clone()); } } }); }); inside |= sub.response.contains_pointer() || pointer.is_some_and(|p| sub.response.rect.contains(p)); } let shown = std::mem::replace(&mut app.menu.shown, true); let (primary, secondary, esc) = ctx.input(|i| { ( shown && i.pointer.button_pressed(egui::PointerButton::Primary), shown && i.pointer.button_pressed(egui::PointerButton::Secondary), i.key_pressed(egui::Key::Escape), ) }); if secondary && inside && app.menu.radial { // A right press on the ring: drag toward a command and release to pick it. app.menu.flick = true; } else if (primary || secondary) && !inside || esc { close(app); } if let Some(item) = picked { close(app); run_item(app, &item, at); } } /// Shared kit surface; legacy callers retain their menu positioning and dispatch. pub fn menu_frame(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -> R { crate::ui_kit::Menu::show(ui, LIST_W, add) } pub fn button(ui: &mut egui::Ui, label: &str, icon: &str) -> egui::Response { button_enabled(ui, label, icon, true) } pub fn button_enabled(ui: &mut egui::Ui, label: &str, icon: &str, enabled: bool) -> egui::Response { let mut item = crate::ui_kit::MenuItem::new(label, label, icon); item.enabled = enabled; item.show(ui) } pub fn list_row(ui: &mut egui::Ui, item: &Item) -> Option { list_row_lit(ui, item, false) } pub fn list_row_lit(ui: &mut egui::Ui, item: &Item, lit: bool) -> Option { if item.is_sep() { crate::ui_kit::Menu::separator(ui); return None; } if item.is_heading() { crate::ui_kit::Menu::heading(ui, &item.label); return None; } let row = kit_item(item, lit); (row.show(ui).clicked() && item.enabled).then(|| item.clone()) } fn kit_item(item: &Item, lit: bool) -> crate::ui_kit::MenuItem<'_> { crate::ui_kit::MenuItem { id: &item.id, label: &item.label, icon: &item.icon, shortcut: if item.shortcut == "current" { "" } else { &item.shortcut }, enabled: item.enabled, highlighted: lit, danger: item.icon == "delete", checked: (item.shortcut == "current").then_some(true), swatch: item.swatch.map(|c| Color32::from_rgb(c[0], c[1], c[2])), submenu: !item.children.is_empty(), } } fn show_rename(app: &mut SolveApp, ctx: &egui::Context) { // Feature-history folders own their editor inside the row. Keep the shared rename state so // automation and keyboard handling still use the same path, but do not draw the floating box. if app.preferences.timeline_left && matches!(app.menu.rename.as_ref().map(|rename| &rename.what), Some(RenameWhat::TimelineGroup(_))) { return; } if app.menu.rename.as_ref().is_some_and(|r| r.inline) { return; } let Some(mut r) = app.menu.rename.take() else { return }; let mut done: Option = None; let resp = Container::new(ctx, Surface::Popup).area(egui::Id::new("sc_rename")).fixed_pos(r.at).constrain(true).order(egui::Order::Foreground).show( ctx, |ui| { done = crate::ui_kit::rename_menu(ui, &mut r.text, &mut r.focused); }, ); if ctx.input(|i| i.pointer.any_pressed()) && !resp.response.contains_pointer() && r.focused { done = Some(true); } match done { Some(true) => commit_rename(app, &r), Some(false) => {} None => app.menu.rename = Some(r), } } /// Finish a rename from automation: commit (true) or cancel. pub fn finish_rename(app: &mut SolveApp, text: Option<&str>, commit: bool) -> bool { let Some(mut r) = app.menu.rename.take() else { return false }; if let Some(s) = text { r.text = s.to_string(); } if commit { commit_rename(app, &r); } true } #[cfg(test)] mod tests { use super::*; /// #320: a selected sketch dimension gets the Toggle Driven Dimension item, it round-trips /// driving -> driven -> driving, and non-dimension selections get no such item. #[test] fn dimension_menu_toggles_driving_driven_and_other_selections_get_no_item() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); let sid = h.app.session.active_sketch.unwrap(); let l = h.app.run("sketch.line", json!({"points":[[0,0],[20,0]],"connect":false,"infer":false})).unwrap()["curves"][0] .as_str() .unwrap() .to_owned(); let dparam = h.app.run("sketch.dimension", json!({"entities":[l],"value":10})).unwrap()["param"].as_str().unwrap().to_owned(); let dim = h.app.run("sketch.glyphs", json!({})).unwrap()["glyphs"] .as_array() .unwrap() .iter() .find(|x| x["param"].as_str() == Some(dparam.as_str())) .and_then(|x| x["id"].as_str()) .expect("the dimension glyph carries its constraint id") .to_owned(); let horiz = h.app.run("sketch.constrainer", json!({"entities":[l]})).unwrap()["constraint"].as_str().unwrap().to_owned(); let is_driven = |h: &crate::scenario::Harness| { h.app.session.world_state().sketch(sid).unwrap().sketch.constraints.iter().any(|c| c.id == dim && c.driven) }; // A selected dimension offers the toggle, aimed at that constraint. h.app.session.selection = vec![Sel::SketchConstraint { id: dim.clone() }]; let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|i| i.id == "sketch.toggle_driven").expect("a selected dimension must offer Toggle Driven Dimension"); assert!(item.enabled); assert_eq!(item.params, Some(json!({"constraint": dim}))); // Running it flips the state both ways. run_item(&mut h.app, item, egui::pos2(0.0, 0.0)); assert!(is_driven(&h), "the dimension is driven now"); let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|i| i.id == "sketch.toggle_driven").expect("a driven dimension still offers the toggle"); run_item(&mut h.app, item, egui::pos2(0.0, 0.0)); assert!(!is_driven(&h), "and driving again"); // A non-dimension constraint, and a plain curve, get no toggle item. h.app.session.selection = vec![Sel::SketchConstraint { id: horiz }]; assert!(!items(&h.app, &Target::Viewport).iter().any(|i| i.id == "sketch.toggle_driven"), "a horizontal constraint is not a dimension"); h.app.session.selection = vec![Sel::SketchCurve { id: l, sketch: None }]; assert!(!items(&h.app, &Target::Viewport).iter().any(|i| i.id == "sketch.toggle_driven")); } /// #7499: a selected circle's dimension offers Toggle Radius / Diameter, which switches it /// both ways; a line's length does not. #[test] fn a_circle_dimension_menu_toggles_radius_and_diameter() { use solidcraft_engine::sketch::ConstraintKind; let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); let sid = h.app.session.active_sketch.unwrap(); let c = h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":10})).unwrap()["curves"][0].as_str().unwrap().to_owned(); let l = h.app.run("sketch.line", json!({"points":[[30,0],[50,0]],"connect":false,"infer":false})).unwrap()["curves"][0] .as_str() .unwrap() .to_owned(); let pc = h.app.run("sketch.dimension", json!({"entities":[c]})).unwrap()["param"].as_str().unwrap().to_owned(); let pl = h.app.run("sketch.dimension", json!({"entities":[l],"value":20})).unwrap()["param"].as_str().unwrap().to_owned(); let dim = |h: &crate::scenario::Harness, p: &str| { h.app.session.world_state().sketch(sid).unwrap().sketch.constraints.iter().find(|c| c.param.as_deref() == Some(p)).unwrap().clone() }; let did = dim(&h, &pc).id; h.app.session.selection = vec![Sel::SketchConstraint { id: did.clone() }]; let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|i| i.id == "sketch.toggle_diameter").expect("a circle's dimension must offer Toggle Radius / Diameter"); assert!(item.enabled); assert_eq!(item.params, Some(json!({"constraint": did}))); run_item(&mut h.app, item, egui::pos2(0.0, 0.0)); assert!(matches!(dim(&h, &pc).kind, ConstraintKind::Radius { .. }), "the diameter is a radius now"); let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|i| i.id == "sketch.toggle_diameter").expect("a radius still offers the toggle"); run_item(&mut h.app, item, egui::pos2(0.0, 0.0)); assert!(matches!(dim(&h, &pc).kind, ConstraintKind::Diameter { .. }), "and a diameter again"); h.app.session.selection = vec![Sel::SketchConstraint { id: dim(&h, &pl).id }]; let menu = items(&h.app, &Target::Viewport); assert!(menu.iter().any(|i| i.id == "sketch.toggle_driven")); assert!(!menu.iter().any(|i| i.id == "sketch.toggle_diameter"), "a length is no radius"); } #[test] fn units_toolbar_start_offers_choices_and_one_undo_step() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.call("ui.start", json!({"command":"document.units"})); assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); assert_eq!(h.app.menu.target, Target::Units); assert!(h.app.viewport.context_menu.is_some()); let menu = describe(&h.app); let choices = menu["items"].as_array().unwrap(); assert_eq!(choices.iter().map(|item| item["label"].as_str().unwrap()).collect::>(), crate::prefs::UNITS); assert!(choices.iter().all(|item| item["enabled"] == true)); assert!(h.app.session.undo.is_empty()); h.call("ui.menuPick", json!({"item":"in"})); assert_eq!(h.app.session.doc.units, "in"); assert!(h.app.viewport.context_menu.is_none()); assert_eq!(h.app.session.undo.len(), 1); h.app.run("edit.undo", json!({})).unwrap(); assert_eq!(h.app.session.doc.units, "mm"); h.app.run("edit.redo", json!({})).unwrap(); assert_eq!(h.app.session.doc.units, "in"); } #[test] fn units_toolbar_menu_is_anchored_and_programmatic_calls_stay_headless() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; let missing = h.call("engine.execute", json!({"command":"document.units","params":{}})); assert_eq!(missing["ok"], false); assert!(h.app.viewport.context_menu.is_none()); let changed = h.call("engine.execute", json!({"command":"document.units","params":{"units":"cm"}})); assert_eq!(changed["ok"], true); assert_eq!(h.app.session.doc.units, "cm"); assert!(h.app.viewport.context_menu.is_none()); h.app.status = None; h.step(&json!({"click":{"handle":"tab:MANAGE"}})).unwrap(); let button = crate::scenario::rect_of("button:document.units").unwrap(); h.step(&json!({"click":{"handle":"button:document.units"}})).unwrap(); assert_eq!(h.app.viewport.context_menu, Some(button.left_bottom())); assert_eq!(h.app.menu.target, Target::Units); assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); assert_eq!(items(&h.app, &Target::Units).iter().find(|item| item.label == "cm").unwrap().shortcut, "current"); h.step(&json!({"click":{"handle":"button:document.units"}})).unwrap(); assert!(h.app.viewport.context_menu.is_none()); } #[test] fn line_offset_context_menu_breaks_association_and_allows_trim() { use solidcraft_engine::{geom::Vec2, sketch::Shape}; let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); let source = h.app.run("sketch.line", json!({"points":[[0,0],[20,0]],"connect":false,"infer":false})).unwrap()["curves"][0] .as_str() .unwrap() .to_owned(); let output = h.app.run("sketch.offset", json!({"curves":[source],"distance":2,"chain":false})).unwrap()["curves"][0].as_str().unwrap().to_owned(); h.app.run("sketch.line", json!({"points":[[10,-5],[10,5]],"connect":false,"infer":false})).unwrap(); let sid = h.app.session.active_sketch.unwrap(); let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; let Shape::Line { a, b } = sk.shape(sk.curve_index(&output).unwrap()).unwrap() else { panic!("offset must be a line") }; let cut = Vec2::new(15.0, a.y); assert!((a.dist(b) - 20.0).abs() < 1e-6); assert!(h.app.run("sketch.trim", json!({"curve":output,"at":[cut.x,cut.y]})).is_err()); h.call("ui.view", json!({"view":"top"})); h.app.cam.distance = 60.0; h.settle(); h.step(&json!({"click":{"world":[cut.x,cut.y,0]},"button":"right"})).unwrap(); assert_eq!(h.app.session.selection, vec![Sel::SketchCurve { id: output.clone(), sketch: None }]); let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|item| item.id == "sketch.offset.break").expect("offset line must offer Break Offset Association"); assert_eq!(item.label, "Break Offset Association"); assert!(item.enabled); assert_eq!(item.params, Some(json!({"curve":output}))); h.step(&json!({"click":{"handle":"menu:sketch.offset.break"}})).unwrap(); assert!(h.app.session.world_state().sketch(sid).unwrap().sketch.offset_distance(&output).is_none()); h.app.run("sketch.trim", json!({"curve":output,"at":[cut.x,cut.y]})).unwrap(); let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; let remaining = sk.shape(sk.curve_index(&output).unwrap()).unwrap(); assert!(matches!(remaining, Shape::Line { a, b } if (a.dist(b) - 10.0).abs() < 1e-6), "{remaining:?}"); assert!(remaining.dist(cut) > 1.0); } /// #6533: a right-click on a fit point spline offers Add Spline Point at the clicked spot, and /// the item puts a fit point there. A control point spline is not offered it. Every spline is /// offered Reverse Spline Direction (#8224), which runs it the other way. #[test] fn spline_context_menu_adds_a_fit_point_where_it_was_clicked() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); let fit = h.app.run("sketch.spline.fit_point", json!({"points":[[0,0],[10,8],[20,0],[30,6]],"connect":false})).unwrap()["curves"][0] .as_str() .unwrap() .to_owned(); let control = h.app.run("sketch.spline.control_point", json!({"points":[[0,-12],[10,-4],[20,-12]],"connect":false})).unwrap()["curves"][0] .as_str() .unwrap() .to_owned(); let sid = h.app.session.active_sketch.unwrap(); let spot = |h: &crate::scenario::Harness, id: &str, piece: usize| { let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; sk.exact_segs(sk.curve_index(id).unwrap()).unwrap()[piece].point_at(0.5) }; let count = |h: &crate::scenario::Harness, id: &str| { let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; sk.curves[sk.curve_index(id).unwrap()].kind.point_ids().len() }; h.call("ui.view", json!({"view":"top"})); h.app.cam.distance = 80.0; h.settle(); let c = spot(&h, &control, 0); h.step(&json!({"click":{"world":[c.x,c.y,0]},"button":"right"})).unwrap(); assert_eq!(h.app.session.selection, vec![Sel::SketchCurve { id: control.clone(), sketch: None }]); assert!(items(&h.app, &Target::Viewport).iter().all(|item| item.id != "sketch.spline.insert_point")); let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|item| item.id == "sketch.spline.reverse").expect("a control point spline offers Reverse Spline Direction"); assert_eq!((item.label.as_str(), item.params.clone()), ("Reverse Spline Direction", Some(json!({"curve": control})))); let points = |h: &crate::scenario::Harness, id: &str| { let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; sk.curves[sk.curve_index(id).unwrap()].kind.point_ids() }; let mut reversed = points(&h, &control); reversed.reverse(); h.step(&json!({"click":{"handle":"menu:sketch.spline.reverse"}})).unwrap(); assert_eq!(points(&h, &control), reversed); close(&mut h.app); let at = spot(&h, &fit, 1); h.step(&json!({"click":{"world":[at.x,at.y,0]},"button":"right"})).unwrap(); assert_eq!(h.app.session.selection, vec![Sel::SketchCurve { id: fit.clone(), sketch: None }]); let menu = items(&h.app, &Target::Viewport); let item = menu.iter().find(|item| item.id == "sketch.spline.insert_point").expect("a fit spline offers Add Spline Point"); assert_eq!(item.label, "Add Spline Point"); assert!(item.enabled); let p = item.params.clone().unwrap(); assert_eq!(p["curve"], json!(fit)); let clicked = solidcraft_engine::geom::Vec2::new(p["at"][0].as_f64().unwrap(), p["at"][1].as_f64().unwrap()); assert!(clicked.dist(at) < 0.5, "the item carries the clicked spot: {clicked:?} for {at:?}"); h.step(&json!({"click":{"handle":"menu:sketch.spline.insert_point"}})).unwrap(); assert_eq!(count(&h, &fit), 5); let state = h.app.session.world_state(); let sk = &state.sketch(sid).unwrap().sketch; let added = sk.point(sk.curves[sk.curve_index(&fit).unwrap()].kind.point_ids()[2]).unwrap(); assert!(added.dist(at) < 0.5, "the new fit point is where the menu was opened: {added:?}"); } #[test] fn solidworks_face_menu_runs_normal_to_selection_and_rejects_curved_faces() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.app.run("solid.cylinder", json!({"diameter":30,"height":20})).unwrap(); let state = h.app.session.world_state(); let body = state.bodies.first().unwrap(); let faces = body.body.faces(0.1).unwrap(); let flat = faces.iter().find(|f| f.plane_normal.is_some()).unwrap(); let curved = faces.iter().find(|f| f.plane_normal.is_none()).unwrap(); h.app.session.selection = vec![Sel::Face { body: body.name.clone(), index: flat.index, point: flat.centroid }]; assert!(items(&h.app, &Target::Viewport).iter().all(|i| i.id != "view.normal_to")); h.app.preferences.nav = "solidworks".into(); h.app.preferences.language = "ja".into(); h.settle(); let before = h.app.cam; open_for(&mut h.app, pos2(800.0, 400.0), Target::Viewport); h.settle(); assert!(items(&h.app, &Target::Viewport).iter().any(|i| i.id == "view.normal_to" && i.enabled)); h.step(&json!({"click":{"handle":"menu:view.normal_to"}})).unwrap(); h.frames(90); assert!(h.app.cam.back().dist(flat.plane_normal.unwrap()) < 2e-6); assert_eq!((h.app.cam.distance, h.app.cam.fov), (before.distance, before.fov)); assert!(h.app.viewport.context_menu.is_none()); assert_eq!(crate::i18n::Locale::for_language("ja").label("Normal to Selection"), "選択アイテムに垂直"); // Ctrl+8 and the context menu share Look At, including its repeat-to-flip behavior. h.step(&json!({"key":"8","cmd":true})).unwrap(); h.frames(90); assert!(h.app.cam.back().dist(-flat.plane_normal.unwrap()) < 2e-6); open_for(&mut h.app, pos2(800.0, 400.0), Target::Viewport); h.settle(); h.step(&json!({"click":{"handle":"menu:view.normal_to"}})).unwrap(); h.frames(90); assert!(h.app.cam.back().dist(flat.plane_normal.unwrap()) < 2e-6); h.app.session.selection = vec![Sel::Face { body: body.name.clone(), index: curved.index, point: curved.centroid }]; assert!(items(&h.app, &Target::Viewport).iter().any(|i| i.id == "view.normal_to" && !i.enabled)); } #[test] fn viewport_right_click_keeps_list_menu_and_radial_is_opt_in() { let mut h = crate::scenario::Harness::new(); h.app.home.open = false; h.settle(); let point = h.at(&json!({"world":[0,0,0]})).unwrap(); h.step(&json!({"click":point,"button":"right"})).unwrap(); assert!(h.app.viewport.context_menu.is_some(), "ordinary right click must still open a menu"); let list = describe(&h.app); assert!(list["radial"].as_array().unwrap().is_empty()); assert!(list["items"].as_array().unwrap().iter().any(|item| item["id"] == "ui.origin" && item["enabled"] == true)); h.step(&json!({"click":{"handle":"menu:ui.origin"}})).unwrap(); assert!(!h.app.origin_shown() && h.app.viewport.context_menu.is_none(), "the ordinary menu must execute Hide Origin and close"); h.call("ui.prefs", json!({"radial_context_menu":true})); h.step(&json!({"click":point,"button":"right"})).unwrap(); assert_eq!(describe(&h.app)["radial"].as_array().unwrap().len(), DIRS); open_for(&mut h.app, pos2(point[0] as f32, point[1] as f32), Target::Origin); assert!(!h.app.menu.radial, "browser menus remain lists when radial menus are enabled"); } #[test] fn disabled_radial_menu_does_not_capture_right_button_hold() { let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default()); let ctx = crate::fonts::test_context(); let point = pos2(600.0, 400.0); app.viewport.mouse = Some(point); for (time, events) in [ ( 0.0, vec![ egui::Event::PointerMoved(point), egui::Event::PointerButton { pos: point, button: egui::PointerButton::Secondary, pressed: true, modifiers: egui::Modifiers::NONE, }, ], ), (1.0, vec![]), ] { let mut output = ctx.run_ui(egui::RawInput { time: Some(time), events, ..Default::default() }, |_| track_hold(&mut app, &ctx)); output.textures_delta.clear(); } assert!(app.viewport.context_menu.is_none() && app.menu.press.is_none() && !app.menu.flick); } #[test] fn sectors_go_clockwise_from_the_top() { assert_eq!(sector(vec2(0.0, -50.0)), Some(0)); assert_eq!(sector(vec2(50.0, -50.0)), Some(1)); assert_eq!(sector(vec2(50.0, 0.0)), Some(2)); assert_eq!(sector(vec2(0.0, 50.0)), Some(4)); assert_eq!(sector(vec2(-50.0, 0.0)), Some(6)); assert_eq!(sector(vec2(-50.0, -50.0)), Some(7)); assert_eq!(sector(vec2(3.0, 3.0)), None); } #[test] fn list_goes_beside_the_ring_near_the_bottom() { let screen = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0)); let c = radial_center(pos2(800.0, 300.0), screen); assert!(list_place(c, 300.0, screen).y > c.y + RY, "room below"); for at in [pos2(800.0, 900.0), pos2(1590.0, 900.0), pos2(10.0, 990.0)] { let c = radial_center(at, screen); let p = list_place(c, 400.0, screen); let r = Rect::from_min_size(p, vec2(LIST_W, 400.0)); assert!(screen.contains_rect(r), "{at:?}: {r:?}"); let ring = Rect::from_center_size(c, vec2(2.0 * RX, 2.0 * RY)); assert!(!ring.intersects(r), "{at:?}: list {r:?} over ring {ring:?}"); } } #[test] fn list_menus_flip_to_stay_in_the_window() { let screen = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0)); let size = vec2(LIST_W, 300.0); assert_eq!(place(pos2(100.0, 100.0), Vec2::ZERO, size, screen), pos2(100.0, 100.0), "room right and below"); assert_eq!(place(pos2(1500.0, 900.0), Vec2::ZERO, size, screen), pos2(1500.0 - LIST_W, 600.0), "ends at the cursor"); assert_eq!(place(pos2(1500.0, 900.0), vec2(12.0, 12.0), size, screen), pos2(1488.0 - LIST_W, 588.0), "the gap both ways"); let tall = vec2(LIST_W, 700.0); assert_eq!(place(pos2(100.0, 500.0), Vec2::ZERO, tall, screen).y, 300.0, "room on neither side: against the bottom"); assert_eq!(place(pos2(100.0, 500.0), Vec2::ZERO, vec2(LIST_W, 1200.0), screen).y, 0.0, "taller than the window: from the top"); } #[test] fn radial_menu_stays_on_screen() { let screen = Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0)); for at in [pos2(2.0, 2.0), pos2(1199.0, 799.0), pos2(600.0, 400.0), pos2(-50.0, 900.0)] { let c = radial_center(at, screen); assert!(screen.contains_rect(Rect::from_center_size(c, vec2(2.0 * RX, 2.0 * RY)))); } } } #[cfg(test)] mod workspace_menu_tests { use super::*; use crate::scenario::{Harness, rect_of}; #[test] fn workspace_titles_use_one_semibold_text_run() { let ctx = crate::fonts::test_context(); let app = SolveApp::new(Default::default(), Default::default()); let list = items(&app, &Target::Workspace); let mut output = ctx.run_ui(egui::RawInput::default(), |ui| { crate::ui_kit::workspace_menu(ui, &list, None, 1000.0); }); output.textures_delta.clear(); let titles: Vec<_> = output .shapes .iter() .filter_map(|s| match &s.shape { egui::Shape::Text(text) if text.galley.text() == "Design" => Some(text), _ => None, }) .collect(); assert_eq!(titles.len(), 1, "workspace titles must never be drawn twice"); assert_eq!(titles[0].galley.job.sections[0].format.font_id, crate::fonts::semibold(14.0)); } #[test] fn workspace_rows_keep_switching_handles_and_disabled_render_behavior() { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1200,"height":1000})); h.step(&json!({"click":{"handle":"ribbon:workspace"}})).unwrap(); let opener = rect_of("ribbon:workspace").unwrap(); let rows: Vec<_> = ["design", "render", "animation", "simulation", "manufacture", "drawing"] .iter() .map(|slug| rect_of(&format!("workspace:menu:{slug}")).unwrap()) .collect(); assert!(rows.windows(2).all(|pair| pair[0].bottom() <= pair[1].top())); assert!(rows[0].top() > opener.bottom()); assert_eq!(rows[0].width(), 450.0); assert!(items(&h.app, &Target::Workspace).iter().skip(2).all(|item| !item.enabled)); h.step(&json!({"click":{"handle":"workspace:menu:animation"}})).unwrap(); assert!(!crate::render_workspace::active(&h.app)); assert!(h.app.viewport.context_menu.is_some()); h.step(&json!({"click":{"handle":"workspace:menu:render"}})).unwrap(); assert!(crate::render_workspace::active(&h.app)); h.step(&json!({"click":{"handle":"ribbon:workspace"}})).unwrap(); h.step(&json!({"click":{"handle":"workspace:menu:design"}})).unwrap(); assert!(!crate::render_workspace::active(&h.app)); h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); h.frames(2); h.step(&json!({"click":{"handle":"ribbon:workspace"}})).unwrap(); assert!(!items(&h.app, &Target::Workspace).iter().find(|i| i.id == "ui.workspace.render").unwrap().enabled); h.step(&json!({"click":{"handle":"workspace:menu:render"}})).unwrap(); assert!(!crate::render_workspace::active(&h.app)); assert!(h.app.viewport.context_menu.is_some()); } }