Skip to main content

waxterm/widgets/
settings_form.rs

1//! Vertical stack of [`NumericField`] instances with field navigation.
2
3use ratatui::layout::Rect;
4use ratatui::Frame;
5
6use super::numeric_field::NumericField;
7use super::WidgetResult;
8use crate::input::KeyPress;
9
10/// A vertical form of numeric fields with arrow-key navigation.
11///
12/// Arrow up/down navigates between fields. All other keys delegate to the
13/// currently selected field. When a field is in edit mode, up/down are
14/// blocked until the user confirms (Enter) or cancels (Escape) the edit.
15pub struct SettingsForm {
16    fields: Vec<NumericField>,
17    selected: usize,
18}
19
20impl SettingsForm {
21    pub fn new(fields: Vec<NumericField>) -> Self {
22        Self {
23            fields,
24            selected: 0,
25        }
26    }
27
28    /// Index of the currently selected field.
29    pub fn selected(&self) -> usize {
30        self.selected
31    }
32
33    /// Number of fields.
34    pub fn len(&self) -> usize {
35        self.fields.len()
36    }
37
38    /// Whether the form has no fields.
39    pub fn is_empty(&self) -> bool {
40        self.fields.is_empty()
41    }
42
43    /// Whether the currently selected field is in edit (text entry) mode.
44    pub fn is_editing(&self) -> bool {
45        self.fields
46            .get(self.selected)
47            .is_some_and(|f| f.is_editing())
48    }
49
50    /// Get all current field values.
51    pub fn values(&self) -> Vec<Option<f64>> {
52        self.fields.iter().map(|f| f.get_value()).collect()
53    }
54
55    /// Handle a key press.
56    ///
57    /// Returns `Confirmed(())` when Enter is pressed in browse mode (all fields committed).
58    /// Returns `Cancelled` when Escape is pressed in browse mode.
59    /// Returns `Pending` for all navigation and edit operations.
60    pub fn handle_key(&mut self, key: &KeyPress) -> WidgetResult<()> {
61        if self.fields.is_empty() {
62            return match key {
63                KeyPress::Enter => WidgetResult::Confirmed(()),
64                KeyPress::Escape => WidgetResult::Cancelled,
65                _ => WidgetResult::Pending,
66            };
67        }
68
69        let field = &mut self.fields[self.selected];
70
71        // If the field is in edit mode, delegate everything to it.
72        if field.is_editing() {
73            field.handle_key(key);
74            return WidgetResult::Pending;
75        }
76
77        // Browse mode: arrow up/down navigates fields.
78        match key {
79            KeyPress::ArrowUp => {
80                if self.selected > 0 {
81                    self.selected -= 1;
82                }
83                WidgetResult::Pending
84            }
85            KeyPress::ArrowDown => {
86                if self.selected + 1 < self.fields.len() {
87                    self.selected += 1;
88                }
89                WidgetResult::Pending
90            }
91            key => {
92                // Delegate to the field. Map field-level Confirmed/Cancelled
93                // to form-level signals.
94                match field.handle_key(key) {
95                    WidgetResult::Confirmed(_) => WidgetResult::Confirmed(()),
96                    WidgetResult::Cancelled => WidgetResult::Cancelled,
97                    WidgetResult::Pending => WidgetResult::Pending,
98                }
99            }
100        }
101    }
102
103    /// Render the form. Each field occupies one row.
104    pub fn render(&self, frame: &mut Frame, area: Rect) {
105        for (i, field) in self.fields.iter().enumerate() {
106            if i as u16 >= area.height {
107                break;
108            }
109            let row = Rect {
110                y: area.y + i as u16,
111                height: 1,
112                ..area
113            };
114            field.render(frame, row, i == self.selected);
115        }
116    }
117}
118
119#[cfg(test)]
120mod tests {
121    use super::super::numeric_field::NumericField;
122    use super::*;
123
124    fn make_form() -> SettingsForm {
125        SettingsForm::new(vec![
126            NumericField::new("A")
127                .integer()
128                .range(0.0, 100.0)
129                .step(1.0)
130                .value(Some(10.0)),
131            NumericField::new("B")
132                .float(2)
133                .range(0.0, 1.0)
134                .step(0.1)
135                .value(Some(0.5)),
136            NumericField::new("C")
137                .integer()
138                .range(0.0, 50.0)
139                .step(5.0)
140                .value(Some(25.0)),
141        ])
142    }
143
144    #[test]
145    fn test_navigation() {
146        let mut form = make_form();
147        assert_eq!(form.selected(), 0);
148        form.handle_key(&KeyPress::ArrowDown);
149        assert_eq!(form.selected(), 1);
150        form.handle_key(&KeyPress::ArrowDown);
151        assert_eq!(form.selected(), 2);
152        form.handle_key(&KeyPress::ArrowDown); // can't go past end
153        assert_eq!(form.selected(), 2);
154        form.handle_key(&KeyPress::ArrowUp);
155        assert_eq!(form.selected(), 1);
156    }
157
158    #[test]
159    fn test_enter_confirms_form() {
160        let mut form = make_form();
161        assert_eq!(
162            form.handle_key(&KeyPress::Enter),
163            WidgetResult::Confirmed(())
164        );
165    }
166
167    #[test]
168    fn test_escape_cancels_form() {
169        let mut form = make_form();
170        assert_eq!(form.handle_key(&KeyPress::Escape), WidgetResult::Cancelled);
171    }
172
173    #[test]
174    fn test_arrow_adjusts_selected_field() {
175        let mut form = make_form();
176        form.handle_key(&KeyPress::ArrowRight); // increment field A
177        assert_eq!(form.values()[0], Some(11.0));
178        assert_eq!(form.values()[1], Some(0.5)); // B unchanged
179    }
180
181    #[test]
182    fn test_edit_mode_blocks_navigation() {
183        let mut form = make_form();
184        form.handle_key(&KeyPress::Char(b'5')); // enter edit on field A
185        assert!(form.is_editing());
186        form.handle_key(&KeyPress::ArrowDown); // should NOT navigate — goes to field edit cursor
187        assert_eq!(form.selected(), 0); // still on field A
188    }
189
190    #[test]
191    fn test_values() {
192        let form = make_form();
193        assert_eq!(form.values(), vec![Some(10.0), Some(0.5), Some(25.0)]);
194    }
195}