use super::text_edit::EditState;
use super::{UiFrame, widget_id};
use crate::canvas::draw::Rect;
use crate::canvas::text::{HAlign, TextStyle, VAlign};
#[derive(Debug, Clone, Copy)]
pub(super) struct NumberDrag {
id: u64,
start_pos: glam::Vec2,
start_value: f32,
moved: bool,
}
const NUMBER_DRAG_THRESHOLD: f32 = 3.0;
const NUMBER_EDIT_MAX_LEN: usize = 24;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct NumberField {
pub speed: f32,
pub step: f32,
pub min: f32,
pub max: f32,
pub decimals: usize,
}
impl Default for NumberField {
fn default() -> Self {
Self {
speed: 1.0,
step: 1.0,
min: f32::NEG_INFINITY,
max: f32::INFINITY,
decimals: 2,
}
}
}
impl NumberField {
#[must_use]
pub fn speed(mut self, speed: f32) -> Self {
self.speed = speed;
self
}
#[must_use]
pub fn step(mut self, step: f32) -> Self {
self.step = step;
self
}
#[must_use]
pub fn range(mut self, min: f32, max: f32) -> Self {
self.min = min;
self.max = max;
self
}
#[must_use]
pub fn decimals(mut self, decimals: usize) -> Self {
self.decimals = decimals;
self
}
fn clamp(&self, value: f32) -> f32 {
let value = if self.min.is_nan() {
value
} else {
value.max(self.min)
};
if self.max.is_nan() {
value
} else {
value.min(self.max)
}
}
fn display(&self, value: f32) -> String {
format!("{value:.*}", self.decimals)
}
fn draft(&self, value: f32) -> String {
let display = self.display(value);
if display.len() > NUMBER_EDIT_MAX_LEN {
format!("{value:e}")
} else {
display
}
}
}
impl UiFrame<'_> {
#[allow(clippy::too_many_lines)]
pub fn number_field(
&mut self,
name: &str,
rect: Rect,
value: &mut f32,
opts: NumberField,
px: f32,
) -> bool {
let id = widget_id(name);
let side = rect.size().y;
let dec = Rect::new(rect.min.x, rect.min.y, side, side);
let inc = Rect::new(rect.max.x - side, rect.min.y, side, side);
let middle = Rect::new(
rect.min.x + side,
rect.min.y,
(rect.size().x - 2.0 * side).max(0.0),
side,
);
let before = *value;
if self.button(&format!("{name}.dec"), dec, "-", px) {
*value = opts.clamp(*value - opts.step);
}
if self.button(&format!("{name}.inc"), inc, "+", px) {
*value = opts.clamp(*value + opts.step);
}
self.register_focus(id, &middle);
if self.ui.focus == Some(id) {
if self.ui.edit.id != Some(id) {
self.ui.number_edit = opts.draft(*value);
}
let mut buf = std::mem::take(&mut self.ui.number_edit);
let edited = self.line_edit_impl(
name,
middle,
&mut buf,
NUMBER_EDIT_MAX_LEN,
px,
false,
false,
);
if edited
&& let Ok(typed) = buf.trim().parse::<f32>()
&& typed.is_finite()
{
*value = opts.clamp(typed);
}
self.ui.number_edit = buf;
return *value != before;
}
let hover = self.hit(&middle);
if self.input.mouse_pressed && hover {
self.ui.active = Some(id);
self.ui.number_drag = Some(NumberDrag {
id,
start_pos: self.input.mouse_pos,
start_value: *value,
moved: false,
});
}
let mut dragging = false;
if let Some(mut drag) = self.ui.number_drag
&& drag.id == id
{
let delta = self.input.mouse_pos - drag.start_pos;
if delta.x.abs() >= NUMBER_DRAG_THRESHOLD || delta.y.abs() >= NUMBER_DRAG_THRESHOLD {
drag.moved = true;
}
if drag.moved {
*value = opts.clamp(drag.start_value + delta.x * opts.speed);
}
if self.input.mouse_down {
self.ui.number_drag = Some(drag);
dragging = drag.moved;
} else {
self.ui.number_drag = None;
if !drag.moved {
self.ui.focus = Some(id);
self.edit_clicked = true;
self.ui.number_edit = opts.draft(*value);
self.ui.edit = EditState {
id: Some(id),
caret: self.ui.number_edit.chars().count(),
anchor: self.ui.number_edit.chars().count(),
scroll: 0.0,
};
}
}
}
let bg = if dragging {
self.ui.theme.pressed
} else if hover {
self.ui.theme.hovered
} else {
self.ui.theme.control
};
self.rect(middle, bg);
let fg = if hover {
self.ui.theme.text_hovered
} else {
self.ui.theme.text
};
let style = TextStyle::new(px, fg).with_outline(self.ui.theme.text_outline);
self.label(
middle,
&opts.display(*value),
&style,
HAlign::Center,
VAlign::Center,
);
*value != before
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::canvas::draw::DrawList;
use crate::ui::test_ui::{BTN, ROW, fixture, hover_at, press_at, release_at};
use crate::ui::{UiInput, UiKey};
use sgl_core::math::Vec2;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn numeric_keyboard_reentry_uses_stepped_value() {
let (mut ui, mut text, _assets) = fixture();
let mut value = 10.0;
for (index, input) in [
UiInput::default(),
UiInput {
keys: vec![UiKey::Tab],
..UiInput::default()
},
UiInput {
keys: vec![UiKey::Enter],
..UiInput::default()
},
UiInput {
keys: vec![UiKey::Tab],
shift: true,
..UiInput::default()
},
UiInput {
chars: vec!['0'],
..UiInput::default()
},
]
.into_iter()
.enumerate()
{
let mut list = DrawList::new();
let mut f = ui.begin(&mut text, &mut list, input);
if index == 0 {
f.focus("n");
}
f.number_field(
"n",
BTN,
&mut value,
NumberField::default().decimals(0),
20.0,
);
f.end();
if index == 2 {
assert_eq!(value, 9.0);
}
}
assert_eq!(value, 90.0);
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_buttons_step_and_clamp() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().step(5.0).range(0.0, 12.0);
let mut value = 10.0;
let mut f = ui.begin(&mut text, &mut list, press_at(230.0, 116.0));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 12.0, "10 + 5 clamps to the max");
let mut f = ui.begin(&mut text, &mut list, press_at(20.0, 116.0));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 7.0);
let mut f = ui.begin(&mut text, &mut list, hover_at(20.0, 116.0, true));
assert!(
!f.number_field("n", ROW, &mut value, opts, 20.0),
"held: no repeat"
);
f.end();
assert_eq!(value, 7.0);
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_drag_scrubs_by_speed() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().speed(0.5).range(-100.0, 100.0);
let mut value = 1.0;
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
let mut f = ui.begin(&mut text, &mut list, hover_at(102.0, 116.0, true));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 1.0);
let mut f = ui.begin(&mut text, &mut list, hover_at(120.0, 116.0, true));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 11.0);
let mut f = ui.begin(&mut text, &mut list, hover_at(106.0, 116.0, true));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 4.0);
let mut f = ui.begin(&mut text, &mut list, hover_at(900.0, 116.0, true));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
assert_eq!(value, 100.0);
let mut f = ui.begin(&mut text, &mut list, release_at(900.0, 116.0));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert!(!ui.has_focus(), "a drag never opens the field for typing");
assert_eq!(value, 100.0);
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_release_frame_movement_scrubs() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default();
let mut value = 1.0;
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
let mut f = ui.begin(&mut text, &mut list, release_at(120.0, 116.0));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 21.0);
assert!(!ui.has_focus(), "a drag never opens the field for typing");
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
let mut f = ui.begin(&mut text, &mut list, hover_at(110.0, 116.0, true));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
assert_eq!(value, 31.0);
let mut f = ui.begin(&mut text, &mut list, release_at(130.0, 116.0));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 51.0, "the release frame's movement is applied");
assert!(!ui.has_focus());
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_vertical_drag_does_not_open_typing() {
for positions in [vec![(100.0, 500.0)], vec![(100.0, 500.0), (100.0, 116.0)]] {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let mut value = 2.5;
let opts = NumberField::default();
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
for (index, &(x, y)) in positions.iter().enumerate() {
let input = if index + 1 == positions.len() {
release_at(x, y)
} else {
hover_at(x, y, true)
};
let mut f = ui.begin(&mut text, &mut list, input);
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
}
assert_eq!(value, 2.5, "vertical travel does not scrub the value");
assert!(!ui.has_focus(), "vertical drag is not a click-to-type");
}
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_large_opening_draft_accepts_typing() {
for clicked in [false, true] {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let mut value = 1e22;
let opts = NumberField::default().decimals(2);
if clicked {
for input in [press_at(100.0, 116.0), release_at(100.0, 116.0)] {
let mut f = ui.begin(&mut text, &mut list, input);
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
}
} else {
let mut f = ui.begin(&mut text, &mut list, UiInput::default());
f.focus("n");
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
}
let opening = ui.number_edit.clone();
let mut f = ui.begin(
&mut text,
&mut list,
UiInput {
keys: vec![UiKey::Home],
chars: vec!['5'],
..UiInput::default()
},
);
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_ne!(
ui.number_edit, opening,
"opening draft accepts an insertion"
);
assert!(ui.number_edit.starts_with('5'), "Home inserts at the start");
assert!(value > 1e22, "the inserted digit updates the parsed value");
}
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_click_types_a_value() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().range(-10.0, 10.0);
let mut value = 2.5;
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
let mut f = ui.begin(&mut text, &mut list, release_at(101.0, 116.0));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert!(ui.has_focus(), "a click opens the field for typing");
assert_eq!(value, 2.5);
let type_in = |chars: &[char], backspace: bool| UiInput {
mouse_pos: Vec2::new(500.0, 500.0),
chars: chars.to_vec(),
backspace,
..UiInput::default()
};
let mut f = ui.begin(&mut text, &mut list, type_in(&[], true));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 2.5, "\"2.5\" parses to the same value");
let mut f = ui.begin(&mut text, &mut list, type_in(&[], true));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 2.0, "\"2.\" parses as 2");
for _ in 0..2 {
let mut f = ui.begin(&mut text, &mut list, type_in(&[], true));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 2.0, "\"2\" then \"\": value kept");
}
let mut f = ui.begin(&mut text, &mut list, type_in(&['-'], false));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 2.0);
let mut f = ui.begin(&mut text, &mut list, type_in(&['7'], false));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, -7.0);
let mut f = ui.begin(&mut text, &mut list, type_in(&['9'], false));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, -10.0, "typed -79 clamps to the min");
let mut f = ui.begin(&mut text, &mut list, press_at(500.0, 500.0));
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert!(!ui.has_focus());
assert_eq!(value, -10.0);
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_one_frame_click_types_a_value() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().decimals(0);
let mut value = 1.0;
let click = UiInput {
mouse_pos: Vec2::new(100.0, 116.0),
mouse_pressed: true,
mouse_released: true,
..UiInput::default()
};
let mut f = ui.begin(&mut text, &mut list, click);
assert!(!f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert!(
ui.has_focus(),
"a one-frame click opens the field for typing"
);
let mut f = ui.begin(
&mut text,
&mut list,
UiInput {
mouse_pos: Vec2::new(500.0, 500.0),
chars: vec!['5'],
..UiInput::default()
},
);
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 15.0, "typed text edits the value");
}
fn release_and_press_at(x: f32, y: f32) -> UiInput {
UiInput {
mouse_pos: Vec2::new(x, y),
mouse_pressed: true,
mouse_released: true,
mouse_down: true,
..UiInput::default()
}
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_release_then_press_in_one_frame_keeps_the_drag() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().speed(1.0).range(-100.0, 100.0);
let mut value = 1.0;
let mut f = ui.begin(&mut text, &mut list, press_at(100.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
let mut f = ui.begin(&mut text, &mut list, release_and_press_at(110.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
let mut f = ui.begin(&mut text, &mut list, hover_at(120.0, 116.0, true));
assert!(f.number_field("n", ROW, &mut value, opts, 20.0));
f.end();
assert_eq!(value, 11.0);
let mut f = ui.begin(&mut text, &mut list, release_at(120.0, 116.0));
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
assert!(!ui.has_focus(), "a drag never opens the field for typing");
}
#[wasm_bindgen_test(unsupported = test)]
fn number_field_release_then_press_elsewhere_ends_the_drag() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let opts = NumberField::default().speed(1.0).range(-100.0, 100.0);
let mut value = 1.0;
for input in [
press_at(100.0, 116.0),
release_and_press_at(500.0, 500.0),
hover_at(140.0, 116.0, true),
release_at(140.0, 116.0),
] {
let mut f = ui.begin(&mut text, &mut list, input);
f.number_field("n", ROW, &mut value, opts, 20.0);
f.end();
}
assert_eq!(value, 1.0);
assert!(!ui.has_focus());
}
}