Skip to main content

waxterm/widgets/
numeric_field.rs

1//! Single numeric value with browse (arrow incr/decr) and edit (digit entry) modes.
2
3use 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/// Whether the field holds an integer or a float.
13#[derive(Clone, Copy, Debug)]
14pub enum NumericKind {
15    Integer,
16    Float { decimals: u8 },
17}
18
19/// A single numeric field supporting browse mode (arrow incr/decr) and
20/// edit mode (direct digit entry).
21pub 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    // Edit mode state
31    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    /// Set the field to integer mode.
56    pub fn integer(mut self) -> Self {
57        self.kind = NumericKind::Integer;
58        self
59    }
60
61    /// Set the field to float mode with the given number of decimal places.
62    pub fn float(mut self, decimals: u8) -> Self {
63        self.kind = NumericKind::Float { decimals };
64        self
65    }
66
67    /// Set the valid range (inclusive).
68    pub fn range(mut self, min: f64, max: f64) -> Self {
69        self.min = min;
70        self.max = max;
71        self
72    }
73
74    /// Set the increment/decrement step size.
75    pub fn step(mut self, step: f64) -> Self {
76        self.step = step;
77        self
78    }
79
80    /// Set the initial value. None means "use default".
81    pub fn value(mut self, v: Option<f64>) -> Self {
82        self.value = v;
83        self
84    }
85
86    /// Set the label shown when value is None.
87    pub fn none_label(mut self, label: &'static str) -> Self {
88        self.none_label = label;
89        self
90    }
91
92    /// Whether the field can be set to None.
93    pub fn nullable(mut self, nullable: bool) -> Self {
94        self.nullable = nullable;
95        self
96    }
97
98    /// Current value.
99    pub fn get_value(&self) -> Option<f64> {
100        self.value
101    }
102
103    /// Whether the field is in edit (text entry) mode.
104    pub fn is_editing(&self) -> bool {
105        self.editing
106    }
107
108    /// Format the current value for display.
109    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        // else: invalid input — keep previous value
162        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    /// Handle a key press. Returns `Confirmed` when Enter is pressed in browse mode,
177    /// `Cancelled` when Escape is pressed in browse mode.
178    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            // Browse mode
217            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 => {} // already None, can't go lower
232                    }
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    /// Render the field on a single row.
263    pub fn render(&self, frame: &mut Frame, area: Rect, focused: bool) {
264        let label_style = Style::default().fg(Color::Rgb(112, 128, 160)); // DIM
265        let focus_style = Style::default()
266            .fg(Color::Rgb(0, 232, 252))
267            .add_modifier(Modifier::BOLD); // CYAN
268        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            // Edit mode: show text buffer with cursor
286            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            // Browse mode: show ‹ value ›
304            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)); // clamped at max
353    }
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)); // clamped
386    }
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)); // reverted
396    }
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)); // min value
405    }
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')); // not a digit
426        assert!(!f.is_editing()); // should not enter edit mode
427    }
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)); // unchanged
449    }
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); // went below min → None
461    }
462}