1use crate::data::FieldValue;
4use crate::event::Event;
5use crate::view::{Context, DrawCtx, Point, StateFlag, View, ViewId, ViewState};
6use crate::widgets::list_viewer::{self, ListViewer, ListViewerState};
7
8pub struct ListBox {
52 lv: ListViewerState,
53 items: Vec<String>,
55 source: Vec<String>,
57}
58
59impl ListBox {
60 pub fn new(
75 bounds: crate::view::Rect,
76 num_cols: i32,
77 h: Option<ViewId>,
78 v: Option<ViewId>,
79 ) -> Self {
80 ListBox {
81 lv: ListViewerState::new(bounds, num_cols, h, v),
82 items: Vec::new(),
83 source: Vec::new(),
84 }
85 }
86
87 pub fn with_find(mut self, mode: crate::widgets::list_viewer::FindMode) -> Self {
91 self.lv.find_mode = mode;
92 self
93 }
94
95 pub fn new_list(&mut self, items: Vec<String>, ctx: &mut Context) {
108 self.source = items;
109 self.rebuild_view(ctx, true);
110 }
111
112 fn rebuild_view(&mut self, ctx: &mut Context, reset_focus: bool) {
115 self.items = list_viewer::filtered_view(&self.source, self.lv.find_mode, &self.lv.query);
116 let len = self.items.len() as i32;
117 list_viewer::apply_view_len(self, len, reset_focus, ctx);
118 }
119
120 pub fn list(&self) -> &[String] {
129 &self.items
130 }
131}
132
133impl ListViewer for ListBox {
134 fn lv(&self) -> &ListViewerState {
135 &self.lv
136 }
137
138 fn lv_mut(&mut self) -> &mut ListViewerState {
139 &mut self.lv
140 }
141
142 fn get_text(&self, item: i32) -> String {
146 self.items.get(item as usize).cloned().unwrap_or_default()
147 }
148
149 fn on_query_changed(&mut self, ctx: &mut Context) {
150 if self.lv.find_mode == crate::widgets::list_viewer::FindMode::Filter {
151 self.rebuild_view(ctx, false);
152 }
153 }
154 }
157
158impl View for ListBox {
159 fn state(&self) -> &ViewState {
160 &self.lv.state
161 }
162
163 fn state_mut(&mut self) -> &mut ViewState {
164 &mut self.lv.state
165 }
166
167 fn draw(&mut self, ctx: &mut DrawCtx) {
168 list_viewer::draw(self, ctx);
169 }
170
171 fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context) {
172 list_viewer::handle_event(self, ev, ctx);
173 }
174
175 fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context) {
176 list_viewer::set_state(self, flag, enable, ctx);
177 }
178
179 fn on_bounds_changed(&mut self, ctx: &mut Context) {
181 list_viewer::on_bounds_changed(self, ctx);
182 }
183
184 fn cursor_request(&self) -> Option<Point> {
185 list_viewer::focused_cursor(self)
186 }
187
188 fn apply_scroll_sync(&mut self, h: Option<i32>, v: Option<i32>, ctx: &mut Context) {
189 list_viewer::apply_scroll(self, h, v, ctx);
190 }
191
192 fn as_any_mut(&mut self) -> Option<&mut dyn core::any::Any> {
193 Some(self)
194 }
195
196 fn value(&self) -> Option<FieldValue> {
206 Some(FieldValue::Int(self.lv.focused))
207 }
208
209 fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context) {
221 if let FieldValue::Int(idx) = v {
222 list_viewer::focus_item_num(self, idx, ctx);
223 }
224 }
225}
226
227fn ci_cmp(a: &str, b: &str) -> core::cmp::Ordering {
233 a.chars()
234 .map(|c| c.to_ascii_lowercase())
235 .cmp(b.chars().map(|c| c.to_ascii_lowercase()))
236}
237
238pub struct SortedListBox {
259 lv: ListViewerState,
260 items: Vec<String>,
262 source: Vec<String>,
264 search_pos: i32,
267 shift_state: u8,
269}
270
271impl SortedListBox {
272 pub fn new(
282 bounds: crate::view::Rect,
283 num_cols: i32,
284 h: Option<ViewId>,
285 v: Option<ViewId>,
286 ) -> Self {
287 let mut lv = ListViewerState::new(bounds, num_cols, h, v);
288 lv.state.show_cursor();
289 lv.state.set_cursor(1, 0);
290 SortedListBox {
291 lv,
292 items: Vec::new(),
293 source: Vec::new(),
294 search_pos: -1,
295 shift_state: 0,
296 }
297 }
298
299 pub fn with_find(mut self, mode: crate::widgets::list_viewer::FindMode) -> Self {
303 self.lv.find_mode = mode;
304 self
305 }
306
307 pub fn new_list(&mut self, mut items: Vec<String>, ctx: &mut Context) {
318 items.sort_by(|a, b| ci_cmp(a, b));
319 self.source = items;
320 self.search_pos = -1;
321 self.rebuild_view(ctx, true);
322 }
323
324 fn rebuild_view(&mut self, ctx: &mut Context, reset_focus: bool) {
328 self.items = list_viewer::filtered_view(&self.source, self.lv.find_mode, &self.lv.query);
329 let len = self.items.len() as i32;
330 list_viewer::apply_view_len(self, len, reset_focus, ctx);
331 }
332
333 pub fn list(&self) -> &[String] {
342 &self.items
343 }
344
345 #[cfg(test)]
347 pub(crate) fn search_pos(&self) -> i32 {
348 self.search_pos
349 }
350}
351
352impl ListViewer for SortedListBox {
353 fn lv(&self) -> &ListViewerState {
354 &self.lv
355 }
356
357 fn lv_mut(&mut self) -> &mut ListViewerState {
358 &mut self.lv
359 }
360
361 fn get_text(&self, item: i32) -> String {
363 self.items.get(item as usize).cloned().unwrap_or_default()
364 }
365
366 fn on_query_changed(&mut self, ctx: &mut Context) {
367 if self.lv.find_mode == crate::widgets::list_viewer::FindMode::Filter {
368 self.rebuild_view(ctx, false);
369 }
370 }
371 }
374
375impl list_viewer::SortedSearch for SortedListBox {
376 fn search_pos(&self) -> i32 {
377 self.search_pos
378 }
379
380 fn set_search_pos(&mut self, pos: i32) {
381 self.search_pos = pos;
382 }
383
384 fn shift_state(&self) -> u8 {
385 self.shift_state
386 }
387
388 fn set_shift_state(&mut self, s: u8) {
389 self.shift_state = s;
390 }
391
392 fn search(&self, cur: &[char]) -> i32 {
403 let key: String = cur.iter().collect();
404 let range = self.lv.range;
405 let (mut lo, mut hi) = (0i32, range);
406 while lo < hi {
407 let mid = lo + (hi - lo) / 2;
408 if ci_cmp(&self.get_text(mid), &key) == core::cmp::Ordering::Less {
409 lo = mid + 1;
410 } else {
411 hi = mid;
412 }
413 }
414 lo
415 }
416}
417
418impl View for SortedListBox {
419 fn state(&self) -> &ViewState {
420 &self.lv.state
421 }
422
423 fn state_mut(&mut self) -> &mut ViewState {
424 &mut self.lv.state
425 }
426
427 fn draw(&mut self, ctx: &mut DrawCtx) {
428 list_viewer::draw(self, ctx);
429 }
430
431 fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context) {
435 list_viewer::sorted_handle_event(self, ev, ctx);
436 }
437
438 fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context) {
439 list_viewer::set_state(self, flag, enable, ctx);
440 }
441
442 fn on_bounds_changed(&mut self, ctx: &mut Context) {
444 list_viewer::on_bounds_changed(self, ctx);
445 }
446
447 fn cursor_request(&self) -> Option<Point> {
450 list_viewer::sorted_cursor(self)
451 }
452
453 fn apply_scroll_sync(&mut self, h: Option<i32>, v: Option<i32>, ctx: &mut Context) {
454 list_viewer::apply_scroll(self, h, v, ctx);
455 }
456
457 fn as_any_mut(&mut self) -> Option<&mut dyn core::any::Any> {
458 Some(self)
459 }
460
461 fn value(&self) -> Option<FieldValue> {
469 Some(FieldValue::Int(self.lv.focused))
470 }
471
472 fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context) {
480 if let FieldValue::Int(idx) = v {
481 list_viewer::focus_item_num(self, idx, ctx);
482 }
483 }
484}
485
486#[cfg(test)]
491mod tests {
492 use super::*;
493 use crate::backend::{HeadlessBackend, Renderer};
494 use crate::event::{Key, KeyEvent, KeyModifiers};
495 use crate::screen::Buffer;
496 use crate::theme::Theme;
497 use crate::view::{Deferred, Group, Rect};
498 use crate::widgets::list_viewer::{FindMode, ListViewer};
499 use std::collections::VecDeque;
500
501 fn make_ctx<'a>(
502 out: &'a mut VecDeque<Event>,
503 timers: &'a mut crate::timer::TimerQueue,
504 deferred: &'a mut Vec<Deferred>,
505 ) -> Context<'a> {
506 Context::new(out, timers, 0, deferred)
507 }
508
509 fn key_ev(k: Key) -> Event {
510 Event::KeyDown(KeyEvent::new(k, KeyModifiers::default()))
511 }
512
513 fn render(lb: &mut ListBox, w: u16, h: u16) -> String {
515 let theme = Theme::classic_blue();
516 let (backend, screen) = HeadlessBackend::new(w, h);
517 let mut r = Renderer::new(Box::new(backend));
518 r.render(|buf: &mut Buffer| {
519 let bounds = lb.state().get_bounds();
520 let mut dc = DrawCtx::new(buf, &theme, bounds, bounds.a);
521 lb.draw(&mut dc);
522 });
523 screen.snapshot()
524 }
525
526 #[test]
529 fn ctor_empty_items_and_zeroed_fields() {
530 let lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
531 assert!(lb.lv.state.options.first_click, "ofFirstClick set");
532 assert!(lb.lv.state.options.selectable, "ofSelectable set");
533 assert_eq!(lb.lv.range, 0, "range starts at 0");
534 assert_eq!(lb.lv.focused, 0, "focused starts at 0");
535 assert_eq!(lb.lv.top_item, 0, "top_item starts at 0");
536 assert_eq!(lb.lv.indent, 0, "indent starts at 0");
537 assert_eq!(lb.lv.num_cols, 1, "num_cols == 1");
538 assert!(lb.items.is_empty(), "items starts empty");
539 }
540
541 #[test]
544 fn new_list_sets_range_and_queues_vbar_params() {
545 let mut mint_group = Group::new(Rect::new(0, 0, 4, 4));
547 let sentinel =
548 mint_group.insert(Box::new(ListBox::new(Rect::new(0, 0, 1, 1), 1, None, None)));
549
550 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, Some(sentinel));
551 let mut out = VecDeque::new();
552 let mut timers = crate::timer::TimerQueue::new();
553 let mut deferred: Vec<Deferred> = vec![];
554 {
555 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
556 lb.new_list(
557 vec!["alpha".into(), "beta".into(), "gamma".into()],
558 &mut ctx,
559 );
560 }
561 assert_eq!(lb.lv.range, 3, "range == N after new_list");
562 assert_eq!(lb.lv.focused, 0, "focus_item(0) called");
563 assert_eq!(
566 deferred.len(),
567 2,
568 "set_range + focus_item each queue one op"
569 );
570 assert!(matches!(
571 deferred[0],
572 Deferred::ScrollBarSetParams {
573 id,
574 value: Some(0),
575 min: Some(0),
576 max: Some(2),
577 page_step: None,
578 arrow_step: None,
579 } if id == sentinel
580 ));
581 assert!(matches!(
582 deferred[1],
583 Deferred::ScrollBarSetParams {
584 id,
585 value: Some(0),
586 min: None,
587 max: None,
588 page_step: None,
589 arrow_step: None,
590 } if id == sentinel
591 ));
592 }
593
594 #[test]
595 fn new_list_empty_skips_focus_item() {
596 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
597 let mut out = VecDeque::new();
598 let mut timers = crate::timer::TimerQueue::new();
599 let mut deferred: Vec<Deferred> = vec![];
600 {
601 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
602 lb.new_list(vec![], &mut ctx);
603 }
604 assert_eq!(lb.lv.range, 0, "range == 0 for empty list");
605 assert!(deferred.is_empty(), "empty list queues nothing");
607 }
608
609 #[test]
610 fn new_list_replaces_previous_items() {
611 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
612 let mut out = VecDeque::new();
613 let mut timers = crate::timer::TimerQueue::new();
614 let mut deferred: Vec<Deferred> = vec![];
615 {
616 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
617 lb.new_list(vec!["first".into()], &mut ctx);
618 }
619 deferred.clear();
620 {
621 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
622 lb.new_list(vec!["second".into(), "third".into()], &mut ctx);
623 }
624 assert_eq!(lb.items.len(), 2, "old items replaced");
625 assert_eq!(lb.items[0], "second");
626 assert_eq!(lb.items[1], "third");
627 assert!(
628 lb.items.iter().all(|s| s != "first"),
629 "old item 'first' is gone"
630 );
631 }
632
633 #[test]
636 fn get_text_returns_item_or_empty_for_oob() {
637 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
638 let mut out = VecDeque::new();
639 let mut timers = crate::timer::TimerQueue::new();
640 let mut deferred: Vec<Deferred> = vec![];
641 {
642 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
643 lb.new_list(vec!["alpha".into(), "beta".into()], &mut ctx);
644 }
645 let text0 = lb.get_text(0);
647 assert_eq!(text0, "alpha");
648 assert_ne!(
649 text0, "",
650 "in-range item is not empty (bite: distinguishes from OOB)"
651 );
652
653 let text1 = lb.get_text(1);
654 assert_eq!(text1, "beta");
655
656 assert_eq!(lb.get_text(2), "");
658 assert_eq!(lb.get_text(99), "");
659 assert_eq!(lb.get_text(-1_i32), "");
660 }
661
662 #[test]
665 fn value_reflects_focused_item() {
666 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
667 let mut out = VecDeque::new();
668 let mut timers = crate::timer::TimerQueue::new();
669 let mut deferred: Vec<Deferred> = vec![];
670 {
671 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
672 lb.new_list(
673 vec!["a".into(), "b".into(), "c".into(), "d".into(), "e".into()],
674 &mut ctx,
675 );
676 }
677 assert_eq!(lb.value(), Some(FieldValue::Int(0)), "initial focused == 0");
679
680 deferred.clear();
682 let mut ev = key_ev(Key::Down);
683 {
684 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
685 lb.handle_event(&mut ev, &mut ctx);
686 }
687 let mut ev = key_ev(Key::Down);
688 {
689 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
690 lb.handle_event(&mut ev, &mut ctx);
691 }
692 assert_eq!(lb.lv.focused, 2, "focus moved to 2");
693 assert_eq!(
695 lb.value(),
696 Some(FieldValue::Int(2)),
697 "value() reflects focused == 2 (not the initial 0)"
698 );
699 }
700
701 #[test]
704 fn snapshot_active_focused_list_box() {
705 let mut lb = ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None);
706 lb.lv.state.state.selected = true;
707 lb.lv.state.state.active = true;
708 lb.lv.state.state.focused = true;
709 lb.items = vec![
711 "apple".into(),
712 "banana".into(),
713 "cherry".into(),
714 "date".into(),
715 ];
716 lb.lv.range = 4;
717 lb.lv.focused = 1;
718 insta::assert_snapshot!(render(&mut lb, 14, 5));
719 }
720
721 #[test]
724 fn handle_event_wired_down_moves_focused() {
725 let mut lb = ListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
726 lb.items = vec!["x".into(), "y".into(), "z".into()];
727 lb.lv.range = 3;
728 let mut out = VecDeque::new();
729 let mut timers = crate::timer::TimerQueue::new();
730 let mut deferred: Vec<Deferred> = vec![];
731
732 let mut ev = key_ev(Key::Down);
733 {
734 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
735 lb.handle_event(&mut ev, &mut ctx);
736 }
737 assert_eq!(lb.lv.focused, 1, "KeyDown(Down) wired: focused moves to 1");
738 assert!(ev.is_nothing(), "Down consumed");
739 }
740
741 #[test]
742 fn broadcast_from_own_vbar_queues_sync_list_viewer() {
743 let mut group = Group::new(Rect::new(0, 0, 30, 20));
745
746 let mut vbar_group = Group::new(Rect::new(0, 0, 4, 4));
748 let v_id = vbar_group.insert(Box::new(ListBox::new(Rect::new(0, 0, 1, 1), 1, None, None)));
749
750 let lb_id = group.insert(Box::new(ListBox::new(
751 Rect::new(0, 0, 20, 8),
752 1,
753 None,
754 Some(v_id),
755 )));
756
757 let mut out = VecDeque::new();
758 let mut timers = crate::timer::TimerQueue::new();
759 let mut deferred: Vec<Deferred> = vec![];
760
761 let mut ev = Event::Broadcast {
763 command: crate::command::Command::SCROLL_BAR_CHANGED,
764 source: Some(v_id),
765 };
766 {
767 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
768 group
769 .find_mut(lb_id)
770 .unwrap()
771 .handle_event(&mut ev, &mut ctx);
772 }
773 assert_eq!(deferred.len(), 1, "one ScrollSync op queued");
774 assert!(
775 matches!(
776 deferred[0],
777 Deferred::ScrollSync {
778 target,
779 h: None,
780 v: Some(vid),
781 } if target == lb_id && vid == v_id
782 ),
783 "ScrollSync carries correct target and v-bar ids"
784 );
785 }
786
787 fn make_sorted_lb(
794 items: Vec<&str>,
795 ) -> (
796 SortedListBox,
797 VecDeque<Event>,
798 crate::timer::TimerQueue,
799 Vec<Deferred>,
800 ) {
801 let mut slb = SortedListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
802 let mut out = VecDeque::new();
803 let mut timers = crate::timer::TimerQueue::new();
804 let mut deferred: Vec<Deferred> = vec![];
805 {
806 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
807 slb.new_list(items.into_iter().map(|s| s.into()).collect(), &mut ctx);
808 }
809 deferred.clear();
810 (slb, out, timers, deferred)
811 }
812
813 #[test]
816 fn sorted_lb_type_to_jump_b_then_br() {
817 use crate::widgets::list_viewer::ListViewer;
818 let (mut slb, mut out, mut timers, mut deferred) =
819 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
820 let mut ev = key_ev(Key::Char('b'));
825 {
826 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
827 slb.handle_event(&mut ev, &mut ctx);
828 }
829 assert_eq!(slb.lv().focused, 1, "'b' -> focused == 1 (\"beta\")");
830 assert_eq!(slb.search_pos(), 0, "search_pos == 0 after first char");
831 assert!(ev.is_nothing(), "'b' consumed (alpha match found)");
832
833 deferred.clear();
834
835 let mut ev = key_ev(Key::Char('r'));
837 {
838 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
839 slb.handle_event(&mut ev, &mut ctx);
840 }
841 assert_eq!(slb.lv().focused, 2, "'br' -> focused == 2 (\"bravo\")");
842 assert_eq!(slb.search_pos(), 1, "search_pos == 1 after second char");
843 assert!(ev.is_nothing(), "'r' consumed");
844 }
845
846 #[test]
849 fn sorted_lb_backspace_shortens_search() {
850 use crate::widgets::list_viewer::ListViewer;
851 let (mut slb, mut out, mut timers, mut deferred) =
852 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
853
854 for ch in ['b', 'r'] {
856 let mut ev = key_ev(Key::Char(ch));
857 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
858 slb.handle_event(&mut ev, &mut ctx);
859 deferred.clear();
860 }
861 assert_eq!(slb.lv().focused, 2, "pre: focused == 2 (\"bravo\")");
862 assert_eq!(slb.search_pos(), 1, "pre: search_pos == 1");
863
864 let mut ev = key_ev(Key::Backspace);
870 {
871 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
872 slb.handle_event(&mut ev, &mut ctx);
873 }
874 assert_eq!(slb.search_pos(), 0, "search_pos decremented to 0");
875 assert_eq!(slb.lv().focused, 1, "backspace re-focuses to \"beta\"");
877 }
878
879 #[test]
882 fn sorted_lb_dot_jumps_to_extension() {
883 use crate::widgets::list_viewer::ListViewer;
884 let (mut slb, mut out, mut timers, mut deferred) =
891 make_sorted_lb(vec!["file.txt", "file.bak", "zebra"]);
892 assert_eq!(slb.get_text(0), "file.bak");
894 assert_eq!(slb.get_text(1), "file.txt");
895 assert_eq!(slb.lv().focused, 0, "starts at 0 (\"file.bak\")");
896
897 for (ch, want_focus) in [('f', 0), ('i', 0), ('l', 0), ('e', 0)] {
901 let mut ev = key_ev(Key::Char(ch));
902 {
903 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
904 slb.handle_event(&mut ev, &mut ctx);
905 }
906 assert_eq!(
907 slb.lv().focused,
908 want_focus,
909 "typing '{ch}' keeps focus on \"file.bak\" (shared prefix)"
910 );
911 deferred.clear();
912 }
913 assert_eq!(slb.search_pos(), 3, "search_pos == 3 after \"file\"");
914
915 let mut ev = key_ev(Key::Down);
917 {
918 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
919 slb.handle_event(&mut ev, &mut ctx);
920 }
921 assert_eq!(slb.lv().focused, 1, "Down -> focus \"file.txt\"");
922 assert_eq!(slb.search_pos(), -1, "arrow nav reset search_pos");
923 deferred.clear();
924
925 let mut ev = key_ev(Key::Char('.'));
930 {
931 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
932 slb.handle_event(&mut ev, &mut ctx);
933 }
934 assert_eq!(
935 slb.search_pos(),
936 4,
937 "dot sets search_pos to the '.' position"
938 );
939 assert_eq!(
940 slb.lv().focused,
941 1,
942 "dot must NOT mis-jump to \"file.bak\"; stays on \"file.txt\""
943 );
944 }
945
946 #[test]
949 fn sorted_lb_no_match_alpha_consumes_but_reverts() {
950 use crate::widgets::list_viewer::ListViewer;
951 let (mut slb, mut out, mut timers, mut deferred) =
952 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
953
954 let mut ev = key_ev(Key::Char('z'));
958 {
959 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
960 slb.handle_event(&mut ev, &mut ctx);
961 }
962 assert_eq!(slb.lv().focused, 0, "no match: focus unchanged");
963 assert_eq!(slb.search_pos(), -1, "no match: search_pos reverted to -1");
964 assert!(ev.is_nothing(), "alpha key consumed even on no-match");
965 }
966
967 #[test]
970 fn sorted_lb_no_match_punctuation_passes_through() {
971 use crate::widgets::list_viewer::ListViewer;
972 let (mut slb, mut out, mut timers, mut deferred) =
975 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
976
977 let mut ev = key_ev(Key::Char('.'));
981 {
982 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
983 slb.handle_event(&mut ev, &mut ctx);
984 }
985 assert_eq!(slb.lv().focused, 0, "focus unchanged");
986 assert_eq!(slb.search_pos(), -1, "search_pos stays -1");
987 assert!(!ev.is_nothing(), "non-alpha no-match: event NOT consumed");
988 }
989
990 #[test]
993 fn sorted_lb_arrow_nav_resets_search_pos() {
994 let (mut slb, mut out, mut timers, mut deferred) =
995 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
996
997 let mut ev = key_ev(Key::Char('b'));
999 {
1000 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1001 slb.handle_event(&mut ev, &mut ctx);
1002 }
1003 assert_eq!(slb.search_pos(), 0, "pre: search_pos == 0");
1004 deferred.clear();
1005
1006 let mut ev = key_ev(Key::Down);
1009 {
1010 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1011 slb.handle_event(&mut ev, &mut ctx);
1012 }
1013 assert_eq!(slb.search_pos(), -1, "arrow nav resets search_pos to -1");
1014 }
1015
1016 #[test]
1019 fn sorted_lb_released_focus_resets_search_pos() {
1020 let (mut slb, mut out, mut timers, mut deferred) =
1021 make_sorted_lb(vec!["alpha", "beta", "bravo", "charlie"]);
1022
1023 let mut ev = key_ev(Key::Char('b'));
1025 {
1026 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1027 slb.handle_event(&mut ev, &mut ctx);
1028 }
1029 assert_eq!(slb.search_pos(), 0, "pre: search_pos == 0");
1030 deferred.clear();
1031
1032 let mut ev = Event::Broadcast {
1034 command: crate::command::Command::RELEASED_FOCUS,
1035 source: None,
1036 };
1037 {
1038 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1039 slb.handle_event(&mut ev, &mut ctx);
1040 }
1041 assert_eq!(slb.search_pos(), -1, "cmReleasedFocus resets search_pos");
1042 }
1043
1044 #[test]
1047 fn sorted_lb_set_value_ctx_focuses_the_item() {
1048 let mut mint_group = Group::new(Rect::new(0, 0, 4, 4));
1051 let sentinel =
1052 mint_group.insert(Box::new(ListBox::new(Rect::new(0, 0, 1, 1), 1, None, None)));
1053
1054 let mut slb = SortedListBox::new(Rect::new(0, 0, 20, 8), 1, None, Some(sentinel));
1055 let mut out = VecDeque::new();
1056 let mut timers = crate::timer::TimerQueue::new();
1057 let mut deferred: Vec<Deferred> = vec![];
1058 {
1059 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1060 slb.new_list(
1062 vec!["alpha".into(), "beta".into(), "charlie".into()],
1063 &mut ctx,
1064 );
1065 }
1066 assert_eq!(slb.value(), Some(FieldValue::Int(0)), "initial gather == 0");
1068
1069 deferred.clear();
1070
1071 {
1073 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1074 slb.set_value_ctx(FieldValue::Int(2), &mut ctx);
1075 }
1076
1077 assert_eq!(
1079 slb.value(),
1080 Some(FieldValue::Int(2)),
1081 "after scatter(2) gather returns 2"
1082 );
1083
1084 assert!(
1086 deferred.iter().any(|d| matches!(
1087 d,
1088 Deferred::ScrollBarSetParams { id, value: Some(_), .. } if *id == sentinel
1089 )),
1090 "scatter queued a ScrollBarSetParams deferral for the v-bar"
1091 );
1092 }
1093
1094 #[test]
1097 fn sorted_lb_new_list_sorts_and_resets() {
1098 use crate::widgets::list_viewer::ListViewer;
1099 let mut slb = SortedListBox::new(Rect::new(0, 0, 20, 8), 1, None, None);
1100 let mut out = VecDeque::new();
1101 let mut timers = crate::timer::TimerQueue::new();
1102 let mut deferred: Vec<Deferred> = vec![];
1103 {
1105 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1106 slb.new_list(
1107 vec!["Zebra".into(), "apple".into(), "Banana".into()],
1108 &mut ctx,
1109 );
1110 }
1111 assert_eq!(slb.get_text(0), "apple", "sorted: apple first");
1113 assert_eq!(slb.get_text(1), "Banana", "sorted: Banana second");
1114 assert_eq!(slb.get_text(2), "Zebra", "sorted: Zebra third");
1115 assert_eq!(slb.search_pos(), -1, "new_list resets search_pos");
1116 }
1117
1118 #[test]
1121 fn set_value_ctx_focuses_the_item() {
1122 let mut out = VecDeque::new();
1123 let mut timers = crate::timer::TimerQueue::new();
1124 let mut deferred = Vec::new();
1125 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1126
1127 let mut lb = ListBox::new(Rect::new(0, 0, 10, 5), 1, None, None);
1128 lb.new_list(
1129 vec!["a".to_string(), "b".to_string(), "c".to_string()],
1130 &mut ctx,
1131 );
1132
1133 lb.set_value_ctx(FieldValue::Int(2), &mut ctx);
1135
1136 assert_eq!(lb.value(), Some(FieldValue::Int(2)));
1138 }
1139
1140 #[test]
1141 fn set_value_ctx_ignores_non_int_variant() {
1142 let mut out = VecDeque::new();
1143 let mut timers = crate::timer::TimerQueue::new();
1144 let mut deferred = Vec::new();
1145 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1146
1147 let mut lb = ListBox::new(Rect::new(0, 0, 10, 5), 1, None, None);
1148 lb.new_list(vec!["a".to_string(), "b".to_string()], &mut ctx);
1149 lb.set_value_ctx(FieldValue::Int(1), &mut ctx);
1151 assert_eq!(lb.value(), Some(FieldValue::Int(1)));
1152
1153 lb.set_value_ctx(FieldValue::Text("ignored".to_string()), &mut ctx);
1155 assert_eq!(
1156 lb.value(),
1157 Some(FieldValue::Int(1)),
1158 "focus unchanged after Text variant"
1159 );
1160 }
1161
1162 #[test]
1165 fn list_box_self_filter_narrows_and_restores() {
1166 let mut out = VecDeque::new();
1167 let mut timers = crate::timer::TimerQueue::new();
1168 let mut deferred = vec![];
1169 let mut lb =
1170 ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1171 {
1172 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1173 lb.new_list(
1174 vec![
1175 "apple".into(),
1176 "banana".into(),
1177 "grape".into(),
1178 "orange".into(),
1179 ],
1180 &mut ctx,
1181 );
1182 }
1183 assert_eq!(lb.lv.range, 4, "empty query shows the full source");
1184
1185 lb.lv.query = "an".into();
1186 {
1187 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1188 lb.on_query_changed(&mut ctx);
1189 }
1190 assert_eq!(lb.lv.range, 2, "only rows containing 'an' survive");
1191 assert_eq!(lb.get_text(0), "banana");
1192 assert_eq!(lb.get_text(1), "orange", "insertion order preserved");
1193
1194 lb.lv.query.clear();
1195 {
1196 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1197 lb.on_query_changed(&mut ctx);
1198 }
1199 assert_eq!(
1200 lb.lv.range, 4,
1201 "clearing the query restores the full source"
1202 );
1203 assert_eq!(lb.get_text(0), "apple");
1204 }
1205
1206 #[test]
1207 fn sorted_list_box_self_filter_keeps_sorted_order() {
1208 let mut out = VecDeque::new();
1209 let mut timers = crate::timer::TimerQueue::new();
1210 let mut deferred = vec![];
1211 let mut slb =
1212 SortedListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1213 {
1214 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1215 slb.new_list(
1216 vec![
1217 "orange".into(),
1218 "apple".into(),
1219 "banana".into(),
1220 "grape".into(),
1221 ],
1222 &mut ctx,
1223 );
1224 }
1225 assert_eq!(slb.get_text(0), "apple");
1227 assert_eq!(slb.lv.range, 4);
1228
1229 slb.lv.query = "an".into();
1230 {
1231 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1232 slb.on_query_changed(&mut ctx);
1233 }
1234 assert_eq!(slb.lv.range, 2);
1236 assert_eq!(slb.get_text(0), "banana");
1237 assert_eq!(slb.get_text(1), "orange");
1238
1239 slb.lv.query.clear();
1240 {
1241 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1242 slb.on_query_changed(&mut ctx);
1243 }
1244 assert_eq!(slb.lv.range, 4, "clearing restores the full sorted source");
1245 }
1246
1247 #[test]
1248 fn list_box_self_filter_clamps_focus() {
1249 let mut out = VecDeque::new();
1250 let mut timers = crate::timer::TimerQueue::new();
1251 let mut deferred = vec![];
1252 let mut lb =
1253 ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1254 {
1255 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1256 lb.new_list(
1257 vec![
1258 "apple".into(),
1259 "banana".into(),
1260 "grape".into(),
1261 "orange".into(),
1262 ],
1263 &mut ctx,
1264 );
1265 }
1266 lb.lv.focused = 3;
1267 lb.lv.query = "an".into();
1268 {
1269 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1270 lb.on_query_changed(&mut ctx);
1271 }
1272 assert!(lb.lv.focused <= 1, "focus clamped into the narrowed range");
1273 }
1274
1275 #[test]
1276 fn set_find_query_narrows_like_typed_query() {
1277 let mut out = VecDeque::new();
1278 let mut timers = crate::timer::TimerQueue::new();
1279 let mut deferred = vec![];
1280 let mut lb =
1281 ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1282 {
1283 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1284 lb.new_list(
1285 vec![
1286 "apple".into(),
1287 "banana".into(),
1288 "grape".into(),
1289 "orange".into(),
1290 ],
1291 &mut ctx,
1292 );
1293 }
1294 {
1295 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1296 lb.set_find_query("an", &mut ctx);
1297 }
1298 assert_eq!(
1299 lb.lv.range, 2,
1300 "set_find_query narrows via on_query_changed"
1301 );
1302 assert_eq!(lb.get_text(0), "banana");
1303 assert_eq!(lb.get_text(1), "orange", "insertion order preserved");
1304
1305 {
1306 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1307 lb.set_find_query("", &mut ctx);
1308 }
1309 assert_eq!(
1310 lb.lv.range, 4,
1311 "empty set_find_query restores the full source"
1312 );
1313 assert_eq!(lb.get_text(0), "apple");
1314 }
1315
1316 #[test]
1317 fn typed_and_set_find_query_reach_identical_state() {
1318 let src: Vec<String> = vec![
1319 "apple".into(),
1320 "banana".into(),
1321 "grape".into(),
1322 "orange".into(),
1323 ];
1324
1325 let mut out_a = VecDeque::new();
1327 let mut timers_a = crate::timer::TimerQueue::new();
1328 let mut deferred_a = vec![];
1329 let mut lb_a =
1330 ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1331 {
1332 let mut ctx = make_ctx(&mut out_a, &mut timers_a, &mut deferred_a);
1333 lb_a.new_list(src.clone(), &mut ctx);
1334 }
1335 for c in ['a', 'n'] {
1336 let mut ev = key_ev(Key::Char(c));
1337 let mut ctx = make_ctx(&mut out_a, &mut timers_a, &mut deferred_a);
1338 lb_a.handle_event(&mut ev, &mut ctx);
1339 }
1340
1341 let mut out_b = VecDeque::new();
1343 let mut timers_b = crate::timer::TimerQueue::new();
1344 let mut deferred_b = vec![];
1345 let mut lb_b =
1346 ListBox::new(Rect::new(0, 0, 14, 5), 1, None, None).with_find(FindMode::Filter);
1347 {
1348 let mut ctx = make_ctx(&mut out_b, &mut timers_b, &mut deferred_b);
1349 lb_b.new_list(src.clone(), &mut ctx);
1350 }
1351 {
1352 let mut ctx = make_ctx(&mut out_b, &mut timers_b, &mut deferred_b);
1353 lb_b.set_find_query("an", &mut ctx);
1354 }
1355
1356 assert_eq!(lb_a.find_query(), lb_b.find_query(), "same find_query()");
1358 assert_eq!(lb_a.lv.query, lb_b.lv.query, "same raw query");
1359 assert_eq!(lb_a.lv.range, lb_b.lv.range, "same narrowed range");
1360 let rows_a: Vec<String> = (0..lb_a.lv.range).map(|i| lb_a.get_text(i)).collect();
1361 let rows_b: Vec<String> = (0..lb_b.lv.range).map(|i| lb_b.get_text(i)).collect();
1362 assert_eq!(rows_a, rows_b, "same visible rows");
1363 }
1364}