Skip to content

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

Mouse gestures: ring of tools on the right button, per studio and customizable (#2934) (#2936)

Georgette876d57a67b4d
diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs
index 871e4e600d..46429a9c5d 100644
--- a/crates/ui-egui/src/context_menu.rs
+++ b/crates/ui-egui/src/context_menu.rs
@@ -129,7 +129,7 @@ impl Item {
pub fn on_if(self, enabled: bool) -> Item {
self.on(enabled)
}
- fn on(mut self, enabled: bool) -> Item {
+ pub(crate) fn on(mut self, enabled: bool) -> Item {
self.enabled &= enabled;
self
}
@@ -140,7 +140,7 @@ impl Item {
}
/// A command entry: label, icon, shortcut and enablement come from the registry.
-fn cmd(app: &SolveApp, id: &str, label: &str) -> Item {
+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(),
@@ -158,7 +158,7 @@ fn cmd(app: &SolveApp, id: &str, label: &str) -> Item {
}
/// A view action (`ui.*`).
-fn act(id: &str, label: &str, icon: &str) -> Item {
+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 }
}
@@ -1604,7 +1604,7 @@ fn slot_rect(c: Pos2, k: usize, size: Vec2) -> Rect {
/// 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 {
+ if !app.preferences.radial_context_menu || crate::mouse_gesture::active(app) {
app.menu.press = None;
app.menu.flick = false;
app.menu.radial = false;
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 5fbbe848ad..1b3b9a4467 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -77,6 +77,7 @@ mod loft_rails_dialog_tests;
#[cfg(test)]
mod look_at_tests;
mod material_card_review;
+
#[cfg(test)]
mod measurement_ui_tests;
#[cfg(test)]
@@ -130,6 +131,7 @@ pub(crate) mod display_lod;
mod file_load_ui_tests;
#[cfg(test)]
mod fillet_spline_handle_tests;
+pub mod mouse_gesture;
pub(crate) mod navigation;
pub(crate) mod open_meshing;
pub mod palette;
@@ -339,6 +341,8 @@ pub struct SolveApp {
pub palette: palette::Palette,
/// Context menus, rename box and Properties window.
pub menu: context_menu::MenuState,
+ /// Mouse gestures: the ring of tools and its customization window.
+ pub gesture: mouse_gesture::State,
/// Browser tree state (reveal, groups being edited, occurrence moves).
pub tree: browser::TreeState,
/// A saved design copied for insertion into another open document.
@@ -486,6 +490,7 @@ impl SolveApp {
material_card_review: None,
palette: palette::Palette::default(),
menu: context_menu::MenuState::default(),
+ gesture: mouse_gesture::State::default(),
tree: browser::TreeState::default(),
linked_design_clipboard: None,
sbox: shortcut_box::ShortcutBox::default(),
@@ -1514,6 +1519,7 @@ impl SolveApp {
stand_up::show(self, ui.ctx());
prefs::show_reset_notice(self, ui.ctx());
context_menu::show(self, ui.ctx());
+ mouse_gesture::show(self, ui.ctx());
delete::show(self, ui.ctx());
shortcut_box::show(self, ui.ctx());
prefs::show(self, ui.ctx());
diff --git a/crates/ui-egui/src/mouse_gesture.rs b/crates/ui-egui/src/mouse_gesture.rs
new file mode 100644
index 0000000000..55c8f9594c
--- /dev/null
+++ b/crates/ui-egui/src/mouse_gesture.rs
@@ -0,0 +1,1201 @@
+//! Mouse gestures: a ring of tools that opens under the pointer when the right button is held and
+//! the pointer moves [`OPEN_DRAG`] points, a different set in each studio, taken by touching a
+//! tool's zone.
+//!
+//! Gestures work with the SolidWorks mouse mode only (the wheel orbits, Ctrl + wheel pans). While
+//! they are on, the right button no longer orbits the view (`prefs::nav_mode`) and the optional
+//! radial menu is off (`context_menu::track_hold` asks [`active`]). A right-click that does not
+//! move still opens the usual context menu (or finishes the tool in progress); one that moves
+//! far enough opens the ring instead, even while a tool is in progress, and the click that ends
+//! it opens no menu ([`took_press`]). With gestures off nothing changes.
+//!
+//! The ring is 280 points across inside and 350 outside. Every tool has a zone, and only tools
+//! have zones: five tools make five equal parts of the circle. Zones alternate between two tints,
+//! with a third one on the last zone when their number is odd, so no two zones side by side
+//! share a tint ([`tint`]). A tool is taken as soon as the pointer leaves the hub into its zone
+//! ([`entered`]); the zones reach outward without limit.
+//!
+//! A [`Studio`] is the part of the application the person is working in: a tab of the Design
+//! workspace, a sketch being edited, or the Render workspace. Each has its own default tools, and
+//! [`Config`] (kept with the preferences, edited in [`editor`]) holds the person's own list for
+//! any of them: how many tools and in which place, clockwise from the top.
+
+use std::collections::BTreeMap;
+
+use egui::{Align2, Color32, FontId, Mesh, Painter, Pos2, Rect, Sense, Shape, Stroke, Vec2, pos2, vec2};
+use serde::{Deserialize, Serialize};
+
+use crate::SolveApp;
+use crate::context_menu::{Item, act, cmd};
+use crate::theme::Tokens;
+
+/// Most tools one ring may hold.
+pub(crate) const MAX_TOOLS: usize = 12;
+/// Radius of the hub: the ring is 280 points across inside.
+pub(crate) const HUB: f32 = 140.0;
+/// Outer radius: 350 points across. The zones themselves continue outward.
+pub(crate) const RING: f32 = 175.0;
+/// Space between two drawn zones, in degrees.
+const GAP: f32 = 1.5;
+/// Points sampled along one frame's pointer move when looking for the zone it touched.
+const SAMPLES: usize = 48;
+/// The only mouse mode gestures work with.
+pub(crate) const MOUSE_MODE: &str = "solidworks";
+
+// ---------------------------------------------------------------------------------------------
+// Studios and their tools
+// ---------------------------------------------------------------------------------------------
+
+/// Where the person is working. Each studio has its own ring.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) enum Studio {
+ /// The Solid tab (and the tabs that have no ring of their own).
+ Part,
+ /// A sketch is being edited.
+ Sketch,
+ Surface,
+ SheetMetal,
+ Plastic,
+ Mesh,
+ /// The Render workspace.
+ Render,
+}
+
+const PART: [&str; 8] = ["repeat", "delete", "solid.press_pull", "solid.hole", "sketch.create", "solid.extrude", "undo", "solid.move"];
+const SKETCH: [&str; 8] =
+ ["repeat", "delete", "sketch.line", "sketch.rectangle.two_point", "ui.finishSketch", "sketch.circle.center", "undo", "sketch.dimension"];
+const SURFACE: [&str; 8] = ["repeat", "delete", "surface.extrude", "surface.loft", "sketch.create", "surface.patch", "undo", "surface.trim"];
+const SHEET_METAL: [&str; 8] = ["repeat", "delete", "sheet.flange", "sheet.hem", "sketch.create", "sheet.fold", "undo", "sheet.flat_pattern"];
+const PLASTIC: [&str; 8] = ["repeat", "delete", "plastic.boss", "plastic.lip", "sketch.create", "plastic.snap_fit", "undo", "plastic.rest"];
+const MESH: [&str; 8] = ["repeat", "delete", "file.save_mesh", "inspect.measure", "inspect.section", "solid.move", "undo", "inspect.interference"];
+const RENDER: [&str; 8] = ["render.start", "render.scene", "ui.fit", "ui.home", "ui.workspace.design", "repeat", "undo", "ui.clear"];
+
+impl Studio {
+ pub(crate) const ALL: [Studio; 7] =
+ [Studio::Part, Studio::Sketch, Studio::Surface, Studio::SheetMetal, Studio::Plastic, Studio::Mesh, Studio::Render];
+
+ /// The studio the application is in now.
+ pub(crate) fn of(app: &SolveApp) -> Studio {
+ if crate::render_workspace::active(app) {
+ Studio::Render
+ } else if app.session.active_sketch.is_some() {
+ Studio::Sketch
+ } else {
+ match app.ui.tab.as_str() {
+ "SURFACE" => Studio::Surface,
+ "SHEET METAL" => Studio::SheetMetal,
+ "PLASTIC" => Studio::Plastic,
+ "MESH" => Studio::Mesh,
+ _ => Studio::Part,
+ }
+ }
+ }
+
+ /// The name the preferences keep this studio's list under.
+ pub(crate) fn key(self) -> &'static str {
+ match self {
+ Studio::Part => "part",
+ Studio::Sketch => "sketch",
+ Studio::Surface => "surface",
+ Studio::SheetMetal => "sheet_metal",
+ Studio::Plastic => "plastic",
+ Studio::Mesh => "mesh",
+ Studio::Render => "render",
+ }
+ }
+
+ pub(crate) fn label(self) -> &'static str {
+ match self {
+ Studio::Part => "Part",
+ Studio::Sketch => "Sketch",
+ Studio::Surface => "Surface",
+ Studio::SheetMetal => "Sheet Metal",
+ Studio::Plastic => "Plastic",
+ Studio::Mesh => "Mesh",
+ Studio::Render => "Render",
+ }
+ }
+
+ /// The studio's tools as shipped, clockwise from the top.
+ pub(crate) fn defaults(self) -> &'static [&'static str] {
+ match self {
+ Studio::Part => &PART,
+ Studio::Sketch => &SKETCH,
+ Studio::Surface => &SURFACE,
+ Studio::SheetMetal => &SHEET_METAL,
+ Studio::Plastic => &PLASTIC,
+ Studio::Mesh => &MESH,
+ Studio::Render => &RENDER,
+ }
+ }
+}
+
+/// Tools that are not commands: what they are called in a list of tools.
+const SPECIALS: [(&str, &str); 3] = [("repeat", "Repeat"), ("delete", "Delete"), ("undo", "Undo")];
+/// View actions (`ui.*`): id, label, icon.
+const ACTIONS: [(&str, &str, &str); 5] = [
+ ("ui.fit", "Fit", "fit"),
+ ("ui.home", "Home View", "home"),
+ ("ui.finishSketch", "Finish Sketch", "finish"),
+ ("ui.workspace.design", "Design Workspace", "box"),
+ ("ui.clear", "Clear Selection", ""),
+];
+
+/// A command's label without its shortcut hint: `Line (L)` is `Line`.
+fn short(label: &str) -> &str {
+ label.split(" (").next().unwrap_or(label).trim()
+}
+
+/// What a tool is called, or none when `id` is not a tool.
+pub(crate) fn label_of(id: &str) -> Option<String> {
+ if let Some((_, label)) = SPECIALS.iter().find(|(i, _)| *i == id) {
+ return Some((*label).to_string());
+ }
+ if let Some((_, label, _)) = ACTIONS.iter().find(|(i, _, _)| *i == id) {
+ return Some((*label).to_string());
+ }
+ solidcraft_engine::find_command(id).map(|spec| short(spec.label).to_string())
+}
+
+/// The tool `id` as a menu item (its state follows the design), or none for an unknown id.
+pub(crate) fn item(app: &SolveApp, id: &str) -> Option<Item> {
+ match id {
+ "repeat" => Some(match &app.last_command {
+ Some((_, label)) => act("ui.repeat", &format!("Repeat {label}"), "redo"),
+ None => act("ui.repeat", "Repeat", "redo").on(false),
+ }),
+ "delete" => Some(act("ui.delete", "Delete", "delete").key("Del").on(!app.session.selection.is_empty())),
+ "undo" => Some(cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty())),
+ _ => match ACTIONS.iter().find(|(i, _, _)| *i == id) {
+ Some((i, label, icon)) => Some(act(i, label, icon)),
+ None => solidcraft_engine::find_command(id).map(|spec| cmd(app, spec.id, short(spec.label))),
+ },
+ }
+}
+
+/// Every tool a ring can hold, as (id, label): the specials and view actions, then the commands
+/// that sit on the toolbar.
+pub(crate) fn catalog() -> Vec<(String, String)> {
+ let mut v: Vec<(String, String)> = SPECIALS.iter().map(|(i, l)| ((*i).to_string(), (*l).to_string())).collect();
+ v.extend(ACTIONS.iter().map(|(i, l, _)| ((*i).to_string(), (*l).to_string())));
+ for spec in solidcraft_engine::command_specs() {
+ if !spec.tab.is_empty() && spec.planned.is_none() && !v.iter().any(|(i, _)| i == spec.id) {
+ v.push((spec.id.to_string(), short(spec.label).to_string()));
+ }
+ }
+ v
+}
+
+// ---------------------------------------------------------------------------------------------
+// The person's settings
+// ---------------------------------------------------------------------------------------------
+
+/// The gesture settings, kept with the preferences.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct Config {
+ /// Gestures are on (they also need the SolidWorks mouse mode, see [`active`]).
+ pub enabled: bool,
+ /// A studio's own list of tool ids, clockwise from the top, by [`Studio::key`]. A studio
+ /// without an entry uses its default tools.
+ pub wheels: BTreeMap<String, Vec<String>>,
+}
+
+impl Config {
+ /// The tool ids of `studio`: the person's list cleaned of unknown and repeated ids and cut
+ /// to [`MAX_TOOLS`], or the studio's defaults when nothing usable is left.
+ pub(crate) fn tools(&self, studio: Studio) -> Vec<String> {
+ let mut out: Vec<String> = Vec::new();
+ for id in self.wheels.get(studio.key()).into_iter().flatten() {
+ if out.len() < MAX_TOOLS && label_of(id).is_some() && !out.contains(id) {
+ out.push(id.clone());
+ }
+ }
+ if out.is_empty() { studio.defaults().iter().map(|s| (*s).to_string()).collect() } else { out }
+ }
+
+ /// Whether `studio` has a list of its own.
+ pub(crate) fn is_custom(&self, studio: Studio) -> bool {
+ self.wheels.contains_key(studio.key())
+ }
+
+ pub(crate) fn set_tools(&mut self, studio: Studio, tools: Vec<String>) {
+ self.wheels.insert(studio.key().to_string(), tools);
+ }
+
+ /// Puts `studio` back to its default tools.
+ pub(crate) fn reset(&mut self, studio: Studio) {
+ self.wheels.remove(studio.key());
+ }
+}
+
+/// Gestures are on and the mouse mode allows them.
+pub(crate) fn active(app: &SolveApp) -> bool {
+ app.preferences.mouse_gestures.enabled && app.preferences.nav == MOUSE_MODE
+}
+
+/// The ring's tools in `studio` as menu items, unknown ids dropped.
+pub(crate) fn items(app: &SolveApp, studio: Studio) -> Vec<Item> {
+ app.preferences.mouse_gestures.tools(studio).iter().filter_map(|id| item(app, id)).collect()
+}
+
+// ---------------------------------------------------------------------------------------------
+// Geometry
+// ---------------------------------------------------------------------------------------------
+
+/// The zone of an `n`-tool ring a pointer offset from its centre is in: none inside the hub.
+/// Zone 0 is centred on the top and the rest follow clockwise (screen y points down); each takes
+/// `360 / n` degrees.
+pub(crate) fn sector(d: Vec2, n: usize) -> Option<usize> {
+ if n == 0 || !d.is_finite() || d.length() < HUB {
+ return None;
+ }
+ let step = 360.0 / n as f32;
+ let a = d.x.atan2(-d.y).to_degrees();
+ let k = ((a + 360.0 + step / 2.0) / step).floor() as i64;
+ Some(k.rem_euclid(n as i64) as usize)
+}
+
+/// The enabled tool whose zone the pointer touched moving straight from `from` to `to` around a
+/// ring centred at `c` with `enabled.len()` tools: the first one on the way, so a fast stroke
+/// between two frames still takes the tool it began toward. Zones that are off are passed over.
+pub(crate) fn entered(c: Pos2, from: Pos2, to: Pos2, enabled: &[bool]) -> Option<usize> {
+ if !(c.is_finite() && from.is_finite() && to.is_finite()) {
+ return None;
+ }
+ let n = enabled.len();
+ let on = |p: Pos2| sector(p - c, n).filter(|k| enabled.get(*k).copied().unwrap_or(false));
+ let (f, d) = (from - c, to - from);
+ // Leaving the hub: the zone is the one at the exit point, which a sample could step past.
+ let a = d.dot(d);
+ if f.length() < HUB && a > 1e-9 {
+ let (b, cc) = (2.0 * f.dot(d), f.dot(f) - HUB * HUB);
+ let disc = b * b - 4.0 * a * cc;
+ if disc >= 0.0 {
+ let t = (-b + disc.sqrt()) / (2.0 * a);
+ if (0.0..=1.0).contains(&t) {
+ // A hair past the edge, so rounding can't leave the point in the hub.
+ if let Some(k) = on(c + (f + d * t) * 1.001) {
+ return Some(k);
+ }
+ }
+ }
+ }
+ (1..=SAMPLES).find_map(|i| on(from + d * (i as f32 / SAMPLES as f32)))
+}
+
+/// Which of the three tints zone `k` of `n` takes: 0 and 1 alternate, and when `n` is odd the
+/// last zone takes 2, so it differs from both its neighbours (the one before it and zone 0).
+pub(crate) fn tint(n: usize, k: usize) -> usize {
+ if n % 2 == 1 && n > 1 && k == n - 1 { 2 } else { k % 2 }
+}
+
+/// The three tints, from the theme.
+fn palette(t: &Tokens) -> [Color32; 3] {
+ [t.panel, t.panel.lerp_to_gamma(t.text, 0.30), t.panel.lerp_to_gamma(t.text, 0.55)]
+}
+
+/// How far (points) the pointer moves with the right button held before the ring opens; a press
+/// that stays inside this is a right-click.
+pub(crate) const OPEN_DRAG: f32 = 4.0;
+
+/// Where a ring opened by a press at `at` is centred: there, or as near as keeps it on screen.
+fn centre_for(at: Pos2, screen: Rect) -> Pos2 {
+ let m = RING + 6.0;
+ let x = if screen.width() > 2.0 * m { at.x.clamp(screen.left() + m, screen.right() - m) } else { screen.center().x };
+ let y = if screen.height() > 2.0 * m { at.y.clamp(screen.top() + m, screen.bottom() - m) } else { screen.center().y };
+ pos2(x, y)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Drawing
+// ---------------------------------------------------------------------------------------------
+
+/// Draws the ring centred at `c`, `scale` times its real size: one zone per tool, tinted
+/// alternately, the zone the pointer is in lit, an icon in each, and in the hub the lit tool's
+/// name (the studio's when none is).
+pub(crate) fn paint(painter: &Painter, c: Pos2, scale: f32, studio: Studio, items: &[Item], pointer: Option<Pos2>, t: Tokens) {
+ let n = items.len();
+ if n == 0 {
+ return;
+ }
+ let (hub, ring) = (HUB * scale, RING * scale);
+ let hot = pointer.and_then(|p| sector((p - c) / scale, n));
+ let tints = palette(&t);
+ let step = 360.0 / n as f32;
+ let gap = if n > 1 { GAP } else { 0.0 };
+ painter.circle(c, hub, t.panel.gamma_multiply(0.5), Stroke::new(1.0, t.border));
+ for (k, item) in items.iter().enumerate() {
+ let lit = item.enabled && hot == Some(k);
+ let base = tints[tint(n, k)];
+ let (fill, edge) = match (item.enabled, lit) {
+ (_, true) => (t.accent_soft, t.accent),
+ (true, false) => (base, t.border),
+ (false, false) => (base.gamma_multiply(0.6), t.border.gamma_multiply(0.7)),
+ };
+ let mid = k as f32 * step;
+ zone(painter, c, hub, ring, mid - step / 2.0 + gap / 2.0, mid + step / 2.0 - gap / 2.0, fill, edge);
+ if !item.icon.is_empty() {
+ let a = mid.to_radians();
+ let at = c + vec2(a.sin(), -a.cos()) * (hub + ring) / 2.0;
+ let ink = if item.enabled { t.icon } else { t.border };
+ let side = (24.0 * scale).max(12.0);
+ crate::icons::paint(painter, Rect::from_center_size(at, vec2(side, side)), &item.icon, ink, t.icon_fill, t.accent);
+ }
+ }
+ match hot.and_then(|k| items.get(k)).filter(|i| i.enabled) {
+ Some(item) => {
+ painter.text(c, Align2::CENTER_CENTER, crate::i18n::tr_label(&item.label), FontId::proportional((20.0 * scale).max(9.0)), t.text)
+ }
+ None => {
+ painter.text(c, Align2::CENTER_CENTER, crate::i18n::tr_label(studio.label()), FontId::proportional((16.0 * scale).max(9.0)), t.text_dim)
+ }
+ };
+}
+
+/// One zone of the ring, between `a0` and `a1` degrees clockwise from the top.
+fn zone(painter: &Painter, c: Pos2, inner: f32, outer: f32, a0: f32, a1: f32, fill: Color32, edge: Color32) {
+ let at = |deg: f32, r: f32| {
+ let a = deg.to_radians();
+ c + vec2(a.sin(), -a.cos()) * r
+ };
+ let steps = (((a1 - a0) / 3.0).ceil() as usize).clamp(2, 120);
+ let mut mesh = Mesh::default();
+ let mut outline: Vec<Pos2> = Vec::with_capacity(2 * (steps + 1));
+ for i in 0..=steps {
+ let deg = a0 + (a1 - a0) * i as f32 / steps as f32;
+ mesh.colored_vertex(at(deg, inner), fill);
+ mesh.colored_vertex(at(deg, outer), fill);
+ outline.push(at(deg, outer));
+ if i < steps {
+ let k = 2 * i as u32;
+ mesh.add_triangle(k, k + 1, k + 2);
+ mesh.add_triangle(k + 1, k + 3, k + 2);
+ }
+ }
+ for i in (0..=steps).rev() {
+ outline.push(at(a0 + (a1 - a0) * i as f32 / steps as f32, inner));
+ }
+ painter.add(Shape::mesh(mesh));
+ painter.add(Shape::closed_line(outline, Stroke::new(1.0, edge)));
+}
+
+// ---------------------------------------------------------------------------------------------
+// The gesture
+// ---------------------------------------------------------------------------------------------
+
+/// What gestures keep between frames.
+#[derive(Default)]
+pub struct State {
+ /// The ring that is open.
+ wheel: Option<Wheel>,
+ /// Where the right button went down, until the pointer has moved [`OPEN_DRAG`] from it.
+ press: Option<Pos2>,
+ /// The right button that is down (or was last) opened a ring: its release is no click.
+ used: bool,
+ /// The customization window.
+ pub(crate) editor: Editor,
+}
+
+struct Wheel {
+ centre: Pos2,
+ studio: Studio,
+ /// The pointer on the last frame: the move since then is what may touch a zone.
+ from: Pos2,
+ /// The pointer has been in the hub since the ring opened, so a zone it is in is one it moved
+ /// into (a ring pushed off the screen's edge opens with the pointer outside its hub).
+ armed: bool,
+}
+
+/// One frame of gestures: opens, runs and closes the ring, draws it, and shows the editor.
+pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
+ track(app, ctx);
+ paint_open(app, ctx);
+ editor(app, ctx);
+}
+
+/// The right button last pressed opened the ring, so letting go of it is not a right-click.
+pub(crate) fn took_press(app: &SolveApp) -> bool {
+ app.gesture.used
+}
+
+/// Whether a ring is open.
+#[cfg(test)]
+pub(crate) fn is_open(app: &SolveApp) -> bool {
+ app.gesture.wheel.is_some()
+}
+
+fn track(app: &mut SolveApp, ctx: &egui::Context) {
+ if !active(app) {
+ app.gesture.wheel = None;
+ app.gesture.press = None;
+ app.gesture.used = false;
+ return;
+ }
+ let (pressed, down, pos, esc) = ctx.input(|i| {
+ (
+ i.pointer.button_pressed(egui::PointerButton::Secondary),
+ i.pointer.secondary_down(),
+ i.pointer.latest_pos(),
+ i.key_pressed(egui::Key::Escape),
+ )
+ });
+ // Letting go, or Esc, leaves nothing half-way.
+ if !down || esc {
+ app.gesture.wheel = None;
+ app.gesture.press = None;
+ return;
+ }
+ let Some(pos) = pos else { return };
+ // A press in the viewport waits to see whether it is a click or the start of a gesture.
+ if pressed {
+ app.gesture.used = false;
+ app.gesture.press = (app.gesture.wheel.is_none() && app.viewport.mouse.is_some()).then_some(pos);
+ }
+ // Held and moved far enough: the ring opens where the button went down, whatever the pointer
+ // carries (a tool or a dialog in progress included).
+ if let Some(at) = app.gesture.press
+ && (pos - at).length() >= OPEN_DRAG
+ {
+ app.gesture.press = None;
+ let studio = Studio::of(app);
+ if !items(app, studio).is_empty() {
+ let centre = centre_for(at, ctx.content_rect());
+ app.gesture.wheel = Some(Wheel { centre, studio, from: at, armed: (at - centre).length() < HUB });
+ app.gesture.used = true;
+ }
+ }
+ let Some((centre, studio, from, armed)) = app.gesture.wheel.as_mut().map(|w| {
+ let from = w.from;
+ w.from = pos;
+ w.armed |= (from - w.centre).length() < HUB;
+ (w.centre, w.studio, from, w.armed)
+ }) else {
+ return;
+ };
+ if !armed {
+ return;
+ }
+ let list = items(app, studio);
+ let enabled: Vec<bool> = list.iter().map(|i| i.enabled).collect();
+ if let Some(k) = entered(centre, from, pos, &enabled)
+ && let Some(tool) = list.get(k)
+ {
+ app.gesture.wheel = None;
+ crate::context_menu::run_item(app, tool, centre);
+ }
+}
+
+fn paint_open(app: &SolveApp, ctx: &egui::Context) {
+ let Some(wheel) = &app.gesture.wheel else { return };
+ let list = items(app, wheel.studio);
+ let t = Tokens::get();
+ let pointer = ctx.input(|i| i.pointer.latest_pos());
+ let area = Rect::from_center_size(wheel.centre, vec2(2.0 * (RING + 6.0), 2.0 * (RING + 6.0)));
+ crate::frame::area(egui::Id::new("sc_mouse_gesture")).fixed_pos(area.min).order(egui::Order::Foreground).show(ctx, |ui| {
+ let (r, _) = ui.allocate_exact_size(area.size(), Sense::hover());
+ paint(&ui.painter_at(r.expand(4.0)), wheel.centre, 1.0, wheel.studio, &list, pointer, t);
+ });
+}
+
+// ---------------------------------------------------------------------------------------------
+// Customization
+// ---------------------------------------------------------------------------------------------
+
+/// The customization window's state.
+pub(crate) struct Editor {
+ pub(crate) open: bool,
+ pub(crate) studio: Studio,
+}
+
+impl Default for Editor {
+ fn default() -> Self {
+ Editor { open: false, studio: Studio::Part }
+ }
+}
+
+/// A change to a list of tools.
+#[derive(Clone, Debug, PartialEq)]
+enum Op {
+ Up(usize),
+ Down(usize),
+ Remove(usize),
+ Add,
+ Set(usize, String),
+}
+
+/// The first tool of the catalog that `list` doesn't hold.
+fn next_unused(list: &[String]) -> Option<String> {
+ catalog().into_iter().map(|(id, _)| id).find(|id| !list.contains(id))
+}
+
+/// Applies `op` to `list`; false when it was refused (a ring keeps 1 to [`MAX_TOOLS`] tools, each
+/// of them known and none twice).
+fn apply(list: &mut Vec<String>, op: Op) -> bool {
+ match op {
+ Op::Up(i) if i > 0 && i < list.len() => {
+ list.swap(i, i - 1);
+ true
+ }
+ Op::Down(i) if i + 1 < list.len() => {
+ list.swap(i, i + 1);
+ true
+ }
+ Op::Remove(i) if list.len() > 1 && i < list.len() => {
+ list.remove(i);
+ true
+ }
+ Op::Add if list.len() < MAX_TOOLS => match next_unused(list) {
+ Some(id) => {
+ list.push(id);
+ true
+ }
+ None => false,
+ },
+ Op::Set(i, id) if i < list.len() && label_of(&id).is_some() && !list.contains(&id) => {
+ list[i] = id;
+ true
+ }
+ _ => false,
+ }
+}
+
+/// The rows of Preferences › Navigation that belong to gestures: the switch, the button that
+/// opens the editor, and what the mouse mode has to be.
+pub(crate) fn nav_rows(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
+ let note = |ui: &mut egui::Ui, s: &str| {
+ ui.label("");
+ ui.add(egui::Label::new(egui::RichText::new(crate::i18n::tr_label(s)).size(11.0).color(t.text_dim)).wrap());
+ ui.end_row();
+ };
+ ui.label(crate::i18n::tr_label("Mouse gestures"));
+ ui.horizontal(|ui| {
+ ui.checkbox(&mut app.preferences.mouse_gestures.enabled, crate::i18n::tr_label("Ring of tools on the right button"));
+ if ui.button(crate::i18n::tr_label("Customize…")).clicked() {
+ app.gesture.editor.open = true;
+ app.gesture.editor.studio = Studio::of(app);
+ }
+ });
+ ui.end_row();
+ if app.preferences.nav != MOUSE_MODE {
+ ui.label("");
+ ui.horizontal_wrapped(|ui| {
+ ui.colored_label(
+ t.warning,
+ crate::i18n::tr_label("Mouse gestures only work with the SolidWorks mouse mode (the wheel orbits, Ctrl + wheel pans)."),
+ );
+ if ui.button(crate::i18n::tr_label("Use the SolidWorks mouse mode")).clicked() {
+ app.preferences.nav = MOUSE_MODE.to_string();
+ app.preferences.zoom_reverse = crate::prefs::nav_preset(MOUSE_MODE).reverse_zoom;
+ }
+ });
+ ui.end_row();
+ } else if app.preferences.mouse_gestures.enabled {
+ note(
+ ui,
+ "With gestures on, the right button no longer orbits the view: hold it and move to open the ring, then touch a tool's zone. A plain right-click still opens the menu.",
+ );
+ }
+}
+
+/// The customization window: pick a studio, then how many tools its ring holds, which, and in
+/// which place (clockwise from the top), with a preview of the ring.
+fn editor(app: &mut SolveApp, ctx: &egui::Context) {
+ if !app.gesture.editor.open {
+ return;
+ }
+ let t = Tokens::get();
+ let mut open = true;
+ let mut studio = app.gesture.editor.studio;
+ let mut config = app.preferences.mouse_gestures.clone();
+ crate::frame::window(ctx, crate::i18n::tr_label("Mouse gestures"), crate::frame::Width::Wide)
+ .id(egui::Id::new("sc_gesture_editor"))
+ .open(&mut open)
+ .show(ctx, |ui| {
+ ui.checkbox(&mut config.enabled, crate::i18n::tr_label("Ring of tools on the right button"));
+ if app.preferences.nav != MOUSE_MODE {
+ ui.colored_label(
+ t.warning,
+ crate::i18n::tr_label("Mouse gestures only work with the SolidWorks mouse mode (the wheel orbits, Ctrl + wheel pans)."),
+ );
+ }
+ ui.horizontal(|ui| {
+ ui.label(crate::i18n::tr_label("Studio"));
+ egui::ComboBox::from_id_salt("gesture_studio").selected_text(crate::i18n::tr_label(studio.label())).show_ui(ui, |ui| {
+ for s in Studio::ALL {
+ ui.selectable_value(&mut studio, s, crate::i18n::tr_label(s.label()));
+ }
+ });
+ if ui.add_enabled(config.is_custom(studio), egui::Button::new(crate::i18n::tr_label("Restore this studio's tools"))).clicked() {
+ config.reset(studio);
+ }
+ });
+ ui.separator();
+ let mut list = config.tools(studio);
+ let catalog = catalog();
+ let mut op: Option<Op> = None;
+ ui.horizontal_top(|ui| {
+ ui.vertical(|ui| {
+ ui.set_min_width(330.0);
+ ui.label(
+ egui::RichText::new(format!("{} {}/{}", crate::i18n::tr_label("Tools, clockwise from the top"), list.len(), MAX_TOOLS))
+ .size(11.0)
+ .color(t.text_dim),
+ );
+ for i in 0..list.len() {
+ ui.horizontal(|ui| {
+ ui.label(format!("{}", i + 1));
+ let shown = label_of(&list[i]).unwrap_or_default();
+ egui::ComboBox::from_id_salt(("gesture_tool", i)).selected_text(shown).width(200.0).show_ui(ui, |ui| {
+ let filter_id = ui.id().with("filter");
+ let mut filter: String = ui.data_mut(|d| d.get_temp(filter_id).unwrap_or_default());
+ ui.add(egui::TextEdit::singleline(&mut filter).hint_text(crate::i18n::tr_label("Filter…")));
+ ui.data_mut(|d| d.insert_temp(filter_id, filter.clone()));
+ let needle = filter.trim().to_lowercase();
+ egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
+ for (id, label) in &catalog {
+ if !needle.is_empty() && !label.to_lowercase().contains(&needle) && !id.to_lowercase().contains(&needle) {
+ continue;
+ }
+ let taken = list.contains(id) && *id != list[i];
+ let r = ui.add_enabled(!taken, egui::Button::selectable(*id == list[i], label.as_str()));
+ if r.clicked() {
+ op = Some(Op::Set(i, id.clone()));
+ ui.close();
+ }
+ }
+ });
+ });
+ if ui.add_enabled(i > 0, egui::Button::new("↑")).clicked() {
+ op = Some(Op::Up(i));
+ }
+ if ui.add_enabled(i + 1 < list.len(), egui::Button::new("↓")).clicked() {
+ op = Some(Op::Down(i));
+ }
+ if ui.add_enabled(list.len() > 1, egui::Button::new("×")).clicked() {
+ op = Some(Op::Remove(i));
+ }
+ });
+ }
+ if ui.add_enabled(list.len() < MAX_TOOLS, egui::Button::new(crate::i18n::tr_label("Add a tool"))).clicked() {
+ op = Some(Op::Add);
+ }
+ });
+ ui.separator();
+ // The ring as it will look, a little smaller.
+ let scale = 0.62;
+ let side = 2.0 * RING * scale + 8.0;
+ let (r, _) = ui.allocate_exact_size(vec2(side, side), Sense::hover());
+ // Every tool as available, whatever the design allows now.
+ let preview: Vec<Item> = list
+ .iter()
+ .filter_map(|id| item(app, id))
+ .map(|mut i| {
+ i.enabled = true;
+ i
+ })
+ .collect();
+ paint(&ui.painter_at(r), r.center(), scale, studio, &preview, None, t);
+ });
+ if let Some(op) = op
+ && apply(&mut list, op)
+ {
+ config.set_tools(studio, list);
+ }
+ });
+ app.gesture.editor.studio = studio;
+ app.preferences.mouse_gestures = config;
+ app.gesture.editor.open = open;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use egui::pos2;
+
+ fn app() -> SolveApp {
+ SolveApp::new(solidcraft_engine::Session::default(), Default::default())
+ }
+
+ fn on(n: usize) -> Vec<bool> {
+ vec![true; n]
+ }
+
+ #[test]
+ fn the_ring_is_280_inside_and_350_outside() {
+ assert_eq!(HUB * 2.0, 280.0);
+ assert_eq!(RING * 2.0, 350.0);
+ }
+
+ #[test]
+ fn a_ring_of_n_tools_is_n_equal_parts_of_the_circle() {
+ for n in 1..=MAX_TOOLS {
+ let mut seen = vec![0usize; n];
+ // Walk the whole circle: every zone is met, none is missing, and each is the same size.
+ for deg in 0..3600 {
+ let a = (deg as f32 / 10.0).to_radians();
+ let k = sector(vec2(a.sin(), -a.cos()) * (HUB + 10.0), n).expect("outside the hub");
+ seen[k] += 1;
+ }
+ let (lo, hi) = (seen.iter().min().copied().unwrap_or(0), seen.iter().max().copied().unwrap_or(0));
+ assert!(lo > 0, "{n} tools: a part of the circle has no tool: {seen:?}");
+ assert!(hi - lo <= 2, "{n} tools: parts of different sizes: {seen:?}");
+ }
+ }
+
+ #[test]
+ fn zones_are_centred_clockwise_from_the_top_and_the_hub_has_none() {
+ let far = |x: f32, y: f32| vec2(x, y) * 400.0;
+ for (n, expect) in [(4, [0, 1, 2, 3]), (8, [0, 2, 4, 6])] {
+ let got = [sector(far(0.0, -1.0), n), sector(far(1.0, 0.0), n), sector(far(0.0, 1.0), n), sector(far(-1.0, 0.0), n)];
+ let want: Vec<Option<usize>> = if n == 4 { expect.iter().map(|k| Some(*k)).collect() } else { expect.iter().map(|k| Some(*k)).collect() };
+ assert_eq!(got.to_vec(), want, "{n} tools");
+ }
+ assert_eq!(sector(vec2(0.0, -(HUB - 1.0)), 5), None);
+ assert_eq!(sector(vec2(0.0, -(HUB + 1.0)), 5), Some(0));
+ assert_eq!(sector(vec2(f32::NAN, 200.0), 5), None);
+ assert_eq!(sector(vec2(0.0, -200.0), 0), None, "no tools, no zones");
+ assert_eq!(sector(vec2(0.0, -9000.0), 5), Some(0), "a zone reaches outward without limit");
+ // Five tools: 72 degrees each, so the zone to the right (90 degrees) is the second.
+ assert_eq!(sector(far(1.0, 0.0), 5), Some(1));
+ }
+
+ #[test]
+ fn no_two_zones_side_by_side_share_a_tint() {
+ for n in 2..=MAX_TOOLS {
+ for k in 0..n {
+ assert_ne!(tint(n, k), tint(n, (k + 1) % n), "{n} tools: zones {k} and {} match", (k + 1) % n);
+ }
+ let used = (0..n).map(|k| tint(n, k)).collect::<std::collections::BTreeSet<_>>().len();
+ assert_eq!(used, if n % 2 == 1 { 3 } else { 2 }, "{n} tools: two tints, three when odd");
+ }
+ assert_eq!((0..5).map(|k| tint(5, k)).collect::<Vec<_>>(), [0, 1, 0, 1, 2]);
+ assert_eq!((0..3).map(|k| tint(3, k)).collect::<Vec<_>>(), [0, 1, 2]);
+ assert_eq!(tint(1, 0), 0);
+ }
+
+ #[test]
+ fn the_three_tints_are_three_different_colours() {
+ for t in [Tokens::dark(), Tokens::light()] {
+ let p = palette(&t);
+ assert!(p[0] != p[1] && p[1] != p[2] && p[0] != p[2], "{p:?}");
+ }
+ }
+
+ #[test]
+ fn touching_a_zone_takes_it_as_the_pointer_leaves_the_hub() {
+ let c = pos2(500.0, 500.0);
+ assert_eq!(entered(c, c, c + vec2(0.0, HUB - 2.0), &on(8)), None, "still in the hub");
+ assert_eq!(entered(c, c, c + vec2(0.0, HUB + 2.0), &on(8)), Some(4), "two points past the hub's edge");
+ assert_eq!(entered(c, c, c + vec2(HUB + 2.0, 0.0), &on(5)), Some(1));
+ }
+
+ #[test]
+ fn a_fast_stroke_takes_the_zone_it_left_the_hub_into() {
+ let c = pos2(0.0, 0.0);
+ assert_eq!(entered(c, c, pos2(900.0, -300.0), &on(8)), Some(2), "the exit point decides, not the far end");
+ assert_eq!(entered(c, c, pos2(300.0, -900.0), &on(8)), Some(0));
+ assert_eq!(entered(c, c, pos2(-900.0, 900.0), &on(8)), Some(5));
+ assert_eq!(entered(c, pos2(-10.0, 0.0), pos2(-600.0, 40.0), &on(8)), Some(6));
+ }
+
+ #[test]
+ fn a_zone_that_is_off_is_passed_over() {
+ let c = pos2(0.0, 0.0);
+ let mut flags = on(8);
+ flags[4] = false;
+ assert_eq!(entered(c, c, pos2(0.0, 400.0), &flags), None, "straight down is off");
+ // Sliding round the ring from the off zone into an enabled one takes the enabled one.
+ assert_eq!(entered(c, pos2(0.0, 180.0), pos2(-180.0, 180.0), &flags), Some(5));
+ assert_eq!(entered(c, c, pos2(0.0, 400.0), &[]), None);
+ }
+
+ #[test]
+ fn hostile_numbers_touch_nothing() {
+ let c = pos2(0.0, 0.0);
+ for p in [pos2(f32::NAN, 0.0), pos2(f32::INFINITY, 5.0), pos2(0.0, f32::NEG_INFINITY)] {
+ assert_eq!(entered(c, c, p, &on(8)), None);
+ assert_eq!(entered(c, p, c, &on(8)), None);
+ assert_eq!(entered(p, c, pos2(0.0, 400.0), &on(8)), None);
+ }
+ assert_eq!(entered(c, c, c, &on(8)), None, "a pointer that did not move");
+ }
+
+ #[test]
+ fn studios_are_read_from_the_application() {
+ let mut app = app();
+ assert_eq!(Studio::of(&app), Studio::Part);
+ for (tab, studio) in [
+ ("SOLID", Studio::Part),
+ ("SURFACE", Studio::Surface),
+ ("MESH", Studio::Mesh),
+ ("SHEET METAL", Studio::SheetMetal),
+ ("PLASTIC", Studio::Plastic),
+ ("UTILITIES", Studio::Part),
+ ] {
+ app.ui.tab = tab.into();
+ assert_eq!(Studio::of(&app), studio, "{tab}");
+ }
+ app.ui.tab = "SURFACE".into();
+ app.session.execute("sketch.create", &serde_json::json!({"plane": "XY"})).expect("a sketch opens");
+ assert_eq!(Studio::of(&app), Studio::Sketch, "a sketch being edited beats the tab");
+ }
+
+ #[test]
+ fn every_studio_ships_distinct_tools_that_exist() {
+ let app = app();
+ let mut sets = Vec::new();
+ for studio in Studio::ALL {
+ let ids = studio.defaults();
+ let mut sorted = ids.to_vec();
+ sorted.sort_unstable();
+ sorted.dedup();
+ assert_eq!(sorted.len(), ids.len(), "{studio:?}: no tool twice");
+ for id in ids {
+ assert!(label_of(id).is_some() && item(&app, id).is_some(), "{studio:?}: `{id}` is not a tool");
+ }
+ assert_eq!(items(&app, studio).len(), ids.len());
+ sets.push(ids.to_vec());
+ }
+ for (i, a) in sets.iter().enumerate() {
+ for b in &sets[i + 1..] {
+ assert_ne!(a, b, "two studios share one ring");
+ }
+ }
+ let keys: std::collections::BTreeSet<_> = Studio::ALL.iter().map(|s| s.key()).collect();
+ assert_eq!(keys.len(), Studio::ALL.len(), "studio keys are unique");
+ }
+
+ #[test]
+ fn repeat_delete_and_undo_follow_the_state_of_the_design() {
+ let mut app = app();
+ assert!(!item(&app, "repeat").expect("a tool").enabled, "nothing to repeat yet");
+ assert!(!item(&app, "delete").expect("a tool").enabled, "nothing selected");
+ assert!(!item(&app, "undo").expect("a tool").enabled, "nothing to undo");
+ app.session.execute("solid.box", &serde_json::json!({"length": 10, "width": 10, "height": 10})).expect("a box");
+ assert!(item(&app, "undo").expect("a tool").enabled, "a command ran: undo is on");
+ assert!(item(&app, "no.such.tool").is_none());
+ }
+
+ #[test]
+ fn a_studio_uses_its_defaults_until_the_person_changes_them() {
+ let mut config = Config::default();
+ assert!(!config.enabled, "gestures start off");
+ assert_eq!(config.tools(Studio::Part), PART.iter().map(|s| s.to_string()).collect::<Vec<_>>());
+ assert!(!config.is_custom(Studio::Part));
+ config.set_tools(Studio::Part, vec!["solid.extrude".into(), "undo".into(), "solid.hole".into(), "delete".into(), "repeat".into()]);
+ assert_eq!(config.tools(Studio::Part).len(), 5, "five tools: five parts of the circle");
+ assert_eq!(config.tools(Studio::Part)[0], "solid.extrude");
+ assert!(config.is_custom(Studio::Part) && !config.is_custom(Studio::Sketch));
+ assert_eq!(config.tools(Studio::Sketch).len(), 8, "other studios keep their own");
+ config.reset(Studio::Part);
+ assert_eq!(config.tools(Studio::Part).len(), 8);
+ }
+
+ #[test]
+ fn a_hand_edited_list_is_cleaned_before_it_is_used() {
+ let mut config = Config::default();
+ let many: Vec<String> = (0..40).map(|_| "undo".to_string()).chain(catalog().into_iter().map(|(id, _)| id)).collect();
+ config.set_tools(Studio::Mesh, many);
+ let tools = config.tools(Studio::Mesh);
+ assert!(tools.len() <= MAX_TOOLS, "{} tools", tools.len());
+ let mut sorted = tools.clone();
+ sorted.sort_unstable();
+ sorted.dedup();
+ assert_eq!(sorted.len(), tools.len(), "no tool twice");
+ config.set_tools(Studio::Mesh, vec!["nonsense".into(), "".into(), "also.not.a.tool".into()]);
+ assert_eq!(config.tools(Studio::Mesh), MESH.iter().map(|s| s.to_string()).collect::<Vec<_>>(), "nothing usable: the defaults");
+ config.set_tools(Studio::Mesh, vec![]);
+ assert_eq!(config.tools(Studio::Mesh).len(), 8);
+ }
+
+ #[test]
+ fn settings_round_trip_and_older_preferences_load() {
+ let mut config = Config { enabled: true, ..Default::default() };
+ config.set_tools(Studio::Sketch, vec!["sketch.line".into(), "undo".into(), "sketch.circle.center".into()]);
+ let json = serde_json::to_string(&config).expect("serializes");
+ assert_eq!(serde_json::from_str::<Config>(&json).expect("loads"), config);
+ let none: Config = serde_json::from_str("{}").expect("an empty value is the default");
+ assert_eq!(none, Config::default());
+ assert!(
+ serde_json::from_str::<Config>(r#"{"enabled":true,"wheels":{"part":["undo"],"future":["x"]}}"#).is_ok(),
+ "unknown studios are kept, not fatal"
+ );
+ }
+
+ #[test]
+ fn the_editor_changes_how_many_tools_and_where_they_sit() {
+ let mut list: Vec<String> = ["solid.extrude", "undo", "solid.hole"].iter().map(|s| s.to_string()).collect();
+ assert!(apply(&mut list, Op::Down(0)));
+ assert_eq!(list, ["undo", "solid.extrude", "solid.hole"]);
+ assert!(apply(&mut list, Op::Up(2)));
+ assert_eq!(list, ["undo", "solid.hole", "solid.extrude"]);
+ assert!(!apply(&mut list, Op::Up(0)) && !apply(&mut list, Op::Down(2)), "can't move past the ends");
+ assert!(apply(&mut list, Op::Add) && list.len() == 4, "a tool is added");
+ assert!(!list[3].is_empty() && !list[..3].contains(&list[3]), "one the ring doesn't hold yet");
+ assert!(apply(&mut list, Op::Set(0, "solid.fillet".into())));
+ assert_eq!(list[0], "solid.fillet");
+ assert!(!apply(&mut list, Op::Set(1, "solid.fillet".into())), "no tool twice");
+ assert!(!apply(&mut list, Op::Set(1, "not.a.tool".into())), "only real tools");
+ assert!(!apply(&mut list, Op::Set(9, "undo".into())), "no such place");
+ assert!(apply(&mut list, Op::Remove(0)) && list.len() == 3);
+ while list.len() > 1 {
+ assert!(apply(&mut list, Op::Remove(0)));
+ }
+ assert!(!apply(&mut list, Op::Remove(0)), "a ring keeps at least one tool");
+ while list.len() < MAX_TOOLS {
+ assert!(apply(&mut list, Op::Add));
+ }
+ assert!(!apply(&mut list, Op::Add), "and at most {MAX_TOOLS}");
+ }
+
+ #[test]
+ fn the_catalog_offers_real_tools_once_each() {
+ let catalog = catalog();
+ assert!(catalog.len() > 50);
+ let mut ids: Vec<&str> = catalog.iter().map(|(i, _)| i.as_str()).collect();
+ ids.sort_unstable();
+ let before = ids.len();
+ ids.dedup();
+ assert_eq!(ids.len(), before, "no tool twice");
+ assert!(catalog.iter().all(|(id, label)| label_of(id).as_deref() == Some(label.as_str())));
+ for studio in Studio::ALL {
+ for id in studio.defaults() {
+ assert!(catalog.iter().any(|(i, _)| i == id), "{studio:?}: `{id}` is not offered in the editor");
+ }
+ }
+ }
+
+ // ---- the gesture itself ----
+
+ /// A right-button drag through `show`, one pointer position per frame (the first presses).
+ /// The button stays down unless `release` is set.
+ fn drag(app: &mut SolveApp, path: &[Pos2], release: bool) {
+ let ctx = egui::Context::default();
+ let screen = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0));
+ app.viewport.mouse = path.first().copied();
+ let secondary =
+ |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Secondary, pressed, modifiers: egui::Modifiers::NONE };
+ let frame = |app: &mut SolveApp, k: usize, events: Vec<egui::Event>| {
+ let raw = egui::RawInput { time: Some(k as f64 * 0.02), screen_rect: Some(screen), events, ..Default::default() };
+ let mut output = ctx.run_ui(raw, |ui| show(app, ui.ctx()));
+ output.textures_delta.clear();
+ };
+ for (k, p) in path.iter().enumerate() {
+ let mut events = vec![egui::Event::PointerMoved(*p)];
+ if k == 0 {
+ events.push(secondary(*p, true));
+ }
+ frame(app, k, events);
+ }
+ if release {
+ let last = path.last().copied().unwrap_or(Pos2::ZERO);
+ frame(app, path.len(), vec![secondary(last, false)]);
+ }
+ }
+
+ fn gesture_app() -> SolveApp {
+ let mut app = app();
+ app.preferences.nav = MOUSE_MODE.into();
+ app.preferences.mouse_gestures.enabled = true;
+ app
+ }
+
+ const PRESS: Pos2 = pos2(800.0, 500.0);
+
+ #[test]
+ fn gestures_need_both_the_switch_and_the_solidworks_mouse_mode() {
+ let mut app = app();
+ assert!(!active(&app), "off by default");
+ app.preferences.mouse_gestures.enabled = true;
+ for nav in ["fusion", "inventor", "alias", "blender", "tinkercad", "openscad", "touchpad"] {
+ app.preferences.nav = nav.into();
+ assert!(!active(&app), "{nav}: gestures only work with the SolidWorks mouse mode");
+ }
+ app.preferences.nav = MOUSE_MODE.into();
+ assert!(active(&app));
+ app.preferences.mouse_gestures.enabled = false;
+ assert!(!active(&app));
+ }
+
+ #[test]
+ fn the_ring_opens_after_four_points_with_the_button_held_where_it_went_down() {
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS], false);
+ assert!(!is_open(&app), "a press alone is not a gesture");
+ drag(&mut app, &[PRESS, PRESS + vec2(OPEN_DRAG - 1.0, 0.0)], false);
+ assert!(!is_open(&app), "three points is still a click");
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS, PRESS + vec2(OPEN_DRAG - 1.0, 0.0), PRESS + vec2(OPEN_DRAG, 0.0)], false);
+ assert!(is_open(&app), "four points opens it");
+ assert_eq!(app.gesture.wheel.as_ref().map(|w| w.centre), Some(PRESS), "centred where the button went down");
+ assert!(app.tool.is_none() && app.dialog.is_none(), "nothing is taken inside the hub");
+ }
+
+ #[test]
+ fn a_plain_right_click_leaves_the_menu_to_the_viewport_and_a_gesture_does_not() {
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS], true);
+ assert!(!is_open(&app) && !took_press(&app), "no move: a right-click, the usual menu opens");
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS, PRESS + vec2(10.0, 0.0)], true);
+ assert!(!is_open(&app) && took_press(&app), "a gesture's release is no click, so no menu");
+ // The next press starts afresh.
+ drag(&mut app, &[PRESS], true);
+ assert!(!took_press(&app));
+ }
+
+ #[test]
+ fn touching_a_zone_takes_the_tool_and_puts_the_ring_away() {
+ let mut app = gesture_app();
+ // Past the hub's edge, below: the bottom zone (Create Sketch).
+ drag(&mut app, &[PRESS, PRESS + vec2(0.0, 20.0), PRESS + vec2(0.0, HUB + 3.0)], false);
+ assert!(!is_open(&app));
+ assert!(app.tool.is_some() || app.dialog.is_some(), "Create Sketch started");
+ }
+
+ #[test]
+ fn a_fast_flick_cannot_skip_the_tool_between_frames() {
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS, PRESS + vec2(0.0, 12.0), PRESS + vec2(0.0, 420.0)], false);
+ assert!(!is_open(&app) && (app.tool.is_some() || app.dialog.is_some()));
+ }
+
+ #[test]
+ fn a_tool_that_is_off_is_not_taken_and_the_ring_stays_up() {
+ let mut app = gesture_app();
+ // Repeat, straight up, has nothing to repeat yet.
+ drag(&mut app, &[PRESS, PRESS + vec2(0.0, -20.0), PRESS + vec2(0.0, -300.0)], false);
+ assert!(is_open(&app) && app.tool.is_none() && app.dialog.is_none());
+ }
+
+ #[test]
+ fn letting_go_puts_the_ring_away() {
+ let mut app = gesture_app();
+ drag(&mut app, &[PRESS, PRESS + vec2(0.0, 20.0)], true);
+ assert!(!is_open(&app));
+ assert!(app.tool.is_none() && app.dialog.is_none());
+ }
+
+ #[test]
+ fn a_ring_of_five_takes_the_tool_in_the_direction_of_its_zone() {
+ let mut app = gesture_app();
+ app.preferences
+ .mouse_gestures
+ .set_tools(Studio::Part, ["undo", "delete", "sketch.create", "solid.extrude", "solid.move"].map(String::from).to_vec());
+ assert_eq!(items(&app, Studio::Part).len(), 5);
+ // 72 degrees a zone: the second (Delete) is centred at 72 degrees, to the right and up a
+ // little. Delete needs a selection, so it is off: nothing is taken and the ring stays.
+ let dir = vec2((72.0_f32).to_radians().sin(), -(72.0_f32).to_radians().cos());
+ drag(&mut app, &[PRESS, PRESS + dir * 20.0, PRESS + dir * 200.0], false);
+ assert!(is_open(&app), "the zone's tool is off");
+ // The third (Create Sketch) is centred at 144 degrees: to the right and down.
+ let dir = vec2((144.0_f32).to_radians().sin(), -(144.0_f32).to_radians().cos());
+ let mut app = gesture_app();
+ app.preferences
+ .mouse_gestures
+ .set_tools(Studio::Part, ["undo", "delete", "sketch.create", "solid.extrude", "solid.move"].map(String::from).to_vec());
+ drag(&mut app, &[PRESS, PRESS + dir * 20.0, PRESS + dir * 200.0], false);
+ assert!(!is_open(&app) && (app.tool.is_some() || app.dialog.is_some()), "Create Sketch started");
+ }
+
+ #[test]
+ fn nothing_opens_while_gestures_are_off_or_the_mouse_mode_is_wrong() {
+ let drag_down = [PRESS, PRESS + vec2(0.0, 20.0), PRESS + vec2(0.0, 300.0)];
+ let mut app = gesture_app();
+ app.preferences.mouse_gestures.enabled = false;
+ drag(&mut app, &drag_down, false);
+ assert!(!is_open(&app) && app.tool.is_none() && app.dialog.is_none());
+ let mut app = gesture_app();
+ app.preferences.nav = "fusion".into();
+ drag(&mut app, &drag_down, false);
+ assert!(!is_open(&app) && app.tool.is_none() && app.dialog.is_none());
+ }
+
+ #[test]
+ fn the_ring_opens_even_while_a_tool_is_in_progress() {
+ let mut app = gesture_app();
+ app.start("sketch.create");
+ assert!(app.tool.is_some() || app.dialog.is_some());
+ drag(&mut app, &[PRESS, PRESS + vec2(OPEN_DRAG + 1.0, 0.0)], false);
+ assert!(is_open(&app), "a tool in the pointer doesn't keep the right button while gestures are on");
+ }
+
+ #[test]
+ fn the_radial_menu_is_off_only_while_gestures_are_active() {
+ let held = |app: &mut SolveApp| {
+ let ctx = egui::Context::default();
+ let screen = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0));
+ app.viewport.mouse = Some(PRESS);
+ for k in 0..40 {
+ let events = if k == 0 {
+ vec![
+ egui::Event::PointerMoved(PRESS),
+ egui::Event::PointerButton {
+ pos: PRESS,
+ button: egui::PointerButton::Secondary,
+ pressed: true,
+ modifiers: egui::Modifiers::NONE,
+ },
+ ]
+ } else {
+ vec![egui::Event::PointerMoved(PRESS)]
+ };
+ let raw = egui::RawInput { time: Some(k as f64 * 0.02), screen_rect: Some(screen), events, ..Default::default() };
+ let mut out = ctx.run_ui(raw, |ui| {
+ crate::context_menu::show(app, ui.ctx());
+ show(app, ui.ctx());
+ });
+ out.textures_delta.clear();
+ }
+ };
+ // Held 0.8 s with the radial menu on, the usual way opens its menu...
+ let mut app = app();
+ app.preferences.nav = MOUSE_MODE.into();
+ app.preferences.radial_context_menu = true;
+ held(&mut app);
+ assert!(app.viewport.context_menu.is_some(), "gestures off: the radial menu opens as before");
+ // ...with gestures on, only the ring.
+ let mut app = gesture_app();
+ app.preferences.radial_context_menu = true;
+ held(&mut app);
+ assert!(app.viewport.context_menu.is_none(), "gestures on: no radial menu");
+ assert!(!is_open(&app), "held without moving: no ring either");
+ }
+
+ #[test]
+ fn each_studio_opens_its_own_ring() {
+ let mut app = gesture_app();
+ let ids = |app: &SolveApp| items(app, Studio::of(app)).into_iter().map(|i| i.id).collect::<Vec<_>>();
+ assert!(ids(&app).contains(&"solid.extrude".to_string()));
+ app.ui.tab = "SHEET METAL".into();
+ let sheet = ids(&app);
+ assert!(sheet.contains(&"sheet.flange".to_string()) && !sheet.contains(&"solid.extrude".to_string()));
+ app.ui.tab = "PLASTIC".into();
+ assert!(ids(&app).contains(&"plastic.snap_fit".to_string()));
+ }
+
+ #[test]
+ fn the_right_button_stops_orbiting_only_while_gestures_are_active() {
+ use crate::prefs::{NavButton, nav_mode};
+ let none = egui::Modifiers::NONE;
+ let mut app = app();
+ app.preferences.nav = MOUSE_MODE.into();
+ assert!(nav_mode(&app, NavButton::Right, none).is_some(), "gestures off: the right button orbits as before");
+ app.preferences.mouse_gestures.enabled = true;
+ assert_eq!(nav_mode(&app, NavButton::Right, none), None, "gestures on: it opens the ring");
+ assert_eq!(nav_mode(&app, NavButton::Middle, none), nav_mode(&gesture_app_off(), NavButton::Middle, none), "the other buttons are untouched");
+ app.preferences.nav = "fusion".into();
+ assert_eq!(
+ nav_mode(&app, NavButton::Right, none),
+ crate::prefs::nav_preset("fusion").mode(NavButton::Right, none),
+ "other mouse modes keep theirs"
+ );
+ }
+
+ fn gesture_app_off() -> SolveApp {
+ let mut app = app();
+ app.preferences.nav = MOUSE_MODE.into();
+ app
+ }
+}
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index af70af2166..d56bdf0277 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -268,6 +268,8 @@ pub struct Prefs {
pub navigator_style: NavigatorStyle,
/// Show the radial ring and enable hold/flick gestures for viewport context menus.
pub radial_context_menu: bool,
+ /// Mouse gestures: a ring of tools on the right button (SolidWorks mouse mode only).
+ pub mouse_gestures: crate::mouse_gesture::Config,
/// The wheel zooms out when turned forward.
pub zoom_reverse: bool,
/// What an orbit turns around.
@@ -446,6 +448,7 @@ impl Default for Prefs {
nav: "fusion".into(),
navigator_style: NavigatorStyle::default(),
radial_context_menu: false,
+ mouse_gestures: Default::default(),
zoom_reverse: false,
orbit_around: OrbitAround::default(),
orbit_cursor: false,
@@ -762,6 +765,7 @@ fn defaults(app: &mut SolveApp, page: usize) {
p.nav = d.nav;
p.navigator_style = d.navigator_style;
p.radial_context_menu = d.radial_context_menu;
+ p.mouse_gestures = d.mouse_gestures;
p.zoom_reverse = d.zoom_reverse;
p.zoom_to_cursor = d.zoom_to_cursor;
p.smooth_wheel_zoom = d.smooth_wheel_zoom;
@@ -885,6 +889,10 @@ pub fn set_autosave(app: &mut SolveApp) {
/// Which navigation dragging `button` with `mods` held does under the preset.
pub fn nav_mode(app: &SolveApp, button: NavButton, mods: Modifiers) -> Option<NavMode> {
+ // With mouse gestures on, the right button opens the ring of tools instead of orbiting.
+ if button == NavButton::Right && crate::mouse_gesture::active(app) {
+ return None;
+ }
nav_preset(&app.preferences.nav).mode(button, mods)
}
@@ -1326,6 +1334,7 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
ui.label(crate::i18n::tr_label("Context menu"));
ui.checkbox(&mut app.preferences.radial_context_menu, crate::i18n::tr_label("Radial context menu"));
ui.end_row();
+ crate::mouse_gesture::nav_rows(app, ui, t);
ui.label(crate::i18n::tr_label("View navigator"));
let picker =
egui::ComboBox::from_id_salt("pref_navigator_style").selected_text(crate::i18n::tr_label(app.preferences.navigator_style.label())).show_ui(ui, |ui| {
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index c23cbbb75e..01cbbf47d4 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -2654,7 +2654,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
.collect();
let _ = app.run("select.set", json!({ "items": items, "add": add }));
}
- if resp.secondary_clicked() && delta == egui::Vec2::ZERO {
+ // A right-click, unless the same press opened the mouse gestures' ring.
+ if resp.secondary_clicked() && delta == egui::Vec2::ZERO && !crate::mouse_gesture::took_press(app) {
if app.tool.is_some() {
crate::tools::finish(app);
} else if app.dialog.is_none() {
diff --git a/docs/book/src/guide/ui-tour.md b/docs/book/src/guide/ui-tour.md
index ea8ff9c880..16c5d2808d 100644
--- a/docs/book/src/guide/ui-tour.md
+++ b/docs/book/src/guide/ui-tour.md
@@ -32,6 +32,15 @@
in the default and Inventor presets. In every preset, Ctrl+left drag (Cmd on macOS) that starts
on empty space orbits; a Ctrl+click still adds to the selection. Shift+right-drag snaps to the nearest standard or
diagonal view; Shift does not request snapping when the preset already requires it to orbit.
+ **Mouse gestures** (Preferences › Navigation, off by default) work with the SolidWorks mouse preset
+ only (the wheel orbits, Ctrl + wheel pans) and take over the right button, which then no longer
+ orbits: hold it and move the pointer 4 pt to open a ring of tools (280 pt inside, 350 pt outside), even
+ while a tool is active, and touch a tool's zone to take it. A right-click that does not move still
+ opens the usual context menu. Each studio has its own
+ tools, and **Customize…** sets how many tools a studio's ring holds and in which place. Zones
+ alternate between two tints, three when the number of tools is odd. The optional radial context
+ menu is a separate setting, and gestures take the right button from it while they are on.
+
With **Touchpad** selected in Preferences › Navigation, hold **Shift** and move the pointer to
pan, or hold **Alt** (**Option** on macOS) and move it to orbit—no mouse button is needed.
Vertical two-finger scrolling zooms in this preset, regardless of the saved two-finger pan