mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-11 02:19:56 -06:00
dotCooCoo
a71a6ca53d
A numeric field's up/down spinner and the chevron that opens its presets were Tab stops, so Tab took three presses to get from one field to the next in the Stroke, Character and Transform panels and two in a text field with presets (Export for Screens' scale). The Transparency row's opacity slider chevron was a Tab stop after the Opacity field too. All three now sense clicks without taking the keyboard focus; clicking them works as before, and Up/Down in the field still step it. Without the chevron in the Tab order, Alt+Down (with no other modifier) in a field with presets opens its preset list with the keyboard focus on the chosen preset, or on the first one. Before, Alt+Down stepped such a field down by one; Shift+Alt+Down still steps it by ten, and fields without presets still step on Alt+Down. Enter on the focused preset picks it and closes the list without also pressing a dialog's OK, as the combo boxes do, and after a pick or Escape the field has the keyboard focus again.
1181 lines
58 KiB
Rust
1181 lines
58 KiB
Rust
//! 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()]);
|
||
}
|
||
}
|
||
|
||
/// Keyboard focus selects a hex field's digits. A pasted code replaces them wherever the caret is,
|
||
/// hex digits that fit edit them in place, and a paste that is not a color leaves them as they were.
|
||
/// Typing digit by digit is not affected.
|
||
#[test]
|
||
fn a_paste_into_a_hex_field_replaces_or_edits_its_digits() {
|
||
let hex = Cell::new(None);
|
||
let hex_id = Cell::new(egui::Id::NULL);
|
||
let draw = |ui: &mut egui::Ui| {
|
||
let red = widgets::plain_field(ui, "red", 255.0, "", 0, 80.0);
|
||
hex_id.set(ui.scope_id().with("hex"));
|
||
hex.set(widgets::hex_field(ui, "hex", "FF8000"));
|
||
red
|
||
};
|
||
let (tab, end) = (|| key(Key::Tab, Modifiers::NONE), || key(Key::End, Modifiers::NONE));
|
||
let paste = |text: &str| vec![Event::Paste(text.into())];
|
||
let digit = |text: &str| vec![Event::Text(text.into())];
|
||
// Its name, the events after the field has the focus, the text they leave and what Tab commits.
|
||
type Case<'a> = (&'a str, Vec<Vec<Event>>, &'a str, Option<&'a str>);
|
||
let select_left = |n: usize| std::iter::once(end()).chain(std::iter::repeat_n(key(Key::ArrowLeft, Modifiers::SHIFT), n)).collect::<Vec<_>>();
|
||
let cases: [Case; 25] = [
|
||
("three selected, three digits", vec![select_left(3), paste("ABC")], "FF8ABC", Some("FF8ABC")),
|
||
("three characters, caret, three digits", vec![digit("FF8"), paste("ABC")], "FF8ABC", Some("FF8ABC")),
|
||
("five characters, two selected, three digits", vec![digit("12345"), select_left(2), paste("ABC")], "123ABC", Some("123ABC")),
|
||
("two characters, caret, three digits", vec![digit("12"), paste("ABC")], "ABC", Some("AABBCC")),
|
||
("four selected, three digits", vec![select_left(4), paste("0f0")], "0f0", Some("00ff00")),
|
||
("selected digits", vec![paste("00FF00")], "00FF00", Some("00FF00")),
|
||
("caret, a code", vec![vec![end()], paste("00FF00")], "00FF00", Some("00FF00")),
|
||
("caret, a code with #", vec![vec![end()], paste("#00ff00")], "00ff00", Some("00ff00")),
|
||
("caret, three digits", vec![vec![end()], paste("0f0")], "0f0", Some("00ff00")),
|
||
("caret, a line break after the code", vec![vec![end()], paste("#00FF00\n")], "00FF00", Some("00FF00")),
|
||
("caret, a word", vec![vec![end()], paste("hello")], "FF8000", None),
|
||
("caret, too few digits", vec![vec![end()], paste("12")], "FF8000", None),
|
||
("selected digits, too many digits", vec![paste("12345678")], "FF8000", None),
|
||
("part selected, digits that fit", vec![select_left(2), paste("AB")], "FF80AB", Some("FF80AB")),
|
||
("typed # and two digits, four digits", vec![digit("#12"), paste("3456")], "#123456", Some("123456")),
|
||
("typed # and three digits, three digits", vec![digit("#FFF"), paste("ABC")], "#FFFABC", Some("FFFABC")),
|
||
("typed # and two digits, three digits", vec![digit("#12"), paste("ABC")], "ABC", Some("AABBCC")),
|
||
("typed #, two digits", vec![digit("#"), paste("12")], "#12", Some("12")),
|
||
("empty field, two digits", vec![vec![key(Key::Backspace, Modifiers::NONE)], paste("12")], "12", Some("12")),
|
||
("the same color in other letters", vec![paste("ff8000")], "ff8000", None),
|
||
("typed digit by digit", ["0", "0", "F", "F", "0", "0"].map(digit).to_vec(), "00FF00", Some("00FF00")),
|
||
("typed with #", vec![digit("#00FF00")], "#00FF00", Some("00FF00")),
|
||
("typed in part", vec![digit("00")], "00", Some("00")),
|
||
("typed three digits with #", vec![digit("#0f0")], "#0f0", Some("00ff00")),
|
||
("typed three letters that are not digits", vec![digit("xyz")], "xyz", Some("xyz")),
|
||
];
|
||
for (name, events, shows, commits) in cases {
|
||
let mut f = Field::new();
|
||
f.frame(vec![], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(vec![], &draw);
|
||
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)), "{name}: keyboard focus selects the digits");
|
||
for events in events {
|
||
f.frame(events, &draw);
|
||
assert_eq!(hex.take(), None, "{name}: nothing is committed before Tab");
|
||
}
|
||
assert_eq!(f.ctx.data(|d| d.get_temp::<String>(hex_id.get())).as_deref(), Some(shows), "{name}: the text");
|
||
f.frame(vec![tab()], &draw);
|
||
assert_eq!(hex.take().as_deref(), commits, "{name}: what Tab commits");
|
||
}
|
||
// Escape drops a pasted code.
|
||
let mut f = Field::new();
|
||
f.frame(vec![], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(paste("00FF00"), &draw);
|
||
assert_eq!(hex.take(), None);
|
||
f.frame(vec![key(Key::Escape, Modifiers::NONE)], &draw);
|
||
assert_eq!(hex.take(), None, "Escape commits nothing");
|
||
f.frame(vec![], &draw);
|
||
assert_eq!(f.ctx.data(|d| d.get_temp::<String>(hex_id.get())).as_deref(), Some("FF8000"), "the field shows its color again");
|
||
// A press outside the field commits in the frame of the press, before the press acts.
|
||
let mut f = Field::new();
|
||
f.frame(vec![], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(vec![tab()], &draw);
|
||
f.frame(paste("00FF00"), &draw);
|
||
let away = Pos2::new(390.0, 190.0);
|
||
f.frame(vec![Event::PointerMoved(away)], &draw);
|
||
assert_eq!(hex.take(), None);
|
||
f.frame(vec![Event::PointerButton { pos: away, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }], &draw);
|
||
assert_eq!(hex.take().as_deref(), Some("00FF00"), "the press commits");
|
||
// Three digits that spell the color the field holds commit nothing.
|
||
let same = |ui: &mut egui::Ui| {
|
||
let red = widgets::plain_field(ui, "red", 255.0, "", 0, 80.0);
|
||
hex.set(widgets::hex_field(ui, "hex", "AABBCC"));
|
||
red
|
||
};
|
||
let mut f = Field::new();
|
||
f.frame(vec![], &same);
|
||
f.frame(vec![tab()], &same);
|
||
f.frame(vec![tab()], &same);
|
||
f.frame(paste("abc"), &same);
|
||
assert_eq!(hex.take(), None);
|
||
f.frame(vec![tab()], &same);
|
||
assert_eq!(hex.take(), None, "abc over AABBCC commits nothing");
|
||
}
|
||
|
||
/// #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 }
|
||
}
|
||
|
||
/// What [`preset_row`]'s fields committed or picked in a frame: the two numbers, the text and the
|
||
/// pick of the field with an Auto entry.
|
||
type PresetPicks = (Option<f64>, Option<f64>, Option<String>, Option<widgets::SpinPick>);
|
||
|
||
const NO_PICK: PresetPicks = (None, None, None, None);
|
||
|
||
thread_local! {
|
||
/// Whether the last [`preset_row`] frame left an Enter press for a dialog drawn after it.
|
||
static ENTER_LEFT: Cell<bool> = const { Cell::new(false) };
|
||
}
|
||
|
||
/// One frame in `ctx` with `events` of a row of two numeric fields with a spinner and presets
|
||
/// (Stroke Weight, and a font size that is none of its presets), a text field with presets (Export
|
||
/// for Screens' scale) and a numeric field whose list starts with Auto, which is on (Leading).
|
||
fn preset_row(ctx: &egui::Context, time: &Cell<f64>, events: Vec<Event>) -> PresetPicks {
|
||
time.set(time.get() + 0.05);
|
||
let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(600.0, 300.0)));
|
||
let mut got = NO_PICK;
|
||
let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time.get()), screen_rect, focused: true, ..Default::default() }, |ui| {
|
||
ui.horizontal(|ui| {
|
||
got.0 = widgets::spin_field(ui, "weight", Some(2.0), Unit::Points, 100.0, 1.0, 0.0, &[1.0, 2.0, 4.0]);
|
||
got.1 = widgets::spin_field(ui, "size", Some(13.0), Unit::Points, 100.0, 1.0, 0.0, &[9.0, 12.0]);
|
||
got.2 = widgets::text_presets(ui, "scale", "1x", &["1x", "2x"], 100.0);
|
||
got.3 = widgets::spin_field_auto(ui, "leading", Some(14.0), Some(true), Unit::Points, 100.0, 1.0, 0.0, &[12.0, 14.0]);
|
||
});
|
||
ENTER_LEFT.set(crate::shortcuts::pressed_anew(ui.ctx(), Key::Enter));
|
||
});
|
||
out.textures_delta.clear();
|
||
got
|
||
}
|
||
|
||
/// Tab goes from one field to the next in one press: it does not stop on a field's spinner or on
|
||
/// the chevron that opens its presets, and Shift+Tab goes back the same way.
|
||
#[test]
|
||
fn tab_goes_from_field_to_field_past_the_spinner_and_the_preset_chevron() {
|
||
let ctx = egui::Context::default();
|
||
crate::theme::install_fonts(&ctx);
|
||
let time = Cell::new(0.0);
|
||
preset_row(&ctx, &time, vec![]);
|
||
preset_row(&ctx, &time, vec![]);
|
||
let stops = crate::widgets::accessibility_tests::tab_stops(&ctx, 8, |events| {
|
||
preset_row(&ctx, &time, events);
|
||
});
|
||
let widths: Vec<f32> = stops.iter().filter_map(|id| ctx.read_response(*id)).map(|r| r.rect.width()).collect();
|
||
assert_eq!(widths.len(), 8, "{stops:?}");
|
||
assert!(widths.iter().all(|w| *w > 40.0), "only the fields are Tab stops, not the spinners or chevrons: {widths:?}");
|
||
assert_eq!(stops[..4], stops[4..], "four fields, then back to the first: {widths:?}");
|
||
let mut back = vec![];
|
||
for _ in 0..2 {
|
||
preset_row(&ctx, &time, vec![key(Key::Tab, Modifiers::SHIFT)]);
|
||
preset_row(&ctx, &time, vec![]);
|
||
back.extend(ctx.memory(|m| m.focused()));
|
||
}
|
||
assert_eq!(back, [stops[2], stops[1]], "Shift+Tab goes back field by field");
|
||
}
|
||
|
||
/// The Transparency row's opacity slider chevron is not a Tab stop either: Tab goes from the
|
||
/// Opacity field straight to the next field.
|
||
#[test]
|
||
fn tab_goes_from_the_opacity_field_past_its_slider_chevron() {
|
||
let ctx = egui::Context::default();
|
||
crate::theme::install_fonts(&ctx);
|
||
let time = Cell::new(0.0);
|
||
let frame = |events: Vec<Event>| {
|
||
time.set(time.get() + 0.05);
|
||
let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(600.0, 300.0)));
|
||
let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time.get()), screen_rect, focused: true, ..Default::default() }, |ui| {
|
||
ui.horizontal(|ui| {
|
||
widgets::opacity_blend(ui, "transparency", Some(0.5), None, true);
|
||
widgets::spin_field(ui, "weight", Some(2.0), Unit::Points, 100.0, 1.0, 0.0, &[]);
|
||
});
|
||
});
|
||
out.textures_delta.clear();
|
||
};
|
||
frame(vec![]);
|
||
frame(vec![]);
|
||
let stops = crate::widgets::accessibility_tests::tab_stops(&ctx, 6, frame);
|
||
let widths: Vec<f32> = stops.iter().filter_map(|id| ctx.read_response(*id)).map(|r| r.rect.width()).collect();
|
||
assert_eq!(widths.len(), 6, "{stops:?}");
|
||
assert!(widths.iter().all(|w| *w > 20.0), "the 18 pt slider chevron is not a Tab stop: {widths:?}");
|
||
assert_eq!(stops[..3], stops[3..], "blend mode, Opacity and the next field, then back: {widths:?}");
|
||
}
|
||
|
||
/// Gives the keyboard focus to the field that `tabs` presses of Tab reach in [`preset_row`], with
|
||
/// every list closed, and returns that field.
|
||
fn focus_preset_field(ctx: &egui::Context, time: &Cell<f64>, tabs: usize) -> Option<egui::Id> {
|
||
egui::Popup::close_all(ctx);
|
||
ctx.memory_mut(|m| m.surrender_focus(m.focused().unwrap_or(egui::Id::NULL)));
|
||
preset_row(ctx, time, vec![]);
|
||
for _ in 0..tabs {
|
||
preset_row(ctx, time, vec![key(Key::Tab, Modifiers::NONE)]);
|
||
}
|
||
preset_row(ctx, time, vec![]);
|
||
ctx.memory(|m| m.focused())
|
||
}
|
||
|
||
/// The presets stay in reach of the keyboard: Alt+↓ in a field opens its preset list with the
|
||
/// keyboard focus on the chosen preset (the first entry when none is chosen, Auto when it is on),
|
||
/// Tab goes on to the next one and Enter picks it, without reaching a dialog's OK. The field then
|
||
/// has the keyboard focus again.
|
||
#[test]
|
||
fn alt_down_opens_a_fields_presets_for_the_keyboard() {
|
||
let ctx = egui::Context::default();
|
||
crate::theme::install_fonts(&ctx);
|
||
let time = Cell::new(0.0);
|
||
let alt_down = || key(Key::ArrowDown, Modifiers::ALT);
|
||
// (Tabs to the field, the pick after Tab and Enter in its list.)
|
||
let cases = [
|
||
(1, (Some(4.0), None, None, None)),
|
||
(2, (None, Some(12.0), None, None)),
|
||
(3, (None, None, Some("2x".to_string()), None)),
|
||
(4, (None, None, None, Some(widgets::SpinPick::Value(12.0)))),
|
||
];
|
||
for (tabs, picked) in cases {
|
||
let field = focus_preset_field(&ctx, &time, tabs);
|
||
assert!(field.is_some(), "{tabs}");
|
||
assert_eq!(preset_row(&ctx, &time, vec![alt_down()]), NO_PICK, "{tabs}");
|
||
preset_row(&ctx, &time, vec![]);
|
||
let entry = ctx.memory(|m| m.focused());
|
||
assert!(entry.is_some() && entry != field, "{tabs}: the list takes the focus");
|
||
let layer = ctx.read_response(entry.unwrap_or(egui::Id::NULL)).map(|r| r.layer_id.order);
|
||
assert_eq!(layer, Some(egui::Order::Foreground), "{tabs}: on an entry of the list");
|
||
preset_row(&ctx, &time, vec![key(Key::Tab, Modifiers::NONE)]);
|
||
preset_row(&ctx, &time, vec![]);
|
||
let mut got = preset_row(&ctx, &time, vec![enter()]);
|
||
assert!(!ENTER_LEFT.get(), "{tabs}: the list takes the Enter, so a dialog's OK does not");
|
||
if got == NO_PICK {
|
||
got = preset_row(&ctx, &time, vec![]);
|
||
}
|
||
assert_eq!(got, picked, "{tabs}: Enter picks the next preset");
|
||
preset_row(&ctx, &time, vec![]);
|
||
preset_row(&ctx, &time, vec![]);
|
||
assert!(!egui::Popup::is_any_open(&ctx), "{tabs}: the list closed");
|
||
assert_eq!(ctx.memory(|m| m.focused()), field, "{tabs}: the field has the keyboard focus again");
|
||
}
|
||
}
|
||
|
||
/// Escape closes a preset list that Alt+↓ opened without picking anything, and the field has the
|
||
/// keyboard focus again.
|
||
#[test]
|
||
fn escape_closes_a_fields_presets_and_returns_to_the_field() {
|
||
let ctx = egui::Context::default();
|
||
crate::theme::install_fonts(&ctx);
|
||
let time = Cell::new(0.0);
|
||
for tabs in [1, 3] {
|
||
let field = focus_preset_field(&ctx, &time, tabs);
|
||
preset_row(&ctx, &time, vec![key(Key::ArrowDown, Modifiers::ALT)]);
|
||
preset_row(&ctx, &time, vec![]);
|
||
assert!(egui::Popup::is_any_open(&ctx), "{tabs}: Alt+↓ opened the list");
|
||
let mut picks = vec![preset_row(&ctx, &time, vec![key(Key::Escape, Modifiers::NONE)])];
|
||
picks.push(preset_row(&ctx, &time, vec![]));
|
||
picks.push(preset_row(&ctx, &time, vec![]));
|
||
assert!(picks.iter().all(|p| *p == NO_PICK), "{tabs}: nothing picked: {picks:?}");
|
||
assert!(!egui::Popup::is_any_open(&ctx), "{tabs}: the list closed");
|
||
assert_eq!(ctx.memory(|m| m.focused()), field, "{tabs}: the field has the keyboard focus again");
|
||
}
|
||
}
|
||
|
||
/// Only Alt+↓ with no other modifier opens the presets: Shift+Alt+↓ in a field with presets
|
||
/// steps it down by ten, as before, and leaves the list closed.
|
||
#[test]
|
||
fn shift_alt_down_still_steps_a_field_with_presets() {
|
||
let ctx = egui::Context::default();
|
||
crate::theme::install_fonts(&ctx);
|
||
let time = Cell::new(0.0);
|
||
let field = focus_preset_field(&ctx, &time, 2);
|
||
let mut got = preset_row(&ctx, &time, vec![key(Key::ArrowDown, Modifiers::SHIFT | Modifiers::ALT)]);
|
||
if got == NO_PICK {
|
||
got = preset_row(&ctx, &time, vec![]);
|
||
}
|
||
assert_eq!(got.1, Some(3.0), "13 pt steps down by ten");
|
||
assert!(!egui::Popup::is_any_open(&ctx), "the list stays closed");
|
||
assert_eq!(ctx.memory(|m| m.focused()), field);
|
||
}
|
||
|
||
#[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));
|
||
}
|