Skip to content

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.rs
index 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.rs
index 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.rs
index 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_labe
pub(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.rs
index 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));