1use crate::data::FieldValue;
4use crate::event::Event;
5use crate::view::{Context, DrawCtx, Group, Rect, View, ViewId};
6use crate::widgets::{InputLine, RevealEye, RevealEyeConfig};
7
8pub struct MaskedInput {
15 group: Group,
16 input_id: ViewId,
17 eye_id: ViewId,
18}
19
20impl MaskedInput {
21 pub fn new(bounds: Rect, limit: i32, mask: char, cfg: RevealEyeConfig) -> Self {
25 let w = bounds.b.x - bounds.a.x;
26 let h = bounds.b.y - bounds.a.y;
27 let mut group = Group::new(bounds);
28
29 let mut input = InputLine::with_limit(Rect::new(0, 0, (w - 1).max(1), h), limit);
33 input.set_mask(Some(mask));
34 let input_id = group.insert(Box::new(input));
35
36 let eye = RevealEye::new(Rect::new((w - 1).max(1), 0, w, h), cfg);
37 let eye_id = group.insert(Box::new(eye));
38
39 MaskedInput {
40 group,
41 input_id,
42 eye_id,
43 }
44 }
45
46 fn input_mut(&mut self) -> Option<&mut InputLine> {
47 self.group
48 .child_mut(self.input_id)?
49 .as_any_mut()?
50 .downcast_mut::<InputLine>()
51 }
52 fn eye_mut(&mut self) -> Option<&mut RevealEye> {
53 self.group
54 .child_mut(self.eye_id)?
55 .as_any_mut()?
56 .downcast_mut::<RevealEye>()
57 }
58
59 pub fn value(&self) -> Option<FieldValue> {
74 self.group.gather_data().into_iter().next().flatten()
75 }
76 pub fn set_value(&mut self, v: FieldValue) {
78 if let Some(i) = self.input_mut() {
79 i.set_value(v);
80 }
81 }
82
83 #[cfg(test)]
84 fn input_ref(&mut self) -> &InputLine {
85 self.input_mut().expect("input child")
86 }
87 #[cfg(test)]
88 fn input_bounds(&mut self) -> Rect {
89 self.input_mut().expect("input child").state().get_bounds()
90 }
91}
92
93#[crate::delegate(to = group)]
94impl View for MaskedInput {
95 fn as_any_mut(&mut self) -> Option<&mut dyn core::any::Any> {
96 Some(self)
97 }
98
99 fn value(&self) -> Option<FieldValue> {
112 self.value()
113 }
114 fn set_value(&mut self, v: FieldValue) {
115 self.set_value(v);
116 }
117 fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context) {
124 let _ = ctx;
125 self.set_value(v);
126 }
127
128 fn draw(&mut self, ctx: &mut DrawCtx) {
129 let focused = self.group.state().state.focused;
131 if let Some(eye) = self.eye_mut() {
132 eye.state_mut().state.visible = focused;
133 }
134 self.group.draw(ctx);
135 }
136
137 fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context) {
138 self.group.handle_event(ev, ctx);
141 let revealing = self.eye_mut().map(|e| e.is_revealing()).unwrap_or(false);
145 if let Some(input) = self.input_mut() {
146 input.set_reveal(revealing);
147 }
148 }
149}
150
151#[cfg(test)]
152mod tests {
153 use super::*;
154 use crate::event::{KeyModifiers, MouseButtons, MouseEvent, MouseEventFlags, MouseWheel};
155 use crate::timer::TimerQueue;
156 use crate::view::Deferred;
157 use crate::{Event, FieldValue, Point, Rect};
158 use std::collections::VecDeque;
159
160 fn with_ctx<R>(mi: &mut MaskedInput, f: impl FnOnce(&mut MaskedInput, &mut Context) -> R) -> R {
161 let mut out: VecDeque<Event> = VecDeque::new();
162 let mut timers = TimerQueue::new();
163 let mut deferred: Vec<Deferred> = Vec::new();
164 let mut ctx = Context::new(&mut out, &mut timers, 0, &mut deferred);
165 f(mi, &mut ctx)
166 }
167
168 fn built() -> MaskedInput {
169 let mut mi = MaskedInput::new(Rect::new(0, 0, 12, 1), 64, '•', RevealEyeConfig::default());
170 mi.set_value(FieldValue::Text("pw".into()));
172 mi
173 }
174
175 #[test]
176 fn value_returns_the_real_text() {
177 let mi = built();
178 assert_eq!(mi.value(), Some(FieldValue::Text("pw".into())));
179 }
180
181 #[test]
190 fn value_round_trips_through_the_view_trait_object() {
191 let bounds = Rect::new(0, 0, 20, 5);
192 let mut host = Group::new(bounds);
193 let mi_id = host.insert(Box::new(built()));
194
195 let gathered = host.gather_data();
196 assert_eq!(
197 gathered,
198 vec![Some(FieldValue::Text("pw".into()))],
199 "gather_data must read the real text through the Box<dyn View> path"
200 );
201
202 let mut out: VecDeque<Event> = VecDeque::new();
203 let mut timers = TimerQueue::new();
204 let mut deferred: Vec<Deferred> = Vec::new();
205 let mut ctx = Context::new(&mut out, &mut timers, 0, &mut deferred);
206 host.scatter_data(&[Some(FieldValue::Text("newpw".into()))], &mut ctx);
207
208 let mi = host
209 .child_mut(mi_id)
210 .unwrap()
211 .as_any_mut()
212 .unwrap()
213 .downcast_mut::<MaskedInput>()
214 .unwrap();
215 assert_eq!(
216 mi.value(),
217 Some(FieldValue::Text("newpw".into())),
218 "scatter_data must write through the Box<dyn View> path too"
219 );
220 }
221
222 #[test]
223 fn eye_press_reveals_the_paired_input() {
224 let mut mi = built();
225 let down = Event::MouseDown(MouseEvent {
227 position: Point::new(11, 0),
228 buttons: MouseButtons {
229 left: true,
230 ..Default::default()
231 },
232 wheel: MouseWheel::None,
233 flags: MouseEventFlags::default(),
234 modifiers: KeyModifiers::default(),
235 });
236 with_ctx(&mut mi, |mi, ctx| {
237 let mut d = down;
238 mi.handle_event(&mut d, ctx);
239 });
240 assert!(mi.input_ref().reveal, "holding the eye reveals the input");
241
242 let up = Event::MouseUp(MouseEvent {
243 position: Point::new(11, 0),
244 buttons: MouseButtons {
245 left: true,
246 ..Default::default()
247 },
248 wheel: MouseWheel::None,
249 flags: MouseEventFlags::default(),
250 modifiers: KeyModifiers::default(),
251 });
252 with_ctx(&mut mi, |mi, ctx| {
253 let mut u = up;
254 mi.handle_event(&mut u, ctx);
255 });
256 assert!(!mi.input_ref().reveal, "releasing hides the input again");
257 }
258
259 #[test]
260 fn input_occupies_all_but_the_last_column() {
261 let mut mi = built();
262 let ib = mi.input_bounds();
263 assert_eq!(
264 ib,
265 Rect::new(0, 0, 11, 1),
266 "input is width-1, eye holds the last column"
267 );
268 }
269}