use std::cell::Cell;
use std::rc::Rc;
use crate::core::config::{ElementBuilder, EventHandler, InteractionConfig, LayoutConfig};
use crate::core::context::MountContext;
use crate::core::element::ElementId;
use crate::core::widget::Widget;
use crate::ecs::components;
use crate::event::{Key, Modifiers};
use crate::style::styled::{StyleRefinement, Styled};
use crate::style::Padding;
use auralis_signal::Signal;
use super::button::Button;
use super::text_input::{TextInput, TextInputType};
pub struct NumberInput {
value: Signal<f64>,
min: f64,
max: f64,
step: f64,
large_step: f64,
decimals: usize,
disabled: bool,
placeholder: String,
style: StyleRefinement,
}
impl NumberInput {
pub fn new(value: Signal<f64>) -> Self {
Self {
value,
min: f64::MIN,
max: f64::MAX,
step: 1.0,
large_step: 10.0,
decimals: 2,
disabled: false,
placeholder: String::new(),
style: StyleRefinement::default(),
}
}
pub fn range(mut self, min: f64, max: f64) -> Self {
self.min = min;
self.max = max;
self
}
pub fn step(mut self, step: f64) -> Self {
self.step = step;
self
}
pub fn large_step(mut self, step: f64) -> Self {
self.large_step = step;
self
}
pub fn decimals(mut self, n: usize) -> Self {
self.decimals = n;
self
}
pub fn disabled(mut self) -> Self {
self.disabled = true;
self
}
pub fn placeholder(mut self, p: impl Into<String>) -> Self {
self.placeholder = p.into();
self
}
}
impl Styled for NumberInput {
fn style_refinement(&mut self) -> &mut StyleRefinement {
&mut self.style
}
}
fn format_value(v: f64, decimals: usize) -> String {
if decimals == 0 {
format!("{:.0}", v)
} else {
format!("{:.1$}", v, decimals)
}
}
fn parse_value(s: &str) -> Option<f64> {
let cleaned = s.trim().replace(',', ".");
if cleaned.is_empty() || cleaned == "-" || cleaned == "." || cleaned == "-." {
return None;
}
cleaned.parse::<f64>().ok()
}
fn clamp_to_step(v: f64, min: f64, max: f64, step: f64) -> f64 {
let clamped = v.clamp(min, max);
if step > 0.0 && min > f64::MIN / 2.0 && max < f64::MAX / 2.0 {
let offset = (clamped - min) / step;
let snapped = offset.round() * step + min;
snapped.clamp(min, max)
} else {
clamped
}
}
impl Widget for NumberInput {
fn component_mask(&self) -> u64 {
components::STYLE | components::LAYOUT
}
fn mount_box(self: Box<Self>, ctx: &mut MountContext<'_>) -> ElementId {
let min = self.min;
let max = self.max;
let step = self.step;
let large_step = self.large_step;
let decimals = self.decimals;
let disabled = self.disabled;
let component_mask = self.component_mask();
let value_signal = self.value;
let placeholder = self.placeholder;
let external_sync_guard: Rc<Cell<bool>> = Rc::new(Cell::new(false));
let formatted = format_value(value_signal.read(), decimals);
let text_signal = Signal::new(formatted);
let mut events = EventHandler::new();
if !disabled {
let key_val = value_signal.clone();
events = events.on_key_down(move |key: Key, mods: Modifiers| -> bool {
let delta = if mods.shift { large_step } else { step };
match key {
Key::ArrowUp => {
let v = clamp_to_step(key_val.read() + delta, min, max, step);
key_val.set(v);
true
}
Key::ArrowDown => {
let v = clamp_to_step(key_val.read() - delta, min, max, step);
key_val.set(v);
true
}
_ => false,
}
});
let scroll_val = value_signal.clone();
events = events.on_scroll(move |_dx: f32, dy: f32| -> bool {
if dy.abs() < 0.5 {
return false;
}
let delta = if dy > 0.0 { step } else { -step };
let v = clamp_to_step(scroll_val.read() + delta, min, max, step);
scroll_val.set(v);
true
});
}
let container_layout = LayoutConfig {
gap: 4.0,
padding: Padding::all(0.0),
..LayoutConfig::default()
};
let container_id = ElementBuilder::new()
.with_components(component_mask)
.layout(container_layout)
.interaction(InteractionConfig {
events: Some(events),
..InteractionConfig::default()
})
.build(ctx);
{
let Some(el) = ctx.arena.get_mut(container_id) else {
return container_id;
};
el.set_accessible_role(accesskit::Role::Group);
el.set_layout_direction(crate::core::LayoutDirection::Horizontal);
if let Some(fs) = self.style.font_size {
el.set_font_size(fs);
}
}
{
let ext_val_for_closure = value_signal.clone();
let ext_text = text_signal.clone();
let guard = external_sync_guard.clone();
crate::core::signal_bridge::subscribe_owned(container_id, &value_signal, move || {
guard.set(true);
let v = ext_val_for_closure.read();
let s = format_value(v, decimals);
let current = ext_text.read();
let same_val =
parse_value(¤t).is_some_and(|pv| (pv - v).abs() < f64::EPSILON);
if !same_val && s != current {
ext_text.set(s);
}
guard.set(false);
});
}
let dec_val = value_signal.clone();
let dec_btn: Box<dyn Widget> = if disabled {
Box::new(Button::new("\u{2212}").disabled())
} else {
Box::new(Button::new("\u{2212}").on_click(move || {
let v = clamp_to_step(dec_val.read() - step, min, max, step);
dec_val.set(v);
}))
};
let dec_id = dec_btn.mount_box(&mut ctx.child_with_events(container_id));
ctx.arena.add_child(container_id, dec_id);
let on_change_val = value_signal.clone();
let on_change_guard = external_sync_guard.clone();
let on_change_text = text_signal.clone();
let mut text_input = TextInput::new(text_signal.clone())
.input_type(TextInputType::Text)
.placeholder(placeholder)
.on_value_changed(move |s: String| {
if on_change_guard.get() {
return; }
if let Some(v) = parse_value(&s) {
on_change_val.set(v);
} else {
let filtered: String = s
.chars()
.filter(|c| c.is_ascii_digit() || *c == '.' || *c == '-')
.collect();
if filtered != s {
on_change_guard.set(true);
on_change_text.set(filtered);
on_change_guard.set(false);
} else if !filtered.is_empty()
&& filtered != "-"
&& filtered != "."
&& filtered != "-."
{
on_change_guard.set(true);
on_change_text.set(format_value(on_change_val.read(), decimals));
on_change_guard.set(false);
}
}
})
.on_submit({
let tv = value_signal.clone();
move |s: String| {
if let Some(v) = parse_value(&s) {
let clamped = clamp_to_step(v, min, max, step);
tv.set(clamped);
}
}
});
if disabled {
text_input = text_input.disabled();
}
let input_id = Box::new(text_input).mount_box(&mut ctx.child_with_events(container_id));
ctx.arena.add_child(container_id, input_id);
{
let blur_val = value_signal.clone();
let blur_text = text_signal.clone();
let blur_guard = external_sync_guard.clone();
let blur_events = EventHandler::new().on_focus_out(move |_reason| {
blur_guard.set(true);
let text = blur_text.read();
if let Some(v) = parse_value(&text) {
let clamped = clamp_to_step(v, min, max, step);
blur_val.set(clamped);
blur_text.set(format_value(clamped, decimals));
} else {
blur_text.set(format_value(blur_val.read(), decimals));
}
blur_guard.set(false);
});
if let Some(reg) = ctx.event_registry.as_mut() {
blur_events.register_all(reg, input_id);
}
}
let inc_val = value_signal.clone();
let inc_btn: Box<dyn Widget> = if disabled {
Box::new(Button::new("+").disabled())
} else {
Box::new(Button::new("+").on_click(move || {
let v = clamp_to_step(inc_val.read() + step, min, max, step);
inc_val.set(v);
}))
};
let inc_id = inc_btn.mount_box(&mut ctx.child_with_events(container_id));
ctx.arena.add_child(container_id, inc_id);
{
let Some(el) = ctx.arena.get_mut(container_id) else {
return container_id;
};
el.set_accessible_label(format!(
"Number input, value {}, minimum {}, maximum {}",
format_value(value_signal.read(), decimals),
min,
max,
));
}
container_id
}
}
impl std::fmt::Debug for NumberInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NumberInput")
.field("min", &self.min)
.field("max", &self.max)
.field("step", &self.step)
.field("decimals", &self.decimals)
.field("disabled", &self.disabled)
.finish_non_exhaustive()
}
}