diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs index 871e4e600..46429a9c5 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 5fbbe848a..1b3b9a446 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 000000000..55c8f9594 --- /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 { + 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 { + 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>, +} + +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 { + let mut out: Vec = 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) { + 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 { + 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 { + 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 { + 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, 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 = 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, + /// Where the right button went down, until the pointer has moved [`OPEN_DRAG`] from it. + press: Option, + /// 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 = 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 { + 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, 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 = 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 = 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 { + 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> = 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::>().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::>(), [0, 1, 0, 1, 2]); + assert_eq!((0..3).map(|k| tint(3, k)).collect::>(), [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::>()); + 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 = (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::>(), "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::(&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::(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 = ["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| { + 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::>(); + 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 af70af216..d56bdf027 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 { + // 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 c23cbbb75..01cbbf47d 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 ea8ff9c88..16c5d2808 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