VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Stroke Weight: a step from a weight between the presets goes to the next preset
dotCooCooc252d22465b7
diff --git a/crates/ui-egui/src/panels/stroke.rs b/crates/ui-egui/src/panels/stroke.rsindex 911f80e43..cc71778b3 100644--- a/crates/ui-egui/src/panels/stroke.rs+++ b/crates/ui-egui/src/panels/stroke.rs@@ -127,10 +127,11 @@ pub(crate) fn shown_weight(app: &VectorcraftApp, st: Option<&StrokeLayer>, mixed(!mixed.weight).then(|| st.map_or(app.session.paint.stroke_width, |s| s.width))}-/// The weight spinner (Stroke panel, Control bar): Units > Stroke, presets, blank when mixed.+/// The weight spinner (Stroke panel, Control bar, Properties panel): Units > Stroke, presets, blank+/// when mixed. A plain step stops at each preset: 0.52 pt goes down to 0.5 pt, not to 0 pt.pub(crate) fn weight_field(app: &mut VectorcraftApp, ui: &mut Ui, id: &str, weight: Option<f64>, width: f32) {let unit = app.session.stroke_unit();- if let Some(w) = widgets::spin_field_named(ui, id, Some(tl!("Weight:")), weight, unit, width, 1.0, 0.0, &weight_presets(unit)) {+ if let Some(w) = widgets::spin_field_stops_named(ui, id, Some(tl!("Weight:")), weight, unit, width, 1.0, 0.0, &weight_presets(unit)) {set(app, json!({"weight": w}));}}@@ -742,7 +743,8 @@ mod tests {};// The weight and the limit.let stroke = |app: &VectorcraftApp| current_stroke(app).map(|s| [s.width, s.miter_limit]).unwrap();- for (shown, after, which, low) in [("1 pt", "0 pt", 0, 0.0), ("2 x", "1 x", 1, 1.0)] {+ // A weight steps through the presets below 1 pt: one step above 0 pt is 0.25 pt.+ for (shown, after, which, low, back) in [("1 pt", "0 pt", 0, 0.0, "0.25 pt"), ("2 x", "1 x", 1, 1.0, "2 x")] {let texts = frame(&mut app, vec![]);let at = texts.iter().find(|(t, _)| t == shown).map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no {shown:?} in {texts:?}"));let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };@@ -766,7 +768,104 @@ mod tests {let key = |key| Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };frame(&mut app, vec![key(egui::Key::ArrowDown), key(egui::Key::ArrowUp)]);let texts = frame(&mut app, vec![]);- assert!(texts.iter().any(|(t, _)| t == shown), "{after}, down and up → {shown}: {texts:?}");+ assert!(texts.iter().any(|(t, _)| t == back), "{after}, down and up → {back}: {texts:?}");+ }+ }++ /// ↑/↓ in the Weight field go from a weight between the listed weights to the next listed+ /// weight in their direction, typed with a decimal comma too: 0,52 pt went down to 0 pt and the+ /// stroke was removed. From 1 pt and up a step is still a whole point.+ #[test]+ fn the_arrows_step_a_weight_to_the_next_listed_weight() {+ use egui::{Event, Key, Modifiers, PointerButton, Pos2};+ use vectorcraft_engine::Session;+ let mut app = VectorcraftApp::new(Session::new(), Default::default());+ app.run("file.new", json!({"width": 400, "height": 300})).unwrap();+ app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 100, "height": 80})).unwrap();+ app.run("stroke.set", json!({"weight": 1})).unwrap();+ let ctx = egui::Context::default();+ crate::theme::install_fonts(&ctx);+ let mut time = 0.0;+ let mut frame = |app: &mut VectorcraftApp, events: Vec<Event>| {+ time += 0.05;+ let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(300.0, 600.0)));+ let raw = egui::RawInput { events, time: Some(time), screen_rect, focused: true, ..Default::default() };+ let mut out = ctx.run_ui(raw, |ui| show(app, ui));+ out.textures_delta.clear();+ out.shapes+ .into_iter()+ .filter_map(|s| match s.shape {+ egui::Shape::Text(t) => Some((t.galley.text().to_string(), Rect::from_min_size(t.pos, t.galley.size()))),+ _ => None,+ })+ .collect::<Vec<_>>()+ };+ let texts = frame(&mut app, vec![]);+ let at = texts.iter().find(|(t, _)| t == "1 pt").map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no 1 pt in {texts:?}"));+ let key = |key| Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };+ let click = |pos| {+ let button = |pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };+ [vec![Event::PointerMoved(pos), button(true)], vec![button(false)], vec![]]+ };+ let away = Pos2::new(290.0, 590.0);+ // (Units > Stroke, points per unit, typed, arrow, the weight after in that unit). A preset+ // with more places than a step keeps them: 0.0156 in goes down to 0.0078 in.+ for (units, per_unit, typed, arrow, after) in [+ ("points", 1.0, "0,52", Key::ArrowDown, 0.5),+ ("points", 1.0, "0,51", Key::ArrowDown, 0.5),+ ("points", 1.0, "0,4", Key::ArrowDown, 0.25),+ ("points", 1.0, "0,52", Key::ArrowUp, 0.75),+ ("points", 1.0, "0,1", Key::ArrowUp, 0.25),+ ("points", 1.0, "0,75", Key::ArrowDown, 0.5),+ ("points", 1.0, "0,5", Key::ArrowDown, 0.25),+ ("points", 1.0, "1", Key::ArrowDown, 0.75),+ ("points", 1.0, "1", Key::ArrowUp, 2.0),+ ("points", 1.0, "1,5", Key::ArrowDown, 1.0),+ ("points", 1.0, "14", Key::ArrowDown, 13.0),+ ("points", 1.0, "14,5", Key::ArrowUp, 15.0),+ ("inches", 72.0, "0,02", Key::ArrowDown, 0.0156),+ ("inches", 72.0, "0,0156", Key::ArrowDown, 0.0078),+ ("inches", 72.0, "0,016", Key::ArrowDown, 0.0156),+ ] {+ app.session.prefs.units_stroke = units.into();+ for events in click(at) {+ frame(&mut app, events);+ }+ frame(&mut app, vec![Event::Text(typed.into()), key(Key::Enter)]);+ for events in click(away) {+ frame(&mut app, events);+ }+ let typed_weight = typed.replace(',', ".").parse::<f64>().unwrap();+ assert!((current_stroke(&app).unwrap().width - typed_weight * per_unit).abs() < 1e-9, "typed {typed}");+ for events in click(at) {+ frame(&mut app, events);+ }+ frame(&mut app, vec![key(arrow)]);+ frame(&mut app, vec![]);+ let w = current_stroke(&app).unwrap().width / per_unit;+ assert!((w - after).abs() < 1e-9, "{typed} {units} and {arrow:?}: {w}");+ for events in click(away) {+ frame(&mut app, events);+ }+ }+ // In picas the field shows 2 pt as 0.167 p; the next press goes on to 1 pt.+ app.session.prefs.units_stroke = "picas".into();+ for events in click(at) {+ frame(&mut app, events);+ }+ frame(&mut app, vec![Event::Text("0p3".into()), key(Key::Enter)]);+ for events in click(away) {+ frame(&mut app, events);+ }+ assert_eq!(current_stroke(&app).unwrap().width, 3.0, "typed 0p3");+ for events in click(at) {+ frame(&mut app, events);+ }+ for (arrow, after) in [(Key::ArrowDown, 2.0), (Key::ArrowDown, 1.0), (Key::ArrowUp, 2.0), (Key::ArrowUp, 3.0)] {+ frame(&mut app, vec![key(arrow)]);+ frame(&mut app, vec![]);+ let w = current_stroke(&app).unwrap().width;+ assert!((w - after).abs() < 1e-9, "picas, {arrow:?} → {after} pt: {w}");}}}diff --git a/crates/ui-egui/src/panels/tests_strokeux.rs b/crates/ui-egui/src/panels/tests_strokeux.rsindex df836118e..deb01832e 100644--- a/crates/ui-egui/src/panels/tests_strokeux.rs+++ b/crates/ui-egui/src/panels/tests_strokeux.rs@@ -194,3 +194,31 @@ fn stroke_weight_stepper_uses_ten_point_shift_steps() {click_step(&mut app, r.center().y + 5.0, egui::Modifiers::COMMAND);assert!((app.session.shown_stroke().unwrap().width - 12.9).abs() < 1e-6);}++/// The weight spinner in the Stroke panel, the Control bar and the Properties panel steps from a+/// weight between the presets to the next preset: 0.52 pt went down to 0 pt.+#[test]+fn every_weight_spinner_steps_to_the_next_preset() {+ use super::tests_appearance::frame_raw;++ let ctx = egui::Context::default();+ crate::theme::install_fonts(&ctx);+ type Show = fn(&mut VectorcraftApp, &mut Ui);+ let surfaces: [(&str, Show); 3] =+ [("Stroke panel", stroke::show), ("Control bar", crate::chrome::control_bar), ("Properties panel", properties::show)];+ for (surface, show) in surfaces {+ for (up, after) in [(false, 0.5), (true, 0.75)] {+ let mut app = app_with_rect();+ run(&mut app, "stroke.set", json!({"weight": 0.52}));+ let t = texts(&ctx, &mut app, show);+ let r = text_rect(&t, "0.52 pt");+ let pos = egui::pos2(r.left() - 14.0, r.center().y + if up { -5.0 } else { 5.0 });+ let button =+ |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };+ for event in [egui::Event::PointerMoved(pos), button(true), button(false)] {+ frame_raw(&ctx, &mut app, egui::RawInput { events: vec![event], ..Default::default() }, show);+ }+ assert_eq!(app.session.shown_stroke().unwrap().width, after, "{surface}, up: {up}");+ }+ }+}diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rsindex decab86ba..0f8ab9a16 100644--- a/crates/ui-egui/src/widgets.rs+++ b/crates/ui-egui/src/widgets.rs@@ -49,11 +49,11 @@ pub use labels::{dim_label, dim_name, divider, field_label, label_row, link_labepub(crate) use labels::{label_field, take_previous_label};pub use numeric::{SpinPick, mixed_field, mixed_field_named, num_field, num_field_named, opt_field, opt_field_named, range_field, range_field_named,- range_field_stepped, size_field, size_field_named, slider, spin_field, spin_field_auto, spin_field_auto_named, spin_field_named, spin_plain,- spin_plain_named,+ range_field_stepped, size_field, size_field_named, slider, spin_field, spin_field_auto, spin_field_auto_named, spin_field_named,+ spin_field_stops_named, spin_plain, spin_plain_named,};#[cfg(test)]-use numeric::{decimal_point, share_of, spinner_step, step_to_multiple};+use numeric::{decimal_point, share_of, spinner_step, step_through, step_to_multiple, within_a_millionth};pub(crate) use numeric::{round_to, set_bare_numbers_are_points, typed_unit};pub use panel_chrome::{bottom_bar, layout_button, list_box, orientation_button, tab_bar};pub(crate) use text::{dialog_focus_flag, enter_modifiers, focus_field, own_field_shift_enter, set_dialog_open, take_dialog_focus};@@ -278,15 +278,80 @@ mod spinner_modifier_tests {#[test]fn shift_steps_stroke_weight_by_ten_points() {- assert_eq!(spinner_step(14.0, 1.0, 0.0, true, egui::Modifiers::SHIFT), 24.0);- assert_eq!(spinner_step(14.0, 1.0, 0.0, false, egui::Modifiers::SHIFT), 4.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, true, egui::Modifiers::SHIFT, &[]), 24.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, false, egui::Modifiers::SHIFT, &[]), 4.0);}#[test]fn unmodified_and_command_steps_keep_existing_behavior() {- assert_eq!(spinner_step(14.0, 1.0, 0.0, true, egui::Modifiers::NONE), 15.0);- assert_eq!(spinner_step(14.0, 1.0, 0.0, false, egui::Modifiers::COMMAND), 13.9);- assert_eq!(spinner_step(0.0, 1.0, 0.0, false, egui::Modifiers::SHIFT), 0.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, true, egui::Modifiers::NONE, &[]), 15.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, false, egui::Modifiers::COMMAND, &[]), 13.9);+ assert_eq!(spinner_step(0.0, 1.0, 0.0, false, egui::Modifiers::SHIFT, &[]), 0.0);+ }++ /// A plain click on the spinner stops at each stop; Shift and Ctrl/Cmd steps do not.+ #[test]+ fn a_plain_spinner_step_stops_at_the_stops() {+ let stops = [0.25, 0.5, 0.75, 1.0, 2.0, 10.0, 20.0];+ let plain = egui::Modifiers::NONE;+ assert_eq!(spinner_step(0.52, 1.0, 0.0, false, plain, &stops), 0.5);+ assert_eq!(spinner_step(0.52, 1.0, 0.0, true, plain, &stops), 0.75);+ assert_eq!(spinner_step(0.1, 1.0, 0.0, false, plain, &stops), 0.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, true, plain, &stops), 15.0);+ assert_eq!(spinner_step(14.0, 1.0, 0.0, false, egui::Modifiers::SHIFT, &stops), 4.0);+ assert!((spinner_step(0.52, 1.0, 0.0, false, egui::Modifiers::COMMAND, &stops) - 0.42).abs() < 1e-9);+ }+}++#[cfg(test)]+mod step_through_tests {+ use super::*;++ /// Each step goes to the nearer of the next whole step and the next stop in its direction.+ #[test]+ fn a_step_goes_to_the_nearer_of_the_next_multiple_and_the_next_stop() {+ let stops = [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 10.0, 20.0, 100.0];+ for (v, n, want) in [+ (0.52, -1.0, 0.5),+ (0.51, -1.0, 0.5),+ (0.4, -1.0, 0.25),+ (0.52, 1.0, 0.75),+ (0.1, 1.0, 0.25),+ (0.1, -1.0, 0.0),+ (0.25, -1.0, 0.0),+ (0.75, -1.0, 0.5),+ (1.0, -1.0, 0.75),+ (1.0, 1.0, 2.0),+ (1.5, -1.0, 1.0),+ (14.0, 1.0, 15.0),+ (14.0, -1.0, 13.0),+ (14.5, 1.0, 15.0),+ (0.4, -2.0, 0.0),+ (0.4, 3.0, 1.0),+ (100.0, 1.0, 101.0),+ (0.52, 0.0, 0.52),+ ] {+ let got = step_through(v, 1.0, n, &stops, within_a_millionth(1.0));+ assert!((got - want).abs() < 1e-9, "{v} × {n}: {got}");+ }+ }++ /// A value a float error away from a stop moves on to the next one.+ #[test]+ fn a_value_next_to_a_stop_moves_past_it() {+ assert_eq!(step_through(0.5 + 1e-9, 1.0, -1.0, &[0.25, 0.5], within_a_millionth(1.0)), 0.25);+ assert_eq!(step_through(0.5 - 1e-9, 1.0, 1.0, &[0.5, 0.75], within_a_millionth(1.0)), 0.75);+ }++ /// A stop shown with the same text as the value moves on to the next one: 2 pt shows as+ /// `0.167 p`. A stop shown differently is still reached: `0.016 in` goes down to `0.0156 in`.+ #[test]+ fn a_stop_shown_as_the_value_moves_past_it() {+ let shown = |unit: Unit| move |a: f64, b: f64| unit.number(unit.to_pt(a)) == unit.number(unit.to_pt(b));+ let picas = [1.0 / 12.0, 2.0 / 12.0, 3.0 / 12.0];+ assert_eq!(step_through(0.167, 1.0, -1.0, &picas, shown(Unit::Picas)), 1.0 / 12.0);+ assert_eq!(step_through(0.083, 1.0, 1.0, &picas, shown(Unit::Picas)), 2.0 / 12.0);+ assert_eq!(step_through(0.016, 1.0, -1.0, &[0.0078, 0.0156], shown(Unit::Inches)), 0.0156);}}diff --git a/crates/ui-egui/src/widgets/numeric.rs b/crates/ui-egui/src/widgets/numeric.rsindex f2a9cc2ec..3b36d0a99 100644--- a/crates/ui-egui/src/widgets/numeric.rs+++ b/crates/ui-egui/src/widgets/numeric.rs@@ -51,7 +51,7 @@ pub fn num_field(ui: &mut Ui, id: impl std::hash::Hash, value: Option<f64>, unit/// its label painted separately): screen readers name the field `name` (already translated).pub fn num_field_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str>, value: Option<f64>, unit: Unit, width: f32) -> Option<f64> {let label = take_previous_label(ui);- unit_field(ui, id, label, name, value, unit, width, false, ANY)+ unit_field(ui, id, label, name, value, unit, width, false, ANY, &[])}/// Any number: the bounds of a field that has none.@@ -64,7 +64,8 @@ fn within(v: f64, bounds: &RangeInclusive<f64>) -> f64 {/// [`num_field`]; with `share_of_value` a percentage typed alone is that share of `value`/// ([`share_of`]). ↑/↓, the wheel and a scrub stop at `bounds` (points), and the field shows where-/// they stopped.+/// they stopped. A plain ↑/↓ or wheel step also stops at each of `stops` (points; see+/// [`step_through`]).#[allow(clippy::too_many_arguments)]fn unit_field(ui: &mut Ui,@@ -76,6 +77,7 @@ fn unit_field(width: f32,share_of_value: bool,bounds: RangeInclusive<f64>,+ stops: &[f64],) -> Option<f64> {let id = id_with(ui.scope_id(), id);let shown = value.map(|v| unit.format(v)).unwrap_or_default();@@ -86,7 +88,8 @@ fn unit_field(let typed = typed_unit(ui.ctx(), unit);let read = |b: &str| typed.parse(&decimal_point(b));let bounds = unit.from_pt(*bounds.start())..=unit.from_pt(*bounds.end());- let stepped = step_value(ui, &resp, &mut buf, &bounds, (|b: &str| Some(unit.from_pt(read(b)?)), |v| unit.format(unit.to_pt(v))), None);+ let stops: Vec<f64> = stops.iter().map(|&s| unit.from_pt(s)).collect();+ let stepped = step_value(ui, &resp, &mut buf, &bounds, (|b: &str| Some(unit.from_pt(read(b)?)), |v| unit.format(unit.to_pt(v))), None, &stops);let scrubbed = scrub::field(ui, id, rect, &buf, value.map(|v| unit.from_pt(v)), STEP_DECIMALS, &bounds);let commit = commit && buf != shown;ui.data_mut(|d| d.insert_temp(id, buf.clone()));@@ -131,11 +134,34 @@ pub(super) fn step_to_multiple(v: f64, size: f64, n: f64) -> f64 {(from + n) * size}+/// `v` moved `n` steps of `size` (down when negative), where each step goes to the nearer of the+/// next multiple of `size` ([`step_to_multiple`]) and the next of `stops` in its direction. By 1 with+/// stops at 0.25, 0.5 and 0.75, 0.52 goes down to 0.5 and up to 0.75, 1 goes down to 0.75, and 14+/// goes up to 15. A stop that `same` finds equal to the value counts as reached: in a field, a stop+/// shown with the same text as the value (`0.167 p` for 2 pt) moves on to the next.+pub(super) fn step_through(v: f64, size: f64, n: f64, stops: &[f64], same: impl Fn(f64, f64) -> bool) -> f64 {+ let mut v = v;+ // One call takes at most 1,000 steps.+ for _ in 0..n.abs().min(1000.0) as u32 {+ let multiple = step_to_multiple(v, size, n.signum());+ let ahead = |s: f64| (if n > 0.0 { s > v } else { s < v }) && !same(s, v);+ let stop = stops.iter().copied().filter(|&s| ahead(s));+ v = if n > 0.0 { stop.fold(multiple, f64::min) } else { stop.fold(multiple, f64::max) };+ }+ v+}++/// Whether `a` and `b` are within a millionth of `size` of each other.+pub(super) fn within_a_millionth(size: f64) -> impl Fn(f64, f64) -> bool {+ move |a, b| (a - b).abs() <= size.abs() * 1e-6+}+/// ↑/↓ in focused numeric field `resp`, or the mouse wheel turned over it, step the number `buf`/// shows (`read` parses it, `show` formats it) per press or wheel notch ([`STEPS`]): a plain step/// goes to the next whole number in its direction (5.1 up to 6, down to 5), a Ctrl/Cmd step goes to/// the next tenth, and a Shift step adds or takes ten. Steps stop at the field's `bounds` (#3370:-/// a weight stops at 0, a miter limit at 1). The new value is applied at once, as in+/// a weight stops at 0, a miter limit at 1), and a plain step also stops at each of `stops`+/// ([`step_through`]). The new value is applied at once, as in/// Illustrator's panels and dialogs, and the new text replaces `buf`, all selected so typing/// replaces it. Returns the new number when a step was taken. While the pointer is over the focused/// field the wheel is the field's (the panel under it doesn't scroll); an unfocused field leaves the@@ -147,6 +173,7 @@ fn step_value(bounds: &RangeInclusive<f64>,(read, show): (impl Fn(&str) -> Option<f64>, impl Fn(f64) -> String),step: Option<fn(f64, f64) -> f64>,+ stops: &[f64],) -> Option<f64> {// Memory focus, as the field's highlight and its typing use: `Response::has_focus` also needs the// window to report keyboard focus.@@ -204,13 +231,14 @@ fn step_value(// The field's own steps: ten at once with Shift, one with or without Ctrl/Cmd.Some(step) => step(v, if mods == egui::Modifiers::SHIFT { 10.0 * n } else { n }),None if mods == egui::Modifiers::SHIFT => v + size * n,+ None if mods == egui::Modifiers::NONE && !stops.is_empty() => step_through(v, size, n, stops, |a, b| show(a) == show(b)),None => step_to_multiple(v, size, n),};// Each step stops at the bounds, so a step back in the same frame starts from there.v = within(v, bounds);}- // Rounded as fields show it, within the field's bounds.- let v = within(round_to(v, STEP_DECIMALS), bounds);+ // Rounded as fields show it, within the field's bounds; a stop keeps its places (0.0156 in).+ let v = within(if stops.contains(&v) { v } else { round_to(v, STEP_DECIMALS) }, bounds);*buf = show(v);ui.data_mut(|d| d.insert_temp(resp.id, buf.clone()));select_all(ui, resp.id, buf);@@ -240,7 +268,7 @@ pub fn size_field_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str}});}- unit_field(ui, id, label, name, value, unit, width, true, ANY)+ unit_field(ui, id, label, name, value, unit, width, true, ANY, &[])}/// [`plain_field`] for a number kept within `range` (the values of dialogs, preferences and panels@@ -347,7 +375,7 @@ fn bounded_field(// ↑/↓ and the wheel step at the field's precision (a count ignores Ctrl/Cmd's tenth); a drag on// its label scrubs it.let decimals = decimals.min(6) as i32;- let stepped = step_value(ui, &resp, &mut buf, bounds, (read, show), step).map(|v| round_to(v, decimals));+ let stepped = step_value(ui, &resp, &mut buf, bounds, (read, show), step, &[]).map(|v| round_to(v, decimals));let scrubbed = scrub::field(ui, id, rect, &buf, value, decimals, bounds);if commit && buf != shown { read(&buf) } else { stepped.or(scrubbed).filter(|&v| Some(v) != value) }}@@ -411,6 +439,28 @@ pub fn spin_field_named(spin_field_auto_named(ui, id, name, value, None, unit, width, step, min, presets).and_then(SpinPick::value)}+/// [`spin_field_named`] whose plain steps (the spinner, ↑/↓ and the wheel without a modifier) also+/// stop at each of its presets ([`step_through`]), for the Stroke Weight: by 1 pt with presets at+/// 0.25, 0.5 and 0.75 pt, 0.52 pt goes down to 0.5 pt and up to 0.75 pt.+#[allow(clippy::too_many_arguments)]+pub fn spin_field_stops_named(+ ui: &mut Ui,+ id: impl std::hash::Hash + Copy,+ name: Option<&str>,+ value: Option<f64>,+ unit: Unit,+ width: f32,+ step: f64,+ min: f64,+ presets: &[f64],+) -> Option<f64> {+ let label = take_previous_label(ui);+ spin_generic(ui, label, value, None, width, step, min, presets, presets, &|v| unit.format(v), &mut |ui, fw, label| {+ unit_field(ui, id, label, name, value, unit, fw, false, min..=f64::INFINITY, presets)+ })+ .and_then(SpinPick::value)+}+/// What a [`spin_field_auto`] returns: a value (points), or its Auto entry.#[derive(Clone, Copy, Debug, PartialEq)]pub enum SpinPick {@@ -460,8 +510,8 @@ pub fn spin_field_auto_named(presets: &[f64],) -> Option<SpinPick> {let label = take_previous_label(ui);- spin_generic(ui, label, value, auto, width, step, min, presets, &|v| unit.format(v), &mut |ui, fw, label| {- unit_field(ui, id, label, name, value, unit, fw, false, min..=f64::INFINITY)+ spin_generic(ui, label, value, auto, width, step, min, presets, &[], &|v| unit.format(v), &mut |ui, fw, label| {+ unit_field(ui, id, label, name, value, unit, fw, false, min..=f64::INFINITY, &[])})}@@ -499,7 +549,7 @@ pub fn spin_plain_named(let label = take_previous_label(ui);let value = value.into();let fmt = |v: f64| format!("{v}{suffix}");- spin_generic(ui, label, value, None, width, step, min, presets, &fmt, &mut |ui, fw, label| {+ spin_generic(ui, label, value, None, width, step, min, presets, &[], &fmt, &mut |ui, fw, label| {bounded_field(ui, id, label, name, value, suffix, decimals, fw, &(min..=f64::INFINITY), None)}).and_then(SpinPick::value)@@ -517,6 +567,7 @@ fn spin_generic(step: f64,min: f64,presets: &[f64],+ stops: &[f64],fmt: &dyn Fn(f64) -> String,field: &mut SpinField<'_>,) -> Option<SpinPick> {@@ -553,7 +604,7 @@ fn spin_generic(&& let Some(v) = value{let modifiers = ui.input(|i| i.modifiers);- out = Some(SpinPick::Value(spinner_step(v, step, min, up.contains(p), modifiers)));+ out = Some(SpinPick::Value(spinner_step(v, step, min, up.contains(p), modifiers, stops)));}let fw = if presets.is_empty() { width - 15.0 } else { width - 34.0 };if let Some(v) = field(ui, fw, label) {@@ -581,9 +632,13 @@ fn spin_generic(}/// Spinner buttons follow the same modifier sizes as ↑/↓ in a focused number field:-/// Shift ×10, Ctrl/Cmd ÷10, otherwise the caller's normal step.-pub(super) fn spinner_step(value: f64, step: f64, min: f64, up: bool, modifiers: egui::Modifiers) -> f64 {- let multiplier = STEPS.iter().find(|(m, _)| modifiers.matches_logically(*m)).map_or(1.0, |(_, factor)| *factor);+/// Shift ×10, Ctrl/Cmd ÷10, otherwise the caller's normal step, which also stops at each of+/// `stops` ([`step_through`]).+pub(super) fn spinner_step(value: f64, step: f64, min: f64, up: bool, modifiers: egui::Modifiers, stops: &[f64]) -> f64 {+ let (mods, multiplier) = STEPS.iter().find(|(m, _)| modifiers.matches_logically(*m)).map_or((egui::Modifiers::NONE, 1.0), |&(m, f)| (m, f));+ if mods == egui::Modifiers::NONE && !stops.is_empty() {+ return step_through(value, step, if up { 1.0 } else { -1.0 }, stops, within_a_millionth(step)).max(min);+ }let delta = step * multiplier;(value + if up { delta } else { -delta }).max(min)}@@ -645,6 +700,7 @@ pub fn opt_field_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str>&lengths,(|b: &str| Some(unit.from_pt(unit.parse(&decimal_point(b))?)), |v| unit.number(unit.to_pt(v))),None,+ &[],);let scrubbed = scrub::field(ui, id, framed.response.rect, &buf, value.map(|v| unit.from_pt(v)), STEP_DECIMALS, &lengths);let focused = ui.memory(|m| m.has_focus(id));