//! 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 crate::ui_kit::{Container, Surface}; 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_icon(painter, Rect::from_center_size(at, vec2(side, side)), &item.icon, f32::from(ink.a()) / 255.0); } } 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((t.font_title * scale).max(t.font_badge)), t.text, ), None => painter.text( c, Align2::CENTER_CENTER, crate::i18n::tr_label(studio.label()), FontId::proportional((t.font_intro * scale).max(t.font_badge)), 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))); Container::new(ctx, Surface::Canvas).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) { crate::ui_kit::settings_block(ui, crate::i18n::tr_label("Mouse gestures"), t.space_24 * 6.0 + t.space_6, |ui| { ui.horizontal_wrapped(|ui| { crate::ui_kit::checkbox(ui, crate::i18n::tr_label("Ring of tools on the right button"), &mut app.preferences.mouse_gestures.enabled); let customize = crate::ui_kit::button(ui, crate::i18n::tr_label("Customize…"), crate::ui_kit::Button::Normal); crate::scenario::publish_handle("gestures:customize", customize.rect.center()); if customize.clicked() { app.gesture.editor.open = true; app.gesture.editor.studio = Studio::of(app); } }); if app.preferences.nav != MOUSE_MODE { crate::ui_kit::text( ui, crate::i18n::tr_label("Mouse gestures only work with the SolidWorks mouse mode (the wheel orbits, Ctrl + wheel pans)."), crate::ui_kit::Text::Hint("mouse_gesture_mode"), ); if crate::ui_kit::button(ui, crate::i18n::tr_label("Use the SolidWorks mouse mode"), crate::ui_kit::Button::Normal).clicked() { app.preferences.nav = MOUSE_MODE.to_string(); app.preferences.zoom_reverse = crate::prefs::nav_preset(MOUSE_MODE).reverse_zoom; } } else if app.preferences.mouse_gestures.enabled { crate::ui_kit::text( ui, crate::i18n::tr_label( "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.", ), crate::ui_kit::Text::Hint("mouse_gesture_help"), ); } }); } /// 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 studio = app.gesture.editor.studio; let mut config = app.preferences.mouse_gestures.clone(); let closed = crate::ui_kit::Window::new(egui::Id::new("sc_gesture_editor"), "settings", crate::i18n::tr_label("Mouse gestures")) .cards(3.0) .show_body(ctx, |ui| { crate::ui_kit::checkbox(ui, crate::i18n::tr_label("Ring of tools on the right button"), &mut config.enabled); 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")); ui.scope(|ui| { ui.set_max_width(200.0); crate::ui_kit::dropdown_menu(ui, "gesture_studio", crate::i18n::tr_label(studio.label()), |ui| { for s in Studio::ALL { if crate::ui_kit::list_picker(ui, s.label(), crate::i18n::tr_label(s.label()), studio == s).clicked() { studio = s; } } }); }); if crate::ui_kit::button( ui, crate::i18n::tr_label("Restore this studio's tools"), crate::ui_kit::Button::Enabled(config.is_custom(studio)), ) .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(t.font_small) .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(); ui.scope(|ui| { ui.set_max_width(200.0); crate::ui_kit::dropdown_menu(ui, ("gesture_tool", i), &shown, |ui| { let filter_id = ui.id().with("filter"); let mut filter: String = ui.data_mut(|d| d.get_temp(filter_id).unwrap_or_default()); crate::ui_kit::text_field(ui, &mut filter, 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_ui(!taken, |ui| crate::ui_kit::list_picker(ui, id, label, *id == list[i])).inner; if r.clicked() { op = Some(Op::Set(i, id.clone())); ui.close(); } } }); }); }); if crate::ui_kit::button(ui, "↑", crate::ui_kit::Button::Enabled(i > 0)).clicked() { op = Some(Op::Up(i)); } if crate::ui_kit::button(ui, "↓", crate::ui_kit::Button::Enabled(i + 1 < list.len())).clicked() { op = Some(Op::Down(i)); } if crate::ui_kit::button(ui, "×", crate::ui_kit::Button::Enabled(list.len() > 1)).clicked() { op = Some(Op::Remove(i)); } }); } if crate::ui_kit::button(ui, crate::i18n::tr_label("Add a tool"), crate::ui_kit::Button::Enabled(list.len() < MAX_TOOLS)) .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 = !closed; } #[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 customization_uses_the_shared_header_keeps_edits_and_has_no_resize_edges() { use crate::scenario::{Harness, handle_at, rect_of}; use serde_json::json; for dark in [false, true] { let mut h = Harness::new(); h.app.home.open = false; h.call("ui.resize", json!({"width":1400,"height":900})); h.call("ui.set", json!({"dark":dark})); h.app.preferences.mouse_gestures.set_tools(Studio::Part, vec!["undo".into(), "solid.extrude".into()]); h.app.gesture.editor.open = true; h.app.gesture.editor.studio = Studio::Part; h.frames(6); let header = rect_of("dialog:header").unwrap(); assert_eq!(header.height(), Tokens::get().form_header_height); assert_eq!(h.app.preferences.mouse_gestures.tools(Studio::Part).len(), 2); h.step(&json!({"widget":"Add a tool"})).unwrap(); h.frames(4); assert_eq!(h.app.preferences.mouse_gestures.tools(Studio::Part).len(), 3); let window = rect_of("dialog:window").unwrap(); for at in [window.left_center(), window.right_center(), window.right_bottom()] { h.call("ui.move", json!({"x":at.x,"y":at.y})); h.frames(2); assert!(!matches!( h.output.cursor_icon, egui::CursorIcon::ResizeHorizontal | egui::CursorIcon::ResizeVertical | egui::CursorIcon::ResizeNwSe | egui::CursorIcon::ResizeNeSw )); } let close = handle_at("dialog:close").unwrap(); h.call("ui.click", json!({"x":close.x,"y":close.y})); h.frames(2); assert!(!h.app.gesture.editor.open); assert_eq!(h.app.preferences.mouse_gestures.tools(Studio::Part).len(), 3, "closing retains edits"); } } #[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 } }