aleleba/vectorcraft
1
0
Fork 0
mirror of https://github.com/storytold/vectorcraft.git synced 2026-10-27 11:17:01 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
09b3b2500438611de304abc73385f4ecd035cdc2
vectorcraft/crates/ui-egui/src/tests_numfields.rs
T

906 lines
43 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Numeric fields: math typed before the unit suffix, and the whole text (unit included) selected
//! on keyboard focus, a released focus click or double-click so typing replaces it; a drag
//! keeps the pressed character as its selection anchor.
use std::cell::{Cell, RefCell};
use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2};
use vectorcraft_doc::Unit;
use crate::widgets;
/// #1457: a focused field follows its value when that changes from outside (the slider beside
/// it), so the arrow keys step from the value shown and losing focus doesn't put the old one back.
#[test]
fn a_focused_field_follows_a_value_changed_from_outside() {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let mut time = 0.0;
let mut frame = |value: f64, events: Vec<Event>| {
time += 0.05;
let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(400.0, 200.0)));
let mut got = (None, Rect::NOTHING);
let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), screen_rect, focused: true, ..Default::default() }, |ui| {
got.0 = widgets::range_field(ui, "f", value, 0.0..=1000.0, "%", 2, 80.0);
got.1 = ui.min_rect();
});
out.textures_delta.clear();
got
};
let key = |key| Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
// Click into the field showing 100 %.
let at = frame(100.0, vec![]).1.center();
frame(100.0, vec![Event::PointerMoved(at), button(at, true)]);
frame(100.0, vec![button(at, false)]);
assert_eq!(frame(100.0, vec![]).0, None);
// The value changes under the focused field (a slider dragged to 142): ↓ steps from 142, not
// from the 100 the field held when it took the focus.
frame(142.0, vec![]);
assert_eq!(frame(142.0, vec![key(Key::ArrowDown)]).0, Some(141.0));
// And changed again, losing focus leaves the value alone.
frame(50.0, vec![]);
let away = at + vec2(0.0, 150.0);
frame(50.0, vec![Event::PointerMoved(away), button(away, true)]);
assert_eq!(frame(50.0, vec![button(away, false)]).0, None);
}
/// A field with steps of its own (the Pencil's Fidelity, #3328): ↑/↓ take them instead of whole
/// numbers, ten at once with Shift, and Ctrl/Cmd steps as plainly as no modifier does.
#[test]
fn a_stepped_field_takes_its_own_steps() {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let mut time = 0.0;
let mut frame = |value: f64, events: Vec<Event>| {
time += 0.05;
let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(400.0, 200.0)));
let mut got = (None, Rect::NOTHING);
let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), screen_rect, focused: true, ..Default::default() }, |ui| {
got.0 = widgets::range_field_stepped(ui, "f", value, 0.01..=100.0, "pt", 2, 80.0, |v, n| ((v + 0.01 * n) * 100.0).round() / 100.0);
got.1 = ui.min_rect();
});
out.textures_delta.clear();
got
};
let key = |key, modifiers| Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers };
let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
let at = frame(0.02, vec![]).1.center();
frame(0.02, vec![Event::PointerMoved(at), button(at, true)]);
frame(0.02, vec![button(at, false)]);
assert_eq!(frame(0.02, vec![key(Key::ArrowUp, Modifiers::NONE)]).0, Some(0.03), "↑ takes one of its steps, not a whole point");
assert_eq!(frame(0.03, vec![key(Key::ArrowDown, Modifiers::NONE)]).0, Some(0.02));
assert_eq!(frame(0.02, vec![key(Key::ArrowUp, Modifiers::SHIFT)]).0, Some(0.12), "Shift takes ten");
assert_eq!(frame(0.12, vec![key(Key::ArrowUp, Modifiers::COMMAND)]).0, Some(0.13), "Cmd takes one");
// The steps stop at the field's range.
assert_eq!(frame(0.01, vec![key(Key::ArrowDown, Modifiers::NONE)]).0, None, "nothing below 0.01");
}
/// #1692: a hex field that the focus only passes through shows the color as it is now and commits
/// nothing. Tab out of an edited field gives the hex field after it the focus in the frame the edit
/// is committed, and the color changes after the hex field is drawn, as in the Color Picker.
/// Shift+Tab out of the field after it gives it the focus a frame later, in the frame that field
/// commits.
#[test]
fn a_hex_field_passed_through_with_tab_commits_nothing() {
let mut f = Field::new();
// Red and Blue fields on either side of the hex field of the color they make.
let rgb = Cell::new([255.0, 128.0, 0.0]);
let (hex, blue, hex_id) = (Cell::new(None), Cell::new(None), Cell::new(egui::Id::NULL));
let draw = |ui: &mut egui::Ui| {
let [r, g, b] = rgb.get();
let red = widgets::plain_field(ui, "red", r, "", 0, 80.0);
hex_id.set(ui.scope_id().with("hex"));
hex.set(widgets::hex_field(ui, "hex", &format!("{:02X}{:02X}{:02X}", r as u8, g as u8, b as u8)));
blue.set(widgets::plain_field(ui, "blue", b, "", 0, 80.0));
red
};
// One frame, its edits applied after it. → What the hex field committed.
let step = |f: &mut Field, events: Vec<Event>| {
let red = f.frame(events, &draw);
let [r, g, b] = rgb.get();
rgb.set([red.unwrap_or(r), g, blue.take().unwrap_or(b)]);
hex.take()
};
// The text the hex field shows (it keeps it under its id).
let shows = |f: &Field| f.ctx.data(|d| d.get_temp::<String>(hex_id.get()));
let (tab, back) = (key(Key::Tab, Modifiers::NONE), key(Key::Tab, Modifiers::SHIFT));
step(&mut f, vec![]);
// Tab into Red, type 50 over it, and Tab on to the hex field, then on to Blue.
for events in [vec![tab.clone()], vec![Event::Text("50".into())], vec![tab.clone()], vec![]] {
assert_eq!(step(&mut f, events), None);
}
assert_eq!(shows(&f).as_deref(), Some("328000"), "the hex field shows Red's edit");
for events in [vec![tab.clone()], vec![]] {
assert_eq!(step(&mut f, events), None);
}
assert_eq!(rgb.get(), [50.0, 128.0, 0.0], "Red keeps what was typed");
// Type 200 over Blue, Shift+Tab back into the hex field and Tab out of it again.
for events in [vec![Event::Text("200".into())], vec![back], vec![], vec![]] {
assert_eq!(step(&mut f, events), None);
}
assert_eq!(shows(&f).as_deref(), Some("3280C8"), "the hex field shows Blue's edit");
for events in [vec![tab], vec![]] {
assert_eq!(step(&mut f, events), None);
}
assert_eq!(rgb.get(), [50.0, 128.0, 200.0], "Blue keeps what was typed");
}
/// What is typed into a hex field is committed when Tab or Enter ends its focus, and Escape drops
/// it.
#[test]
fn typing_into_a_hex_field_commits_it() {
let mut f = Field::new();
let hex = Cell::new(None);
let draw = |ui: &mut egui::Ui| {
let red = widgets::plain_field(ui, "red", 255.0, "", 0, 80.0);
hex.set(widgets::hex_field(ui, "hex", "FF8000"));
red
};
let step = |f: &mut Field, events: Vec<Event>| {
f.frame(events, &draw);
hex.take()
};
let tab = || key(Key::Tab, Modifiers::NONE);
let escape = || key(Key::Escape, Modifiers::NONE);
step(&mut f, vec![]);
for (end, commits) in [(tab(), true), (enter(), true), (escape(), false)] {
// Tab into Red and on into the hex field, select its text and type over it.
let mut got = vec![];
for events in
[vec![tab()], vec![tab()], vec![], vec![key(Key::A, Modifiers::COMMAND)], vec![Event::Text("00FF00".into())], vec![end.clone()], vec![]]
{
got.extend(step(&mut f, events));
}
let want: Vec<String> = if commits { vec!["00FF00".into()] } else { vec![] };
assert_eq!(got, want, "{end:?}");
// Neither field has the focus for the next round.
step(&mut f, vec![escape()]);
}
}
/// #1692: the Stroke panel's dash and gap fields ([`widgets::opt_field`]) are blank while the
/// selected objects' dashes differ. Tab out of the dash after typing into it gives the gap the
/// focus; the gap then shows the dash's length, which the committed dash repeats as its gap. Tab
/// out of the gap commits nothing, and what is typed into the gap replaces all of that length.
#[test]
fn a_gap_field_passed_through_with_tab_commits_nothing() {
use crate::panels::stroke::{dash_fields, dash_pattern};
let shown = Cell::new([None; 6]);
let (dash, gap) = (Cell::new(None), Cell::new(None));
let draw = |ui: &mut egui::Ui| -> Option<f64> {
let [d, g, ..] = shown.get();
dash.set(widgets::opt_field(ui, "dash", d, Unit::Points, 60.0));
gap.set(widgets::opt_field(ui, "gap", g, Unit::Points, 60.0));
None
};
// One frame, then its commit applied the way the Stroke panel applies it. → What the gap
// committed.
let step = |f: &mut Field, events: Vec<Event>| {
f.frame(events, &draw);
let (d, g) = (dash.take(), gap.take());
if d.is_some() || g.is_some() {
let mut fields = shown.get();
fields[0] = d.unwrap_or(fields[0]);
fields[1] = g.unwrap_or(fields[1]);
shown.set(dash_fields(&dash_pattern(&fields)));
}
g
};
let tab = || key(Key::Tab, Modifiers::NONE);
for (typed, commits, pattern) in [(None, None, [20.0, 20.0]), (Some("5"), Some(Some(5.0)), [20.0, 5.0])] {
let mut f = Field::new();
shown.set([None; 6]);
step(&mut f, vec![]);
// Tab into the dash, type 20 and Tab on into the gap.
for events in [vec![tab()], vec![Event::Text("20".into())], vec![tab()], vec![]] {
assert_eq!(step(&mut f, events), None);
}
if let Some(text) = typed {
assert_eq!(step(&mut f, vec![Event::Text(text.into())]), None);
}
assert_eq!(step(&mut f, vec![tab()]), commits, "{typed:?}");
assert_eq!(step(&mut f, vec![]), None);
assert_eq!(dash_pattern(&shown.get()), pattern, "{typed:?}");
}
}
/// #3497: committing a visible dash field must not replace an extended pattern with six values.
/// Passing through the next field without typing must not commit anything else.
#[test]
fn dash_tab_and_enter_commits_preserve_the_unshown_pattern_tail() {
use crate::panels::stroke::{dash_fields, edited_dash_pattern};
for end in [key(Key::Tab, Modifiers::NONE), enter()] {
let original = vec![12.0, 6.0, 2.0, 3.0, 4.0, 5.0, 20.0, 10.0];
let pattern = RefCell::new(original.clone());
let edits = RefCell::new([None; 6]);
let draw = |ui: &mut egui::Ui| {
let fields = dash_fields(&pattern.borrow());
for (i, value) in fields.iter().enumerate() {
edits.borrow_mut()[i] = widgets::opt_field(ui, ("dash", i), *value, Unit::Points, 40.0);
}
None
};
let step = |f: &mut Field, events: Vec<Event>| {
f.frame(events, &draw);
let mut fields = dash_fields(&pattern.borrow());
let mut changed = false;
for (field, edit) in fields.iter_mut().zip(edits.borrow_mut().iter_mut()) {
if let Some(value) = edit.take() {
*field = value;
changed = true;
}
}
if changed {
let next = edited_dash_pattern(&fields, &pattern.borrow());
*pattern.borrow_mut() = next;
}
changed
};
let mut f = Field::new();
let tab = || key(Key::Tab, Modifiers::NONE);
for events in [vec![], vec![tab()], vec![], vec![tab()], vec![]] {
assert!(!step(&mut f, events));
}
assert_eq!(*pattern.borrow(), original, "tabbing without editing changes nothing");
// Shift+Tab back to the first dash, replace it, then commit with Tab or Enter.
for events in [vec![key(Key::Tab, Modifiers::SHIFT)], vec![], vec![Event::Text("14".into())]] {
assert!(!step(&mut f, events));
}
assert!(step(&mut f, vec![end]));
assert!(!step(&mut f, vec![]));
assert_eq!(*pattern.borrow(), vec![14.0, 6.0, 2.0, 3.0, 4.0, 5.0, 20.0, 10.0]);
assert!(!step(&mut f, vec![tab()]));
assert!(!step(&mut f, vec![]));
}
}
/// Headless frames of one field: its rect and id as last drawn.
struct Field {
ctx: egui::Context,
time: f64,
rect: Cell<Rect>,
id: Cell<egui::Id>,
/// Whether the window reports keyboard focus (the live app's doesn't always).
focused: bool,
}
impl Field {
fn new() -> Self {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
Self { ctx, time: 0.0, rect: Cell::new(Rect::NOTHING), id: Cell::new(egui::Id::NULL), focused: true }
}
fn frame(&mut self, events: Vec<Event>, draw: &dyn Fn(&mut egui::Ui) -> Option<f64>) -> Option<f64> {
self.time += 0.05;
let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(400.0, 200.0)));
let input = egui::RawInput { events, time: Some(self.time), screen_rect, focused: self.focused, ..Default::default() };
let mut got = None;
let mut out = self.ctx.run_ui(input, |ui| {
self.id.set(ui.scope_id().with("f"));
got = draw(ui);
self.rect.set(ui.min_rect());
});
out.textures_delta.clear();
got
}
fn num(&mut self, events: Vec<Event>) -> Option<f64> {
self.frame(events, &|ui| widgets::num_field(ui, "f", Some(100.0), Unit::Pixels, 80.0))
}
fn click(&self, count: usize) -> Vec<Event> {
let at = self.rect.get().center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
std::iter::once(Event::PointerMoved(at)).chain((0..count).flat_map(|_| [button(true), button(false)])).collect()
}
fn text_point(&self, text: &str, index: usize, margin: f32) -> Pos2 {
let galley = self.ctx.fonts_mut(|f| f.layout_no_wrap(text.to_owned(), egui::FontId::proportional(12.5), egui::Color32::BLACK));
let x = galley.pos_from_cursor(egui::text::CCursor::new(index)).left();
Pos2::new(self.rect.get().left() + margin + x + 0.1, self.rect.get().center().y)
}
/// The selected character range of the field's text.
fn selection(&self) -> Option<(usize, usize)> {
let st = egui::TextEdit::load_state(&self.ctx, self.id.get())?;
let r = st.cursor.char_range()?.as_sorted_char_range();
Some((r.start.0, r.end.0))
}
}
fn enter() -> Event {
key(Key::Enter, Modifiers::NONE)
}
fn key(key: Key, modifiers: Modifiers) -> Event {
Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }
}
#[test]
fn math_before_the_unit_suffix_evaluates_in_every_unit() {
assert_eq!(Unit::Pixels.parse("1080/2 px"), Some(540.0));
assert_eq!(Unit::Points.parse("1080/2 px"), Some(540.0));
assert_eq!(Unit::Pixels.parse("100*3 px"), Some(300.0));
for u in Unit::ALL {
let shown = u.format(u.to_pt(12.0));
// "12 mm" with "*2" typed after the number, before the suffix.
let typed = shown.replacen(&u.number(u.to_pt(12.0)), "12*2", 1);
let v = u.parse(&typed).unwrap_or_else(|| panic!("{u:?}: `{typed}`"));
assert!((v - u.to_pt(24.0)).abs() < 1e-9, "{u:?}: `{typed}` → {v}");
let typed = shown.replacen(&u.number(u.to_pt(12.0)), "12/4", 1);
let v = u.parse(&typed).unwrap_or_else(|| panic!("{u:?}: `{typed}`"));
assert!((v - u.to_pt(3.0)).abs() < 1e-9, "{u:?}: `{typed}` → {v}");
}
// The suffix measures the expression; units given in it still win.
assert_eq!(Unit::Points.parse("1in/2 mm"), Some(36.0));
assert_eq!(Unit::Points.parse("10/0 px"), None);
// Unitless fields.
assert_eq!(vectorcraft_doc::parse_number("45*2"), Some(90.0));
assert_eq!(vectorcraft_doc::parse_number(" 100 / 4 "), Some(25.0));
assert_eq!(vectorcraft_doc::parse_number("+5"), Some(5.0));
assert_eq!(vectorcraft_doc::parse_number("-5"), Some(-5.0));
assert_eq!(vectorcraft_doc::parse_number("3 mm"), None);
assert_eq!(vectorcraft_doc::parse_number("inf"), None);
}
#[test]
fn focus_selects_the_whole_field_so_typing_replaces_it() {
let mut f = Field::new();
f.num(vec![]);
f.num(f.click(1));
f.num(vec![]);
assert_eq!(f.selection(), Some((0, "100 px".len())), "the unit is selected too");
f.num(vec![Event::Text("1080/2".into())]);
assert_eq!(f.num(vec![enter()]), Some(540.0));
}
#[test]
fn a_percentage_typed_in_a_field_is_a_share_of_the_value_before_it() {
let mut f = Field::new();
let cm = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(72.0), Unit::Centimeters, 80.0);
f.frame(vec![], &cm);
f.frame(f.click(1), &cm);
f.frame(vec![], &cm);
f.frame(vec![Event::Text("3cm*50%".into())], &cm);
let got = f.frame(vec![enter()], &cm).expect("the field reads `3cm*50%`");
assert!((got - Unit::Centimeters.to_pt(1.5)).abs() < 1e-9, "{got}");
}
#[test]
fn double_click_selects_the_whole_field() {
let mut f = Field::new();
f.num(vec![]);
f.num(f.click(1));
f.num(vec![]);
// A click in the focused field (not part of a double-click) places the caret; a double-click
// takes everything again.
f.time += 1.0;
f.num(f.click(1));
f.num(vec![]);
assert!(f.selection().is_some_and(|(a, b)| a == b), "{:?}", f.selection());
f.num(f.click(2));
f.num(vec![]);
assert_eq!(f.selection(), Some((0, "100 px".len())));
}
#[test]
fn plain_fields_do_math_with_their_suffix() {
let mut f = Field::new();
let draw = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", 10.0, "°", 2, 80.0);
f.frame(vec![], &draw);
f.frame(f.click(1), &draw);
f.frame(vec![], &draw);
assert_eq!(f.selection(), Some((0, "10°".chars().count())));
f.frame(vec![Event::Text("45*2°".into())], &draw);
assert_eq!(f.frame(vec![enter()], &draw), Some(90.0));
}
/// Shift+Enter applies what is typed into a field and keeps the field active, its new value all
/// selected so typing replaces it; Enter then ends its editing. In a dialog, Shift+Enter ends the
/// editing as Enter does.
#[test]
fn shift_enter_applies_the_value_and_keeps_the_field_active() {
let shift_enter = || key(Key::Enter, Modifiers::SHIFT);
let has_focus = |f: &Field| f.ctx.memory(|m| m.has_focus(f.id.get()));
// A unit field, a plain field with a suffix and a field that may be empty, each applying what
// it returns. → (text typed, value applied, text shown afterwards).
let px = Cell::new(100.0);
let num = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(px.get()), Unit::Pixels, 80.0).inspect(|&v| px.set(v));
let deg = Cell::new(10.0);
let plain = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", deg.get(), "°", 2, 80.0).inspect(|&v| deg.set(v));
let dash = Cell::new(Some(20.0));
let opt = |ui: &mut egui::Ui| widgets::opt_field(ui, "f", dash.get(), Unit::Points, 60.0).map(|v| dash.set(v)).and(dash.get());
type Draw<'a> = &'a dyn Fn(&mut egui::Ui) -> Option<f64>;
let fields: [(&str, Draw, &str, f64, &str); 3] =
[("num_field", &num, "150", 150.0, "150 px"), ("plain_field", &plain, "45", 45.0, "45°"), ("opt_field", &opt, "2+3", 5.0, "5")];
for (name, draw, typed, want, shows) in fields {
let mut f = Field::new();
f.frame(vec![], draw);
f.frame(f.click(1), draw);
f.frame(vec![], draw);
f.frame(vec![Event::Text(typed.into())], draw);
assert_eq!(f.frame(vec![shift_enter()], draw), Some(want), "{name}: Shift+Enter applies the value");
assert!(has_focus(&f), "{name}: the field keeps the focus");
assert_eq!(f.frame(vec![], draw), None, "{name}: applied once");
assert_eq!(f.selection(), Some((0, shows.chars().count())), "{name}: the value shown is selected");
assert_eq!(f.ctx.data(|d| d.get_temp::<String>(f.id.get())).as_deref(), Some(shows), "{name}");
// Typing replaces it, and Enter applies that and ends the editing.
f.frame(vec![Event::Text("2".into())], draw);
assert_eq!(f.frame(vec![enter()], draw), Some(2.0), "{name}: Enter after it");
assert!(!has_focus(&f), "{name}: Enter ends the editing");
}
// A text field and a hex field (its color shown in capitals) the same way; a field of several
// lines takes Shift+Enter as a line break.
let (text, hex, hex_id) = (Cell::new(None), Cell::new(None), Cell::new(egui::Id::NULL));
let color = RefCell::new(String::from("FF8000"));
let draw = |ui: &mut egui::Ui| {
text.set(widgets::text_field(ui, "f", Some("Name"), 120.0, 1).or(text.take()));
hex_id.set(ui.scope_id().with("hex"));
let shown = color.borrow().clone();
let applied = widgets::hex_field(ui, "hex", &shown);
if let Some(h) = &applied {
color.replace(h.to_uppercase());
}
hex.set(applied.or(hex.take()));
None
};
let mut f = Field::new();
f.frame(vec![], &draw);
f.frame(vec![key(Key::Tab, Modifiers::NONE)], &draw);
f.frame(vec![key(Key::A, Modifiers::COMMAND)], &draw);
f.frame(vec![Event::Text("Logo".into()), shift_enter()], &draw);
assert_eq!(text.take().as_deref(), Some("Logo"));
assert!(has_focus(&f), "the text field keeps the focus");
f.frame(vec![key(Key::Tab, Modifiers::NONE)], &draw);
f.frame(vec![key(Key::A, Modifiers::COMMAND)], &draw);
f.frame(vec![Event::Text("00ff00".into()), shift_enter()], &draw);
assert_eq!((text.take(), hex.take().as_deref()), (None, Some("00ff00")));
assert!(f.ctx.memory(|m| m.has_focus(hex_id.get())), "the hex field keeps the focus");
f.frame(vec![], &draw);
assert_eq!(f.ctx.data(|d| d.get_temp::<String>(hex_id.get())).as_deref(), Some("00FF00"), "the hex field shows the color applied");
let selected = egui::TextEdit::load_state(&f.ctx, hex_id.get()).and_then(|st| st.cursor.char_range()).map(|r| r.as_sorted_char_range());
assert_eq!(selected.map(|r| (r.start.0, r.end.0)), Some((0, 6)), "the hex field's color is selected");
let lines = Cell::new(None);
let draw = |ui: &mut egui::Ui| {
lines.set(widgets::text_field(ui, "f", Some(""), 120.0, 3).or(lines.take()));
None
};
let mut f = Field::new();
f.frame(vec![], &draw);
f.frame(f.click(1), &draw);
f.frame(vec![Event::Text("a".into()), shift_enter(), Event::Text("b".into())], &draw);
assert!(has_focus(&f) && lines.take().is_none(), "a line break, nothing applied");
f.frame(vec![key(Key::Escape, Modifiers::NONE)], &draw);
// In a dialog, Shift+Enter applies the value and ends the editing.
let mut f = Field::new();
widgets::set_dialog_open(&f.ctx, true);
px.set(100.0);
f.frame(vec![], &num);
f.frame(f.click(1), &num);
f.frame(vec![Event::Text("150".into())], &num);
assert_eq!(f.frame(vec![shift_enter()], &num), Some(150.0));
assert!(!has_focus(&f), "a dialog's field ends its editing");
}
/// Preferences › Units › Numbers Without Units Are Points (#394): on (the default), a number typed
/// with no unit into a field in picas is read in points; a typed unit still wins (`2p6`, `1in`);
/// off, it is in picas. A field in any other unit reads it in its unit either way.
#[test]
fn bare_numbers_in_picas_fields_are_points_when_the_preference_says_so() {
let mut f = Field::new();
let typed = |f: &mut Field, u: Unit, text: &str| {
let pt = Cell::new(u.to_pt(4.0));
let draw = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(pt.get()), u, 80.0).inspect(|&v| pt.set(v));
f.frame(vec![], &draw);
f.frame(f.click(1), &draw);
f.frame(vec![Event::Text(text.into())], &draw);
f.frame(vec![enter()], &draw)
};
let (pc, mm) = (Unit::Picas, Unit::Millimeters);
assert_eq!(typed(&mut f, pc, "12"), Some(12.0), "on by default: points in a picas field");
assert_eq!(typed(&mut f, pc, "2p6"), Some(30.0), "picas and points as typed");
assert_eq!(typed(&mut f, pc, "1in"), Some(72.0), "a typed unit wins");
assert_eq!(typed(&mut f, pc, "10+5"), Some(15.0), "arithmetic in points too");
assert_eq!(typed(&mut f, mm, "12"), Some(mm.to_pt(12.0)), "a millimetre field keeps millimetres");
widgets::set_bare_numbers_are_points(&f.ctx, false);
assert_eq!(typed(&mut f, pc, "12"), Some(pc.to_pt(12.0)), "off: picas");
assert_eq!(typed(&mut f, mm, "12"), Some(mm.to_pt(12.0)));
}
/// ↑/↓ step a focused numeric field by one of its unit (Shift: ten, Ctrl/Cmd: a tenth) and apply it
/// at once, the new value selected so typing replaces it; an unfocused field leaves the arrows to
/// the canvas (nudge).
#[test]
fn arrow_keys_step_a_focused_field() {
let mut f = Field::new();
let u = Unit::Millimeters;
let mm = Cell::new(4.0);
let draw = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(u.to_pt(mm.get())), u, 80.0).inspect(|&v| mm.set(u.from_pt(v)));
f.frame(vec![], &draw);
assert_eq!(f.frame(vec![key(Key::ArrowUp, Modifiers::NONE)], &draw), None, "unfocused");
f.frame(f.click(1), &draw);
f.frame(vec![], &draw);
// The window needn't report keyboard focus: the field has egui's.
f.focused = false;
for (k, mods, want) in [
(Key::ArrowUp, Modifiers::NONE, 5.0),
(Key::ArrowUp, Modifiers::SHIFT, 15.0),
(Key::ArrowDown, Modifiers::COMMAND, 14.9),
(Key::ArrowDown, Modifiers::NONE, 14.0),
] {
assert!(f.frame(vec![key(k, mods)], &draw).is_some(), "{k:?} {mods:?}");
assert!((mm.get() - want).abs() < 1e-6, "{k:?} {mods:?}: {}", mm.get());
}
assert_eq!(f.selection(), Some((0, "14 mm".len())), "the new value is selected");
// Enter after the steps commits nothing more.
assert_eq!(f.frame(vec![enter()], &draw), None);
}
/// #2881, #2793: ↑/↓ and the wheel step a fractional value to the next whole unit in their
/// direction (5.1 mm: up to 6, down to 5), and Ctrl/Cmd steps to the next tenth; Shift adds or takes
/// ten and keeps the fraction. In each field's own unit: millimeters, points, percent, degrees.
#[test]
fn steps_go_to_the_next_whole_unit_or_tenth() {
use egui::MouseWheelUnit::Line;
let u = Unit::Millimeters;
let mm = Cell::new(0.0);
let mm_field = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(u.to_pt(mm.get())), u, 80.0).inspect(|&v| mm.set(u.from_pt(v)));
let mut f = Field::new();
f.frame(vec![], &mm_field);
f.frame(f.click(1), &mm_field);
f.frame(vec![], &mm_field);
let at = f.rect.get().center();
// From `from` (set from outside, which the focused field follows), the value `events` give.
let mut step = |from: f64, events: Vec<Event>| {
mm.set(from);
f.frame(vec![], &mm_field);
assert!(f.frame(events, &mm_field).is_some(), "from {from}");
// The field shows the new value before the next one is set.
f.frame(vec![], &mm_field);
mm.get()
};
let arrow = |k, mods| vec![key(k, mods)];
let turn = |dy, mods| wheel(at, Line, dy, mods);
for (from, events, want) in [
(5.1, arrow(Key::ArrowUp, Modifiers::NONE), 6.0),
(5.1, arrow(Key::ArrowDown, Modifiers::NONE), 5.0),
(5.0, arrow(Key::ArrowUp, Modifiers::NONE), 6.0),
(5.0, arrow(Key::ArrowDown, Modifiers::NONE), 4.0),
(-2.5, arrow(Key::ArrowUp, Modifiers::NONE), -2.0),
(-2.5, arrow(Key::ArrowDown, Modifiers::NONE), -3.0),
(5.13, arrow(Key::ArrowUp, Modifiers::COMMAND), 5.2),
(5.13, arrow(Key::ArrowDown, Modifiers::COMMAND), 5.1),
(5.1, arrow(Key::ArrowUp, Modifiers::SHIFT), 15.1),
(5.1, arrow(Key::ArrowDown, Modifiers::SHIFT), -4.9),
(5.1, vec![key(Key::ArrowUp, Modifiers::NONE), key(Key::ArrowUp, Modifiers::NONE)], 7.0),
// Several presses in one frame step in the order they came.
(5.1, vec![key(Key::ArrowUp, Modifiers::NONE), key(Key::ArrowDown, Modifiers::NONE)], 5.0),
(5.13, vec![key(Key::ArrowUp, Modifiers::NONE), key(Key::ArrowUp, Modifiers::COMMAND)], 6.1),
(24.8, turn(1.0, Modifiers::NONE), 25.0),
(24.8, turn(-1.0, Modifiers::NONE), 24.0),
(24.8, turn(2.0, Modifiers::NONE), 26.0),
(24.8, turn(-2.0, Modifiers::NONE), 23.0),
(24.0, turn(1.0, Modifiers::NONE), 25.0),
(24.83, turn(1.0, Modifiers::COMMAND), 24.9),
(24.8, turn(1.0, Modifiers::SHIFT), 34.8),
] {
let got = step(from, events);
assert!((got - want).abs() < 1e-6, "{from} mm to {got}, not {want}");
}
// A points field steps whole points.
let pt = Cell::new(12.25);
let pt_field = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(pt.get()), Unit::Points, 80.0).inspect(|&v| pt.set(v));
let mut f = Field::new();
f.frame(vec![], &pt_field);
f.frame(f.click(1), &pt_field);
f.frame(vec![], &pt_field);
assert_eq!(f.frame(vec![key(Key::ArrowUp, Modifiers::NONE)], &pt_field), Some(13.0));
// Percent and degree fields step whole percents and degrees.
for suffix in ["%", "°"] {
let mut f = Field::new();
let value = Cell::new(37.5);
let plain = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", value.get(), suffix, 2, 80.0).inspect(|&v| value.set(v));
f.frame(vec![], &plain);
f.frame(f.click(1), &plain);
f.frame(vec![], &plain);
for (k, mods, want) in [
(Key::ArrowDown, Modifiers::NONE, 37.0),
(Key::ArrowUp, Modifiers::NONE, 38.0),
(Key::ArrowUp, Modifiers::COMMAND, 38.1),
(Key::ArrowUp, Modifiers::NONE, 39.0),
] {
assert_eq!(f.frame(vec![key(k, mods)], &plain), Some(want), "{suffix} {k:?} {mods:?}");
f.frame(vec![], &plain);
}
}
}
/// Plain fields (degrees, percent, counts) step too, at their precision.
#[test]
fn arrow_keys_step_plain_fields() {
let mut f = Field::new();
let angle = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", 10.0, "°", 2, 80.0);
f.frame(vec![], &angle);
f.frame(f.click(1), &angle);
f.frame(vec![], &angle);
assert_eq!(f.frame(vec![key(Key::ArrowUp, Modifiers::NONE)], &angle), Some(11.0));
assert_eq!(f.frame(vec![key(Key::ArrowDown, Modifiers::SHIFT)], &angle), Some(1.0));
// A count ignores the tenth.
let mut f = Field::new();
let count = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", 3.0, "", 0, 80.0);
f.frame(vec![], &count);
f.frame(f.click(1), &count);
f.frame(vec![], &count);
assert_eq!(f.frame(vec![key(Key::ArrowUp, Modifiers::COMMAND)], &count), None);
assert_eq!(f.frame(vec![key(Key::ArrowUp, Modifiers::NONE)], &count), Some(4.0));
}
/// A wheel turn of `dy` (`unit`s, up positive) with `modifiers`, the pointer at `at`.
fn wheel(at: Pos2, unit: egui::MouseWheelUnit, dy: f32, modifiers: Modifiers) -> Vec<Event> {
vec![
Event::PointerMoved(at),
Event::MouseWheel { unit, delta: vec2(0.0, dy), phase: egui::TouchPhase::Move, modifiers, source: egui::MouseWheelSource::Unknown },
]
}
/// The mouse wheel over a focused numeric field steps it as ↑/↓ do (#485): a notch a step, Shift
/// ten, Ctrl/Cmd a tenth; a trackpad's points add up to notches. Unfocused, or with the pointer
/// elsewhere, the wheel isn't the field's.
#[test]
fn the_wheel_steps_a_focused_field_under_the_pointer() {
use egui::MouseWheelUnit::{Line, Point};
let mut f = Field::new();
let u = Unit::Millimeters;
let mm = Cell::new(4.0);
let draw = |ui: &mut egui::Ui| widgets::num_field(ui, "f", Some(u.to_pt(mm.get())), u, 80.0).inspect(|&v| mm.set(u.from_pt(v)));
f.frame(vec![], &draw);
let at = f.rect.get().center();
assert_eq!(f.frame(wheel(at, Line, 1.0, Modifiers::NONE), &draw), None, "unfocused");
f.frame(f.click(1), &draw);
f.frame(vec![], &draw);
for (dy, mods, want) in
[(1.0, Modifiers::NONE, 5.0), (2.0, Modifiers::SHIFT, 25.0), (-1.0, Modifiers::COMMAND, 24.9), (-1.0, Modifiers::NONE, 24.0)]
{
assert!(f.frame(wheel(at, Line, dy, mods), &draw).is_some(), "{dy} {mods:?}");
assert!((mm.get() - want).abs() < 1e-6, "{dy} {mods:?}: {}", mm.get());
}
assert_eq!(f.selection(), Some((0, "24 mm".len())), "the new value is selected");
// Points: a step for each line's worth, what is left carried to the next turn.
let line = f.ctx.options(|o| o.input_options.line_scroll_speed);
assert_eq!(f.frame(wheel(at, Point, line * 0.6, Modifiers::NONE), &draw), None);
assert!(f.frame(wheel(at, Point, line * 0.6, Modifiers::NONE), &draw).is_some());
assert!((mm.get() - 25.0).abs() < 1e-6, "{}", mm.get());
assert_eq!(f.frame(wheel(Pos2::new(390.0, 190.0), Line, 1.0, Modifiers::NONE), &draw), None, "the pointer elsewhere");
// Plain fields (degrees, percent, counts) too.
let mut f = Field::new();
let count = |ui: &mut egui::Ui| widgets::plain_field(ui, "f", 3.0, "", 0, 80.0);
f.frame(vec![], &count);
f.frame(f.click(1), &count);
f.frame(vec![], &count);
assert_eq!(f.frame(wheel(f.rect.get().center(), Line, -1.0, Modifiers::NONE), &count), Some(2.0));
}
/// The wheel over a focused field steps it and leaves the panel where it is; over an unfocused one
/// it scrolls the panel as before.
#[test]
fn the_wheel_scrolls_the_panel_unless_over_the_focused_field() {
for focus in [false, true] {
let mut f = Field::new();
let offset = Cell::new(0.0);
let draw = |ui: &mut egui::Ui| {
let out = egui::ScrollArea::vertical().max_height(60.0).show(ui, |ui| {
let v = widgets::plain_field(ui, "f", 10.0, "", 0, 80.0);
ui.add_space(600.0);
v
});
offset.set(out.state.clamped_offset().y);
out.inner
};
f.frame(vec![], &draw);
let at = Pos2::new(20.0, 12.0);
if focus {
f.frame(
f.click(1)
.into_iter()
.map(|e| {
if let Event::PointerButton { button, pressed, modifiers, .. } = e {
Event::PointerButton { pos: at, button, pressed, modifiers }
} else {
Event::PointerMoved(at)
}
})
.collect(),
&draw,
);
}
let stepped = f.frame(wheel(at, egui::MouseWheelUnit::Line, -2.0, Modifiers::NONE), &draw);
for _ in 0..20 {
f.frame(vec![], &draw);
}
if focus {
assert_eq!((stepped, offset.get()), (Some(8.0), 0.0));
} else {
assert!(stepped.is_none() && offset.get() > 0.0, "{stepped:?} {}", offset.get());
}
}
}
fn numeric_fixture(ui: &mut egui::Ui, mode: usize) -> Option<f64> {
match mode {
0 => widgets::num_field(ui, "f", Some(123456.0), Unit::Pixels, 100.0),
1 => widgets::num_field(ui, "f", Some(123456.0), Unit::Points, 100.0),
2 => widgets::plain_field(ui, "f", 123456.0, "°", 0, 100.0),
_ => widgets::opt_field(ui, "f", Some(123456.0), Unit::Pixels, 100.0).flatten(),
}
}
fn field_text(mode: usize) -> &'static str {
["123456 px", "123456 pt", "123456°", "123456"][mode]
}
fn pointer_button(at: Pos2, pressed: bool) -> Event {
Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }
}
#[test]
fn numeric_drag_keeps_its_press_position_with_or_without_prior_focus() {
for mode in 0..4 {
for focused in [false, true] {
for (start, end) in [(1, 4), (4, 1)] {
let mut f = Field::new();
let draw = |ui: &mut egui::Ui| numeric_fixture(ui, mode);
f.frame(vec![], &draw);
if focused {
f.frame(f.click(1), &draw);
f.frame(vec![], &draw);
f.time += 1.0;
}
let margin = if mode == 3 { 5.0 } else { 7.0 };
let at = f.text_point(field_text(mode), start, margin);
let to = f.text_point(field_text(mode), end, margin);
f.frame(vec![Event::PointerMoved(at), pointer_button(at, true)], &draw);
assert_eq!(f.selection(), Some((start, start)), "mode {mode}, prior focus {focused}");
f.frame(vec![], &draw); // Holding still must leave the press position alone.
f.frame(vec![Event::PointerMoved(to)], &draw);
f.frame(vec![pointer_button(to, false)], &draw);
assert_eq!(f.selection(), Some((1, 4)), "mode {mode}, {start}->{end}, prior focus {focused}");
f.frame(vec![Event::Text("7".into())], &draw);
assert_eq!(f.frame(vec![enter()], &draw), Some(1756.0), "replace only the dragged text");
}
}
}
}
#[test]
fn a_new_numeric_click_selects_all_on_release_without_moving_its_press_caret() {
let mut f = Field::new();
f.num(vec![]);
let at = f.rect.get().center();
f.num(vec![Event::PointerMoved(at), pointer_button(at, true)]);
assert!(f.selection().is_some_and(|(a, b)| a == b), "a hold can still start a text drag");
f.num(vec![]);
assert!(f.selection().is_some_and(|(a, b)| a == b));
f.num(vec![pointer_button(at, false)]);
assert_eq!(f.selection(), Some((0, "100 px".len())));
f.num(vec![Event::Text("7".into())]);
assert_eq!(f.num(vec![enter()]), Some(7.0));
}
/// #1326: a short drag that the toolkit still counts as a click must keep its caret on
/// release instead of selecting the whole value.
#[test]
fn a_short_drag_released_as_a_click_keeps_its_caret() {
let mut f = Field::new();
let draw = |ui: &mut egui::Ui| numeric_fixture(ui, 0);
f.frame(vec![], &draw);
let at = f.text_point(field_text(0), 2, 7.0);
f.frame(vec![Event::PointerMoved(at), pointer_button(at, true)], &draw);
let pressed = f.selection();
assert!(pressed.is_some_and(|(a, b)| a == b), "the press places a caret");
// Moved a few points: inside one character, so egui reports a click, not a text selection.
let nudge = egui::vec2(3.4, 0.0);
f.frame(vec![Event::PointerMoved(at + nudge)], &draw);
f.frame(vec![pointer_button(at + nudge, false)], &draw);
assert_eq!(f.selection(), pressed, "the short drag keeps its caret instead of selecting all");
assert_ne!(f.selection(), Some((0, field_text(0).chars().count())), "a clicked short drag must not select all (#1326)");
f.frame(vec![Event::Text("7".into())], &draw);
assert_eq!(f.frame(vec![enter()], &draw), Some(1273456.0), "typing lands where the drag left the caret");
}
/// A tap (no movement) on a fresh numeric field still selects all on release.
#[test]
fn a_tap_without_movement_still_selects_all_on_release() {
let mut f = Field::new();
let draw = |ui: &mut egui::Ui| numeric_fixture(ui, 0);
f.frame(vec![], &draw);
let at = f.text_point(field_text(0), 2, 7.0);
f.frame(vec![Event::PointerMoved(at), pointer_button(at, true)], &draw);
f.frame(vec![], &draw);
f.frame(vec![pointer_button(at, false)], &draw);
assert_eq!(f.selection(), Some((0, field_text(0).chars().count())), "a plain tap selects all");
}
#[test]
fn keyboard_focus_keeps_selecting_the_entire_numeric_field() {
for mode in 0..4 {
let mut f = Field::new();
let draw = |ui: &mut egui::Ui| numeric_fixture(ui, mode);
f.frame(vec![], &draw);
f.frame(vec![key(Key::Tab, Modifiers::NONE)], &draw);
f.frame(vec![], &draw);
assert_eq!(f.selection(), Some((0, field_text(mode).chars().count())), "mode {mode}");
}
}
/// #1637: text typed into a field is committed when the focus leaves it by a click on empty space
/// or by a press on a field drawn before it (another channel of the Color panel), whether the
/// window reports keyboard focus or not, as Enter commits it. Escape still drops it.
#[test]
fn typed_text_is_committed_when_the_focus_moves_away() {
for focused in [true, false] {
for onto_field_above in [false, true] {
let mut f = Field::new();
f.focused = focused;
let above = Cell::new(Rect::NOTHING);
let draw = |ui: &mut egui::Ui| {
widgets::range_field(ui, "above", 50.0, 0.0..=1000.0, "%", 0, 80.0);
above.set(ui.min_rect());
widgets::range_field(ui, "f", 100.0, 0.0..=1000.0, "%", 0, 80.0)
};
f.frame(vec![], &draw);
let field = Pos2::new(above.get().center().x, (above.get().bottom() + f.rect.get().bottom()) / 2.0);
let away = if onto_field_above { above.get().center() } else { Pos2::new(field.x, 180.0) };
let case = format!("window focus {focused}, onto the field above {onto_field_above}");
f.frame(vec![Event::PointerMoved(field), pointer_button(field, true)], &draw);
f.frame(vec![pointer_button(field, false)], &draw);
f.frame(vec![Event::Text("42".into())], &draw);
let committed = [
f.frame(vec![Event::PointerMoved(away), pointer_button(away, true)], &draw),
f.frame(vec![pointer_button(away, false)], &draw),
f.frame(vec![], &draw),
];
assert_eq!(committed.iter().flatten().copied().collect::<Vec<_>>(), [42.0], "{case}");
f.frame(vec![Event::PointerMoved(field), pointer_button(field, true)], &draw);
f.frame(vec![pointer_button(field, false)], &draw);
f.frame(vec![Event::Text("7".into())], &draw);
let escaped = [f.frame(vec![key(Key::Escape, Modifiers::NONE)], &draw), f.frame(vec![], &draw)];
assert_eq!(escaped, [None, None], "{case}");
}
}
}
/// Text typed into a field is committed in the frame of a press elsewhere, before what is drawn
/// after the field (the canvas) acts on the press: a click that selects another object must not
/// get the typed value, even when both objects show the same one.
#[test]
fn a_press_on_the_canvas_commits_to_the_object_being_edited() {
let mut f = Field::new();
// The object the panel shows; both have the value 100.
let selected = Cell::new(1);
let committed = Cell::new(None);
let draw = |ui: &mut egui::Ui| {
let got = widgets::range_field(ui, "f", 100.0, 0.0..=1000.0, "%", 0, 80.0);
if let Some(v) = got {
committed.set(Some((selected.get(), v)));
}
// The canvas: a press ends text input and selects the other object.
if ui.input(|i| i.pointer.primary_pressed() && i.pointer.interact_pos().is_some_and(|p| p.y > 100.0)) {
ui.memory_mut(|m| m.stop_text_input());
selected.set(2);
}
got
};
f.frame(vec![], &draw);
let (field, canvas) = (f.rect.get().center(), Pos2::new(200.0, 180.0));
f.frame(vec![Event::PointerMoved(field), pointer_button(field, true)], &draw);
f.frame(vec![pointer_button(field, false)], &draw);
f.frame(vec![Event::Text("42".into())], &draw);
f.frame(vec![Event::PointerMoved(canvas), pointer_button(canvas, true)], &draw);
f.frame(vec![pointer_button(canvas, false)], &draw);
f.frame(vec![], &draw);
assert_eq!((committed.get(), selected.get()), (Some((1, 42.0)), 2));
}
Reference in New Issue View Git Blame Copy Permalink