1use ratatui::layout::Rect;
4use ratatui::style::{Color, Modifier, Style};
5use ratatui::text::{Line, Span};
6use ratatui::widgets::Paragraph;
7use ratatui::Frame;
8
9use super::WidgetResult;
10use crate::input::KeyPress;
11
12#[derive(Clone, Copy, Debug)]
14pub enum NumericKind {
15 Integer,
16 Float { decimals: u8 },
17}
18
19pub struct NumericField {
22 label: String,
23 kind: NumericKind,
24 value: Option<f64>,
25 min: f64,
26 max: f64,
27 step: f64,
28 nullable: bool,
29 none_label: &'static str,
30 editing: bool,
32 edit_buf: String,
33 edit_cursor: usize,
34 pre_edit_value: Option<f64>,
35}
36
37impl NumericField {
38 pub fn new(label: impl Into<String>) -> Self {
39 Self {
40 label: label.into(),
41 kind: NumericKind::Integer,
42 value: None,
43 min: 0.0,
44 max: f64::MAX,
45 step: 1.0,
46 nullable: true,
47 none_label: "default",
48 editing: false,
49 edit_buf: String::new(),
50 edit_cursor: 0,
51 pre_edit_value: None,
52 }
53 }
54
55 pub fn integer(mut self) -> Self {
57 self.kind = NumericKind::Integer;
58 self
59 }
60
61 pub fn float(mut self, decimals: u8) -> Self {
63 self.kind = NumericKind::Float { decimals };
64 self
65 }
66
67 pub fn range(mut self, min: f64, max: f64) -> Self {
69 self.min = min;
70 self.max = max;
71 self
72 }
73
74 pub fn step(mut self, step: f64) -> Self {
76 self.step = step;
77 self
78 }
79
80 pub fn value(mut self, v: Option<f64>) -> Self {
82 self.value = v;
83 self
84 }
85
86 pub fn none_label(mut self, label: &'static str) -> Self {
88 self.none_label = label;
89 self
90 }
91
92 pub fn nullable(mut self, nullable: bool) -> Self {
94 self.nullable = nullable;
95 self
96 }
97
98 pub fn get_value(&self) -> Option<f64> {
100 self.value
101 }
102
103 pub fn is_editing(&self) -> bool {
105 self.editing
106 }
107
108 pub fn display_value(&self) -> String {
110 match self.value {
111 None => self.none_label.to_owned(),
112 Some(v) => match self.kind {
113 NumericKind::Integer => format!("{}", v as i64),
114 NumericKind::Float { decimals } => {
115 format!("{:.prec$}", v, prec = decimals as usize)
116 }
117 },
118 }
119 }
120
121 fn clamp(&self, v: f64) -> f64 {
122 v.clamp(self.min, self.max)
123 }
124
125 fn round_for_kind(&self, v: f64) -> f64 {
126 match self.kind {
127 NumericKind::Integer => v.round(),
128 NumericKind::Float { decimals } => {
129 let factor = 10f64.powi(decimals as i32);
130 (v * factor).round() / factor
131 }
132 }
133 }
134
135 fn enter_edit_mode(&mut self, initial_char: Option<u8>) {
136 self.pre_edit_value = self.value;
137 self.editing = true;
138 self.edit_buf = match initial_char {
139 Some(ch) => {
140 self.edit_cursor = 1;
141 String::from(ch as char)
142 }
143 None => {
144 let s = self.display_value();
145 self.edit_cursor = s.len();
146 if self.value.is_none() {
147 String::new()
148 } else {
149 s
150 }
151 }
152 };
153 }
154
155 fn commit_edit(&mut self) {
156 if self.edit_buf.is_empty() && self.nullable {
157 self.value = None;
158 } else if let Ok(v) = self.edit_buf.parse::<f64>() {
159 self.value = Some(self.round_for_kind(self.clamp(v)));
160 }
161 self.editing = false;
163 self.edit_buf.clear();
164 }
165
166 fn cancel_edit(&mut self) {
167 self.value = self.pre_edit_value;
168 self.editing = false;
169 self.edit_buf.clear();
170 }
171
172 fn is_valid_edit_char(&self, b: u8) -> bool {
173 b.is_ascii_digit() || b == b'.' || b == b'-'
174 }
175
176 pub fn handle_key(&mut self, key: &KeyPress) -> WidgetResult<Option<f64>> {
179 if self.editing {
180 match key {
181 KeyPress::Enter => {
182 self.commit_edit();
183 WidgetResult::Pending
184 }
185 KeyPress::Escape => {
186 self.cancel_edit();
187 WidgetResult::Pending
188 }
189 KeyPress::Backspace => {
190 if self.edit_cursor > 0 {
191 self.edit_cursor -= 1;
192 self.edit_buf.remove(self.edit_cursor);
193 }
194 WidgetResult::Pending
195 }
196 KeyPress::ArrowLeft => {
197 if self.edit_cursor > 0 {
198 self.edit_cursor -= 1;
199 }
200 WidgetResult::Pending
201 }
202 KeyPress::ArrowRight => {
203 if self.edit_cursor < self.edit_buf.len() {
204 self.edit_cursor += 1;
205 }
206 WidgetResult::Pending
207 }
208 KeyPress::Char(b) if self.is_valid_edit_char(*b) => {
209 self.edit_buf.insert(self.edit_cursor, *b as char);
210 self.edit_cursor += 1;
211 WidgetResult::Pending
212 }
213 _ => WidgetResult::Pending,
214 }
215 } else {
216 match key {
218 KeyPress::ArrowLeft => {
219 match self.value {
220 Some(v) => {
221 let new_v = self.round_for_kind(v - self.step);
222 if new_v < self.min && self.nullable {
223 self.value = None;
224 } else {
225 self.value = Some(self.clamp(new_v));
226 }
227 }
228 None if !self.nullable => {
229 self.value = Some(self.min);
230 }
231 None => {} }
233 WidgetResult::Pending
234 }
235 KeyPress::ArrowRight => {
236 match self.value {
237 Some(v) => {
238 let new_v = self.round_for_kind(v + self.step);
239 self.value = Some(self.clamp(new_v));
240 }
241 None => {
242 self.value = Some(self.min);
243 }
244 }
245 WidgetResult::Pending
246 }
247 KeyPress::Backspace if self.nullable => {
248 self.value = None;
249 WidgetResult::Pending
250 }
251 KeyPress::Char(b) if self.is_valid_edit_char(*b) => {
252 self.enter_edit_mode(Some(*b));
253 WidgetResult::Pending
254 }
255 KeyPress::Enter => WidgetResult::Confirmed(self.value),
256 KeyPress::Escape => WidgetResult::Cancelled,
257 _ => WidgetResult::Pending,
258 }
259 }
260 }
261
262 pub fn render(&self, frame: &mut Frame, area: Rect, focused: bool) {
264 let label_style = Style::default().fg(Color::Rgb(112, 128, 160)); let focus_style = Style::default()
266 .fg(Color::Rgb(0, 232, 252))
267 .add_modifier(Modifier::BOLD); let value_style = if focused {
269 Style::default().fg(Color::White)
270 } else {
271 label_style
272 };
273
274 let cursor_marker = if focused { "\u{25b6} " } else { " " };
275
276 let mut spans: Vec<Span> = vec![
277 Span::styled(
278 cursor_marker,
279 if focused { focus_style } else { label_style },
280 ),
281 Span::styled(format!("{:<16}", self.label), label_style),
282 ];
283
284 if self.editing {
285 let buf = &self.edit_buf;
287 if self.edit_cursor > 0 && self.edit_cursor <= buf.len() {
288 spans.push(Span::styled(&buf[..self.edit_cursor], value_style));
289 }
290 let cursor_ch = if self.edit_cursor < buf.len() {
291 &buf[self.edit_cursor..self.edit_cursor + 1]
292 } else {
293 " "
294 };
295 spans.push(Span::styled(
296 cursor_ch.to_owned(),
297 Style::default().fg(Color::Black).bg(Color::White),
298 ));
299 if self.edit_cursor + 1 < buf.len() {
300 spans.push(Span::styled(&buf[self.edit_cursor + 1..], value_style));
301 }
302 } else {
303 let display = self.display_value();
305 if focused {
306 spans.push(Span::styled("\u{2039} ", focus_style));
307 spans.push(Span::styled(display, value_style));
308 spans.push(Span::styled(" \u{203a}", focus_style));
309 } else {
310 spans.push(Span::styled(display, value_style));
311 }
312 }
313
314 frame.render_widget(Paragraph::new(Line::from(spans)), area);
315 }
316}
317
318#[cfg(test)]
319mod tests {
320 use super::*;
321
322 fn int_field() -> NumericField {
323 NumericField::new("Tokens")
324 .integer()
325 .range(64.0, 32768.0)
326 .step(64.0)
327 .value(Some(2048.0))
328 }
329
330 fn float_field() -> NumericField {
331 NumericField::new("Temp")
332 .float(2)
333 .range(0.0, 2.0)
334 .step(0.05)
335 .value(Some(0.7))
336 }
337
338 #[test]
339 fn test_increment_decrement() {
340 let mut f = int_field();
341 f.handle_key(&KeyPress::ArrowRight);
342 assert_eq!(f.get_value(), Some(2112.0));
343 f.handle_key(&KeyPress::ArrowLeft);
344 assert_eq!(f.get_value(), Some(2048.0));
345 }
346
347 #[test]
348 fn test_clamp_to_range() {
349 let mut f = int_field();
350 f.value = Some(32768.0);
351 f.handle_key(&KeyPress::ArrowRight);
352 assert_eq!(f.get_value(), Some(32768.0)); }
354
355 #[test]
356 fn test_digit_entry_switches_to_edit() {
357 let mut f = int_field();
358 assert!(!f.is_editing());
359 f.handle_key(&KeyPress::Char(b'5'));
360 assert!(f.is_editing());
361 assert_eq!(f.edit_buf, "5");
362 }
363
364 #[test]
365 fn test_edit_confirm_parses() {
366 let mut f = int_field();
367 f.handle_key(&KeyPress::Char(b'4'));
368 f.handle_key(&KeyPress::Char(b'0'));
369 f.handle_key(&KeyPress::Char(b'9'));
370 f.handle_key(&KeyPress::Char(b'6'));
371 f.handle_key(&KeyPress::Enter);
372 assert!(!f.is_editing());
373 assert_eq!(f.get_value(), Some(4096.0));
374 }
375
376 #[test]
377 fn test_edit_clamps_parsed_value() {
378 let mut f = int_field();
379 f.handle_key(&KeyPress::Char(b'9'));
380 f.handle_key(&KeyPress::Char(b'9'));
381 f.handle_key(&KeyPress::Char(b'9'));
382 f.handle_key(&KeyPress::Char(b'9'));
383 f.handle_key(&KeyPress::Char(b'9'));
384 f.handle_key(&KeyPress::Enter);
385 assert_eq!(f.get_value(), Some(32768.0)); }
387
388 #[test]
389 fn test_edit_escape_reverts() {
390 let mut f = int_field();
391 assert_eq!(f.get_value(), Some(2048.0));
392 f.handle_key(&KeyPress::Char(b'1'));
393 f.handle_key(&KeyPress::Escape);
394 assert!(!f.is_editing());
395 assert_eq!(f.get_value(), Some(2048.0)); }
397
398 #[test]
399 fn test_none_toggle() {
400 let mut f = int_field().nullable(true);
401 f.handle_key(&KeyPress::Backspace);
402 assert_eq!(f.get_value(), None);
403 f.handle_key(&KeyPress::ArrowRight);
404 assert_eq!(f.get_value(), Some(64.0)); }
406
407 #[test]
408 fn test_float_formatting() {
409 let f = float_field();
410 assert_eq!(f.display_value(), "0.70");
411 }
412
413 #[test]
414 fn test_float_step() {
415 let mut f = float_field();
416 f.handle_key(&KeyPress::ArrowRight);
417 assert_eq!(f.display_value(), "0.75");
418 f.handle_key(&KeyPress::ArrowLeft);
419 assert_eq!(f.display_value(), "0.70");
420 }
421
422 #[test]
423 fn test_invalid_input_ignored() {
424 let mut f = int_field();
425 f.handle_key(&KeyPress::Char(b'a')); assert!(!f.is_editing()); }
428
429 #[test]
430 fn test_browse_enter_confirms() {
431 let mut f = int_field();
432 assert_eq!(
433 f.handle_key(&KeyPress::Enter),
434 WidgetResult::Confirmed(Some(2048.0))
435 );
436 }
437
438 #[test]
439 fn test_browse_escape_cancels() {
440 let mut f = int_field();
441 assert_eq!(f.handle_key(&KeyPress::Escape), WidgetResult::Cancelled);
442 }
443
444 #[test]
445 fn test_non_nullable_cannot_be_none() {
446 let mut f = int_field().nullable(false);
447 f.handle_key(&KeyPress::Backspace);
448 assert_eq!(f.get_value(), Some(2048.0)); }
450
451 #[test]
452 fn test_decrement_past_min_to_none() {
453 let mut f = NumericField::new("X")
454 .integer()
455 .range(1.0, 10.0)
456 .step(1.0)
457 .value(Some(1.0))
458 .nullable(true);
459 f.handle_key(&KeyPress::ArrowLeft);
460 assert_eq!(f.get_value(), None); }
462}