SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Preferences window (File › Preferences): theme, units of new designs, recovery copies every N minutes (to a Recovery folder beside the preferences), mouse presets (Fusion, SolidWorks, Inventor), reverse zoom, orbit around the point under the cursor, grid, perspective, visual style, display precision, anti-aliasing (on restart), sketch and selection options; all kept between runs; ui.prefs control method
bherbruckc99e7e41ecd7
diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rsindex 8a7f897391..0354712da2 100644--- a/apps/solvecraft/src/main.rs+++ b/apps/solvecraft/src/main.rs@@ -58,9 +58,27 @@ fn services() -> Services {pick_save: Some(Box::new(|name: &str, exts: &[&str]| {rfd::FileDialog::new().set_file_name(name).add_filter("File", exts).save_file().map(|p| p.to_string_lossy().to_string())})),+ graphics_path: graphics_path().map(|p| p.to_string_lossy().to_string()),}}+/// The anti-aliasing preference, kept next to eframe's storage (it is needed before the+/// window opens).+fn graphics_path() -> Option<std::path::PathBuf> {+ eframe::storage_dir("SolveCraft").map(|d| d.join("graphics.json"))+}++/// Anti-aliasing samples from Preferences (4 when unset).+fn msaa() -> u16 {+ graphics_path()+ .and_then(|p| std::fs::read_to_string(p).ok())+ .and_then(|s| serde_json::from_str::<serde_json::Value>(&s).ok())+ .and_then(|v| v.get("msaa").and_then(serde_json::Value::as_u64))+ .and_then(|m| u16::try_from(m).ok())+ .filter(|m| [1, 2, 4, 8].contains(m))+ .unwrap_or(MSAA)+}+/// Windows and Linux: no OS title bar; the application bar is the title bar/// (`solvecraft_ui_egui::titlebar`). macOS keeps its traffic lights over the integrated bar.const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");@@ -69,6 +87,7 @@ const DEPTH_BITS: u8 = 24;const MSAA: u16 = 4;fn main() -> eframe::Result {+ let samples = msaa();let mut control_port: Option<u16> = std::env::var("SOLVECRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());let mut files = Vec::new();let mut sample = false;@@ -100,7 +119,7 @@ fn main() -> eframe::Result {.with_title_shown(false).with_app_id("ai.storyteller.solvecraft"),depth_buffer: DEPTH_BITS,- multisampling: MSAA,+ multisampling: samples,..Default::default()};eframe::run_native(@@ -114,7 +133,7 @@ fn main() -> eframe::Result {app.load_prefs(&p);}if let Some(rs) = &cc.wgpu_render_state {- app.set_wgpu(rs, DEPTH_BITS, u32::from(MSAA));+ app.set_wgpu(rs, DEPTH_BITS, u32::from(samples));}if let Some(port) = control_port {let rx = control_server::start(port, cc.egui_ctx.clone());diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex 1c20813129..529fa89505 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -24,6 +24,8 @@//! - `ui.confirm {accept?}`: the Delete confirmation (without `accept`: what it lists)//! - `ui.shortcut {command, key?, replace?}`: a command's key, or bind one ("" clears)//! - `ui.help {item?: about|shortcuts|report}`: the Help menu; returns the version and diagnostics+//! - `ui.prefs {...}`: the preferences (default_units, nav, zoom_reverse, orbit_cursor, msaa,+//! length_decimals, angle_decimals); returns them all//! - `ui.resize {width, height}`, `app.quit`use std::sync::mpsc::Sender;@@ -376,6 +378,7 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->None => ok(json!({"command": id, "key": crate::keymap::effective(app, id)})),}}+ "ui.prefs" => wrap(crate::prefs::set(app, p)),"ui.help" => match s("item") {Some(i @ ("about" | "shortcuts" | "report")) => {crate::help::run(app, ctx, i);diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex c7093c52ee..f56ea55326 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -32,6 +32,7 @@ pub mod keymap;mod menu_tests;pub mod palette;pub mod params_dialog;+pub mod prefs;#[cfg(test)]mod preselect_tests;pub mod preview;@@ -129,6 +130,8 @@ impl Default for UiState {pub struct Services {pub pick_open: Option<Box<dyn Fn() -> Option<String>>>,pub pick_save: Option<Box<dyn Fn(&str, &[&str]) -> Option<String>>>,+ /// Where the host reads the anti-aliasing preference at start (a small JSON file).+ pub graphics_path: Option<String>,}pub struct SolveApp {@@ -161,6 +164,9 @@ pub struct SolveApp {pub keymap: keymap::Keymap,/// The Help menu and the About window.pub help: help::HelpState,+ /// Preferences kept between runs, and their window.+ pub preferences: prefs::Prefs,+ pub prefs_window: prefs::PrefsWindow,pub preview: preview::PreviewState,/// The last command started interactively (id, label), for Repeat.pub last_command: Option<(String, String)>,@@ -215,6 +221,8 @@ impl SolveApp {sbox: shortcut_box::ShortcutBox::default(),keymap: keymap::Keymap::default(),help: help::HelpState::default(),+ preferences: prefs::Prefs::default(),+ prefs_window: prefs::PrefsWindow::default(),preview: preview::PreviewState::default(),last_command: None,esc_handled: false,@@ -262,6 +270,7 @@ impl SolveApp {"shortcut_box": self.sbox.prefs(),"shortcuts": self.keymap.prefs(),"autosave_minutes": self.autosave_minutes,+ "preferences": self.preferences,}).to_string()}@@ -311,6 +320,9 @@ impl SolveApp {if let Some(s) = v.get("shortcuts") {self.keymap.load(s);}+ if let Some(p) = v.get("preferences").and_then(|p| serde_json::from_value::<prefs::Prefs>(p.clone()).ok()) {+ self.preferences = p;+ }}pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {@@ -698,6 +710,7 @@ impl SolveApp {}shortcut_box::show(self, ui.ctx());keymap::show(self, ui.ctx());+ prefs::show(self, ui.ctx());self.frame_ms = now_ms() - t0;}diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsnew file mode 100644index 0000000000..e13cd68811--- /dev/null+++ b/crates/ui-egui/src/prefs.rs@@ -0,0 +1,369 @@+//! Preferences (File › Preferences), in the spirit of Fusion's: General (theme, units of new+//! designs, autosave interval), Navigation (mouse mapping preset, zoom direction, orbit centre), Display+//! (grid, perspective, visual style with or without edges, display precision, anti-aliasing), Sketch and Selection. Everything+//! applies at once and is kept between runs, except anti-aliasing, which needs a restart.++use egui::{Modifiers, Pos2, RichText};+use serde::{Deserialize, Serialize};+use serde_json::json;+use solvecraft_engine::geom::Vec3;++use crate::SolveApp;+use crate::theme::Tokens;+use crate::viewport::NavMode;++pub const UNITS: [&str; 5] = ["mm", "cm", "m", "in", "ft"];+/// Mouse mappings: (id, label).+pub const NAV_PRESETS: [(&str, &str); 3] = [("fusion", "Fusion"), ("solidworks", "SolidWorks"), ("inventor", "Inventor")];+pub const MSAA: [u32; 4] = [1, 2, 4, 8];++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default)]+pub struct Prefs {+ /// Units of new designs.+ pub default_units: String,+ /// Mouse mapping: `fusion`, `solidworks` or `inventor`.+ pub nav: String,+ /// The wheel zooms out when turned forward.+ pub zoom_reverse: bool,+ /// Orbit around the point under the cursor (else around the view's centre).+ pub orbit_cursor: bool,+ /// Anti-aliasing samples (applies on restart).+ pub msaa: u32,+ /// Decimals shown for lengths and angles.+ pub length_decimals: u8,+ pub angle_decimals: u8,+}++impl Default for Prefs {+ fn default() -> Self {+ Prefs {+ default_units: "mm".into(),+ nav: "fusion".into(),+ zoom_reverse: false,+ orbit_cursor: false,+ msaa: 4,+ length_decimals: 2,+ angle_decimals: 1,+ }+ }+}++/// The preferences window.+#[derive(Default)]+pub struct PrefsWindow {+ pub open: bool,+ section: usize,+}++/// The autosave interval follows `app.autosave_minutes` (0: off).+pub fn set_autosave(app: &mut SolveApp) {+ let m = app.autosave_minutes;+ if let Some(a) = app.autosave.as_mut() {+ a.interval = if m > 0.0 { std::time::Duration::from_secs_f64(m * 60.0) } else { std::time::Duration::from_secs(u64::MAX / 4) };+ }+}++/// Which navigation a mouse drag does under the preset.+pub fn nav_mode(app: &SolveApp, middle: bool, secondary: bool, mods: Modifiers) -> Option<NavMode> {+ if secondary && !middle {+ return Some(NavMode::Orbit);+ }+ if !middle {+ return None;+ }+ let ctrl = mods.ctrl || mods.command;+ match app.preferences.nav.as_str() {+ // Middle orbits, Ctrl+middle pans, Shift+middle zooms.+ "solidworks" => Some(if ctrl {+ NavMode::Pan+ } else if mods.shift {+ NavMode::Zoom+ } else {+ NavMode::Orbit+ }),+ // Middle pans, Shift+middle orbits, Ctrl+middle zooms.+ "inventor" => Some(if mods.shift {+ NavMode::Orbit+ } else if ctrl {+ NavMode::Zoom+ } else {+ NavMode::Pan+ }),+ // Fusion: middle pans, Shift+middle orbits.+ _ => Some(if mods.shift { NavMode::Orbit } else { NavMode::Pan }),+ }+}++/// +1, or −1 when the wheel zooms the other way.+pub fn zoom_sign(app: &SolveApp) -> f64 {+ if app.preferences.zoom_reverse { -1.0 } else { 1.0 }+}++/// Orbit by pixel deltas: around the view's centre, or, with "orbit around the cursor", around+/// the model point that was under the cursor when the drag began (kept still on screen).+pub fn orbit(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, press: Option<Pos2>) {+ if !app.preferences.orbit_cursor {+ app.cam.orbit(dx, dy);+ return;+ }+ let pivot = match app.viewport.orbit_pivot {+ Some(p) => p,+ None => {+ let proj = crate::viewport::projection(app, rect);+ let at = press.unwrap_or(rect.center());+ let p = pivot_under(app, &proj, at);+ app.viewport.orbit_pivot = Some(p);+ p+ }+ };+ let before = crate::viewport::projection(app, rect).to_screen(pivot);+ app.cam.orbit(dx, dy);+ let after = crate::viewport::projection(app, rect).to_screen(pivot);+ if let (Some(a), Some(b)) = (before, after) {+ app.cam.pan(f64::from(a.x - b.x), f64::from(a.y - b.y), f64::from(rect.height().max(1.0)));+ }+}++/// The model point under a screen position, or the point at the view's depth.+fn pivot_under(app: &SolveApp, proj: &crate::viewport::Proj, at: Pos2) -> Vec3 {+ use crate::viewport::Hit;+ for h in crate::viewport::pick(app, proj, at) {+ match h {+ Hit::Face { point, .. } | Hit::Vertex { point, .. } => return point,+ Hit::Edge { mid, .. } => return mid,+ _ => {}+ }+ }+ let (o, d) = proj.ray(at);+ let n = app.cam.back();+ let den = d.dot(n);+ if den.abs() > 1e-9 { o + d * ((app.cam.target - o).dot(n) / den) } else { app.cam.target }+}++/// A length in millimetres in `units`, with `decimals` (for display).+pub fn format_length(mm: f64, units: &str, decimals: u8) -> String {+ let (k, u) = match units {+ "cm" => (0.1, "cm"),+ "m" => (0.001, "m"),+ "in" => (1.0 / 25.4, "in"),+ "ft" => (1.0 / 304.8, "ft"),+ _ => (1.0, "mm"),+ };+ format!("{:.*} {u}", usize::from(decimals.min(8)), mm * k)+}++/// Write the anti-aliasing setting where the host reads it at start (the window's samples can't+/// change while it is open).+fn save_graphics(app: &SolveApp) {+ if let Some(path) = &app.services.graphics_path {+ let _ = std::fs::write(path, json!({ "msaa": app.preferences.msaa }).to_string());+ }+}++pub fn show(app: &mut SolveApp, ctx: &egui::Context) {+ if !app.prefs_window.open {+ return;+ }+ let t = Tokens::get();+ let mut open = true;+ let sections = ["General", "Navigation", "Display", "Sketch", "Selection"];+ let before = app.preferences.clone();+ egui::Window::new("Preferences")+ .id(egui::Id::new("sc_prefs"))+ .open(&mut open)+ .default_pos(egui::pos2(300.0, 120.0))+ .default_size([560.0, 360.0])+ .show(ctx, |ui| {+ ui.horizontal_top(|ui| {+ ui.vertical(|ui| {+ ui.set_width(120.0);+ for (i, s) in sections.iter().enumerate() {+ if ui.selectable_label(app.prefs_window.section == i, *s).clicked() {+ app.prefs_window.section = i;+ }+ }+ });+ ui.separator();+ ui.vertical(|ui| {+ egui::Grid::new("sc_prefs_grid").num_columns(2).spacing([16.0, 8.0]).show(ui, |ui| match app.prefs_window.section {+ 0 => {+ ui.label("Theme");+ ui.horizontal(|ui| {+ ui.radio_value(&mut app.ui.dark, true, "Dark");+ ui.radio_value(&mut app.ui.dark, false, "Light");+ });+ ui.end_row();+ ui.label("Units of new designs");+ egui::ComboBox::from_id_salt("pref_units").selected_text(app.preferences.default_units.clone()).show_ui(ui, |ui| {+ for u in UNITS {+ ui.selectable_value(&mut app.preferences.default_units, u.to_string(), u);+ }+ });+ ui.end_row();+ ui.label("Recovery copy every");+ ui.add(egui::DragValue::new(&mut app.preferences.autosave_minutes).range(0..=120).suffix(" min"));+ ui.end_row();+ ui.label("");+ ui.label(RichText::new("0 turns it off").size(11.0).color(t.text_dim));+ ui.end_row();+ }+ 1 => {+ ui.label("Mouse");+ egui::ComboBox::from_id_salt("pref_nav")+ .selected_text(NAV_PRESETS.iter().find(|(id, _)| *id == app.preferences.nav).map_or("Fusion", |x| x.1))+ .show_ui(ui, |ui| {+ for (id, label) in NAV_PRESETS {+ if ui.selectable_value(&mut app.preferences.nav, id.to_string(), label).clicked() {+ app.preferences.zoom_reverse = id == "solidworks";+ }+ }+ });+ ui.end_row();+ ui.label("");+ let how = match app.preferences.nav.as_str() {+ "solidworks" => "Middle drag orbits, Ctrl+middle pans, Shift+middle zooms",+ "inventor" => "Middle drag pans, Shift+middle orbits, Ctrl+middle zooms",+ _ => "Middle drag pans, Shift+middle orbits",+ };+ ui.label(RichText::new(format!("{how}; right drag orbits; the wheel zooms at the cursor")).size(11.0).color(t.text_dim));+ ui.end_row();+ ui.label("Reverse zoom direction");+ ui.checkbox(&mut app.preferences.zoom_reverse, "");+ ui.end_row();+ ui.label("Orbit around");+ ui.horizontal(|ui| {+ ui.radio_value(&mut app.preferences.orbit_cursor, false, "View centre");+ ui.radio_value(&mut app.preferences.orbit_cursor, true, "Point under the cursor");+ });+ ui.end_row();+ }+ 2 => {+ ui.label("Grid");+ ui.checkbox(&mut app.ui.show_grid, "");+ ui.end_row();+ ui.label("Perspective view");+ ui.checkbox(&mut app.ui.perspective, "");+ ui.end_row();+ ui.label("Visual style");+ let styles = ["Shaded with edges", "Shaded", "Wireframe"];+ egui::ComboBox::from_id_salt("pref_style").selected_text(styles[usize::from(app.ui.visual_style.min(2))]).show_ui(+ ui,+ |ui| {+ for (i, s) in styles.iter().enumerate() {+ ui.selectable_value(&mut app.ui.visual_style, i as u8, *s);+ }+ },+ );+ ui.end_row();+ ui.label("Length decimals");+ ui.add(egui::DragValue::new(&mut app.preferences.length_decimals).range(0..=6));+ ui.end_row();+ ui.label("Angle decimals");+ ui.add(egui::DragValue::new(&mut app.preferences.angle_decimals).range(0..=6));+ ui.end_row();+ ui.label("Anti-aliasing");+ egui::ComboBox::from_id_salt("pref_msaa").selected_text(format!("{}×", app.preferences.msaa)).show_ui(ui, |ui| {+ for m in MSAA {+ ui.selectable_value(&mut app.preferences.msaa, m, format!("{m}×"));+ }+ });+ ui.end_row();+ ui.label("");+ ui.label(RichText::new("Anti-aliasing applies the next time SolveCraft starts").size(11.0).color(t.text_dim));+ ui.end_row();+ }+ 3 => {+ ui.label("Project face edges into new sketches");+ let mut auto = app.session.auto_project;+ if ui.checkbox(&mut auto, "").changed() {+ let _ = app.run("sketch.auto_project", json!({ "value": auto }));+ }+ ui.end_row();+ }+ _ => {+ ui.label("Click selects whole bodies");+ ui.checkbox(&mut app.ui.pick_bodies, "");+ ui.end_row();+ }+ });+ });+ });+ });+ if app.preferences.msaa != before.msaa {+ save_graphics(app);+ }+ if !open {+ app.prefs_window.open = false;+ }+}++/// Set preferences from JSON (control channel); returns them all.+pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Value, String> {+ let mut cur = serde_json::to_value(&app.preferences).map_err(|e| e.to_string())?;+ if let (Some(o), Some(src)) = (cur.as_object_mut(), p.as_object()) {+ for (k, v) in src {+ if !o.contains_key(k) {+ return Err(format!("unknown preference `{k}`"));+ }+ o.insert(k.clone(), v.clone());+ }+ }+ let new: Prefs = serde_json::from_value(cur).map_err(|e| e.to_string())?;+ if !UNITS.contains(&new.default_units.as_str()) {+ return Err(format!("units must be one of {}", UNITS.join(", ")));+ }+ if !NAV_PRESETS.iter().any(|(id, _)| *id == new.nav) || !MSAA.contains(&new.msaa) {+ return Err("`nav` must be fusion, solidworks or inventor and `msaa` 1, 2, 4 or 8".into());+ }+ let msaa_changed = new.msaa != app.preferences.msaa;+ app.preferences = new;+ if msaa_changed {+ save_graphics(app);+ }+ serde_json::to_value(&app.preferences).map_err(|e| e.to_string())+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn presets_map_the_mouse_and_prefs_round_trip() {+ let mut app = SolveApp::new(solvecraft_engine::Session::default(), Default::default());+ let shift = Modifiers { shift: true, ..Default::default() };+ let ctrl = Modifiers { ctrl: true, ..Default::default() };+ let none = Modifiers::default();+ assert!(matches!(nav_mode(&app, true, false, none), Some(NavMode::Pan)));+ assert!(matches!(nav_mode(&app, true, false, shift), Some(NavMode::Orbit)));+ set(&mut app, &json!({"nav": "solidworks"})).unwrap();+ assert!(matches!(nav_mode(&app, true, false, none), Some(NavMode::Orbit)));+ assert!(matches!(nav_mode(&app, true, false, ctrl), Some(NavMode::Pan)));+ set(&mut app, &json!({"nav": "inventor", "zoom_reverse": true})).unwrap();+ assert!(matches!(nav_mode(&app, true, false, ctrl), Some(NavMode::Zoom)));+ assert_eq!(zoom_sign(&app), -1.0);+ assert!(matches!(nav_mode(&app, false, true, none), Some(NavMode::Orbit)), "right drag orbits everywhere");+ assert!(set(&mut app, &json!({"nav": "blender"})).is_err());+ assert!(set(&mut app, &json!({"default_units": "furlong"})).is_err());+ assert!(set(&mut app, &json!({"nope": 1})).is_err());+ // Kept between runs.+ let mut other = SolveApp::new(solvecraft_engine::Session::default(), Default::default());+ other.load_prefs(&app.prefs());+ assert_eq!(other.preferences, app.preferences);+ assert_eq!(format_length(25.4, "in", 3), "1.000 in");+ }++ #[test]+ fn orbiting_around_the_cursor_keeps_that_point_still() {+ let mut app = SolveApp::new(solvecraft_engine::Session::default(), Default::default());+ app.run("PrimitiveBox", json!({"length": 40, "width": 40, "height": 40})).unwrap();+ app.preferences.orbit_cursor = true;+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));+ app.fit_view();+ let at = egui::pos2(500.0, 250.0);+ let pivot = pivot_under(&app, &crate::viewport::projection(&app, rect), at);+ orbit(&mut app, rect, 40.0, 25.0, Some(at));+ let s = crate::viewport::projection(&app, rect).to_screen(pivot).unwrap();+ assert!(s.distance(at) < 2.0, "{s:?}");+ }+}diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rsindex f1e1701aaa..e48a8daf76 100644--- a/crates/ui-egui/src/toolbar.rs+++ b/crates/ui-egui/src/toolbar.rs@@ -185,7 +185,7 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {}ui.separator();if item(ui, "Preferences…", "") {- app.dialog = Some(crate::dialogs::Dialog::preferences());+ app.prefs_window.open = true;close = true;}if item(ui, "Keyboard Shortcuts…", "") {diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 8f85ebfde5..f7f7fdd5b0 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -45,6 +45,8 @@ pub struct ViewportState {pub hover_feature: Option<u64>,/// Bodies whose browser row is under the cursor: highlighted the same way.pub hover_bodies: Vec<String>,+ /// The model point an orbit turns around (Preferences: orbit around the cursor).+ pub orbit_pivot: Option<Vec3>,pub build_ms: f64,/// The right-click menu, open at this screen position.pub context_menu: Option<Pos2>,@@ -1057,7 +1059,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {// ---- navigation ----let h = rect.height().max(1.0) as f64;if inside && scroll != 0.0 {- let f = (-scroll as f64 * 0.0015).exp();+ let f = (-scroll as f64 * 0.0015 * crate::prefs::zoom_sign(app)).exp();let anchor = hover.map(|p| {let proj = projection(app, rect);let (o, d) = proj.ray(p);@@ -1071,10 +1073,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let dragging = resp.dragged() || (inside && (middle || secondary_down));if dragging && delta != egui::Vec2::ZERO {let (dx, dy) = (delta.x as f64, delta.y as f64);- let mode = if middle && (mods.shift) || (secondary_down && !middle) {- Some(NavMode::Orbit)- } else if middle {- Some(NavMode::Pan)+ let mode = if middle || secondary_down {+ crate::prefs::nav_mode(app, middle, secondary_down, mods)} else if primary_down {app.viewport.nav} else {@@ -1084,12 +1084,18 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {app.cancel_view_animation();}match mode {- Some(NavMode::Orbit) => app.cam.orbit(dx, dy),+ Some(NavMode::Orbit) => {+ let press = ui.input(|i| i.pointer.press_origin());+ crate::prefs::orbit(app, rect, dx, dy, press);+ }Some(NavMode::Pan) => app.cam.pan(dx, dy, h),Some(NavMode::Zoom) => app.cam.zoom_at((dy * 0.01).exp(), None),None => {}}}+ if !dragging {+ app.viewport.orbit_pivot = None;+ }if !app.cam.is_valid() {app.cam = Camera::default();app.fit_view();diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 0e3cbb3d69..4c62cd5f2c 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -48,6 +48,7 @@ Commands never open dialogs when run this way. `solvecraft-cli commands` prints| `ui.home` | `open?`: bool; `sample?`: index | the start page: show or hide it, open a built-in sample (once built); returns `open` and the recent designs || `ui.shortcut` | `command`, `key?`, `replace?` | a command's key, or rebinds it (`""` clears; a key another command uses is refused unless `replace`) || `ui.help` | `item?`: `about`, `shortcuts` (read only), `report` (copies diagnostics) | the version, commit, build date and diagnostic text |+| `ui.prefs` | any of `default_units`, `nav` (`fusion`, `solidworks`, `inventor`), `zoom_reverse`, `orbit_cursor`, `msaa`, `length_decimals`, `angle_decimals` | sets preferences (kept between runs), returns them all || `ui.window` | `action`: minimize, maximize, restore, toggle, close | what the title bar's caption buttons do (on Windows and Linux the application bar is the title bar) || `ui.resize` | `width`, `height` | || `app.quit` | — | |