1use crate::capture::TrackMask;
79use crate::command::Command;
80use crate::event::{Event, Key, KeyEvent, ctrl_to_arrow};
81use crate::theme::{Role, SurfaceRoles};
82use crate::view::{Context, DrawCtx, Point, StateFlag, View, ViewId, ViewState};
83
84const EMPTY_TEXT: &str = "<empty>";
86
87const MOUSE_AUTOS_TO_SKIP: i32 = 4;
90
91#[derive(Clone, Copy, Debug)]
93pub(crate) struct LvTrack {
94 count: i32,
97 old_item: i32,
100}
101
102#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum FindMode {
117 Off,
119 Highlight,
121 Filter,
123}
124
125pub struct ListViewerState {
136 pub state: ViewState,
138 pub num_cols: i32,
145 pub top_item: i32,
151 pub focused: i32,
157 pub range: i32,
164 pub indent: i32,
168 pub h_scroll_bar: Option<ViewId>,
176 pub v_scroll_bar: Option<ViewId>,
182 pub(crate) abs_origin: Point,
186 pub(crate) track: Option<LvTrack>,
190 pub find_mode: FindMode,
193 pub query: String,
195}
196
197impl ListViewerState {
198 pub fn new(
210 bounds: crate::view::Rect,
211 num_cols: i32,
212 h_scroll_bar: Option<ViewId>,
213 v_scroll_bar: Option<ViewId>,
214 ) -> Self {
215 debug_assert!(
216 num_cols >= 1,
217 "ListViewer num_cols must be >= 1 (size.x / num_cols and col_width math \
218 divide by it); clamping to 1"
219 );
220 let num_cols = num_cols.max(1);
221 let mut state = ViewState::new(bounds);
222 state.options.first_click = true;
223 state.options.selectable = true;
224 ListViewerState {
225 state,
226 num_cols,
227 top_item: 0,
228 focused: 0,
229 range: 0,
230 indent: 0,
231 h_scroll_bar,
232 v_scroll_bar,
233 abs_origin: Point::new(0, 0),
234 track: None,
235 find_mode: FindMode::Off,
236 query: String::new(),
237 }
238 }
239}
240
241#[derive(Clone, Copy, Debug, PartialEq, Eq)]
254pub struct ListRoles {
255 pub normal: Role,
258 pub inactive: Role,
260 pub surface: Role,
263 pub focused: Role,
265 pub selected: Role,
267 pub divider: Role,
269}
270
271impl ListRoles {
272 pub const LIST_VIEWER: ListRoles = ListRoles {
274 normal: Role::ListNormal,
275 inactive: Role::ListInactive,
276 surface: Role::ListSurface,
277 focused: Role::ListFocused,
278 selected: Role::ListSelected,
279 divider: Role::ListDivider,
280 };
281}
282
283pub trait ListViewer: View {
311 fn lv(&self) -> &ListViewerState;
313 fn lv_mut(&mut self) -> &mut ListViewerState;
315
316 fn get_text(&self, _item: i32) -> String {
319 String::new()
320 }
321
322 fn list_roles(&self) -> ListRoles {
329 ListRoles::LIST_VIEWER
330 }
331
332 fn is_selected(&self, item: i32) -> bool {
337 item == self.lv().focused
338 }
339
340 fn item_role(&self, _item: i32) -> Option<Role> {
347 None
348 }
349
350 fn select_item(&mut self, _item: i32, ctx: &mut Context) {
358 let source = self.lv().state.id();
359 ctx.broadcast(Command::LIST_ITEM_SELECTED, source);
360 }
361
362 fn on_focus_changed(&mut self, _ctx: &mut Context) {}
368
369 fn find_query(&self) -> Option<&str> {
373 let lv = self.lv();
374 if lv.find_mode == FindMode::Off || lv.query.is_empty() {
375 None
376 } else {
377 Some(&lv.query)
378 }
379 }
380
381 fn set_find_query(&mut self, query: &str, ctx: &mut Context) {
392 if self.lv().find_mode == FindMode::Off || self.lv().query == query {
393 return;
394 }
395 self.lv_mut().query = query.to_string();
396 find_notify(self, ctx);
397 }
398
399 fn clear_find(&mut self, ctx: &mut Context) {
403 self.set_find_query("", ctx);
404 }
405
406 fn on_query_changed(&mut self, _ctx: &mut Context) {}
411}
412
413pub fn focus_item_num<L: ListViewer + ?Sized>(this: &mut L, mut item: i32, ctx: &mut Context) {
423 if item < 0 {
424 item = 0;
425 } else if item >= this.lv().range && this.lv().range > 0 {
426 item = this.lv().range - 1;
427 }
428 if this.lv().range != 0 {
429 focus_item(this, item, ctx);
430 }
431}
432
433pub fn focus_item<L: ListViewer + ?Sized>(this: &mut L, item: i32, ctx: &mut Context) {
440 this.lv_mut().focused = item;
441 if let Some(v) = this.lv().v_scroll_bar {
442 ctx.request_scroll_bar_params(v, Some(item), None, None, None, None);
446 }
447
448 let size_y = this.lv().state.size.y;
449 let num_cols = this.lv().num_cols;
450 let top_item = this.lv().top_item;
451 if size_y > 0 {
452 if item < top_item {
453 this.lv_mut().top_item = if num_cols == 1 {
454 item
455 } else {
456 item - item % size_y
457 };
458 } else if item >= top_item + size_y * num_cols {
459 this.lv_mut().top_item = if num_cols == 1 {
460 item - size_y + 1
461 } else {
462 item - item % size_y - (size_y * (num_cols - 1))
463 };
464 }
465 }
466
467 this.on_focus_changed(ctx);
470}
471
472pub fn set_range<L: ListViewer + ?Sized>(this: &mut L, a_range: i32, ctx: &mut Context) {
479 this.lv_mut().range = a_range;
480 if this.lv().focused >= a_range {
481 this.lv_mut().focused = 0;
482 }
483 let focused = this.lv().focused;
484 if let Some(v) = this.lv().v_scroll_bar {
485 ctx.request_scroll_bar_params(v, Some(focused), Some(0), Some(a_range - 1), None, None);
486 }
487}
488
489pub(crate) fn filtered_view(source: &[String], mode: FindMode, query: &str) -> Vec<String> {
493 if mode == FindMode::Filter && !query.is_empty() {
494 source
495 .iter()
496 .filter(|s| find_match(s, query).is_some())
497 .cloned()
498 .collect()
499 } else {
500 source.to_vec()
501 }
502}
503
504pub(crate) fn apply_view_len<L: ListViewer + ?Sized>(
508 this: &mut L,
509 len: i32,
510 reset_focus: bool,
511 ctx: &mut Context,
512) {
513 set_range(this, len, ctx);
514 if reset_focus {
515 if len > 0 {
516 focus_item(this, 0, ctx);
517 }
518 } else {
519 let f = this.lv().focused.min(len - 1).max(0);
520 focus_item_num(this, f, ctx);
521 }
522}
523
524pub fn apply_scroll<L: ListViewer + ?Sized>(
532 this: &mut L,
533 h: Option<i32>,
534 v: Option<i32>,
535 ctx: &mut Context,
536) {
537 if let Some(hv) = h {
538 this.lv_mut().indent = hv;
539 }
540 if let Some(vv) = v {
541 focus_item_num(this, vv, ctx);
542 }
543}
544
545pub fn update_steps<L: ListViewer + ?Sized>(this: &L, ctx: &mut Context) {
560 let size = this.lv().state.size;
561 let num_cols = this.lv().num_cols;
562 if let Some(v) = this.lv().v_scroll_bar {
563 let (pg_step, ar_step) = if num_cols == 1 {
564 (size.y - 1, 1)
565 } else {
566 (size.y * num_cols, size.y)
567 };
568 ctx.request_scroll_bar_params(v, None, None, None, Some(pg_step), Some(ar_step));
569 }
570 if let Some(h) = this.lv().h_scroll_bar {
571 ctx.request_scroll_bar_params(h, None, None, None, Some(size.x / num_cols), Some(1));
572 }
573}
574
575pub fn on_bounds_changed<L: ListViewer + ?Sized>(this: &L, ctx: &mut Context) {
586 let lv = this.lv();
587 let size = lv.state.size;
588 let num_cols = lv.num_cols.max(1);
589 if let Some(v) = lv.v_scroll_bar {
590 ctx.request_scroll_bar_params(
591 v,
592 None, None, None, Some(size.y), None, );
598 }
599 if let Some(h) = lv.h_scroll_bar {
600 ctx.request_scroll_bar_params(
601 h,
602 None, None, None, Some(size.x / num_cols), None, );
608 }
609}
610
611pub fn set_state<L: ListViewer + ?Sized>(
620 this: &mut L,
621 flag: StateFlag,
622 enable: bool,
623 ctx: &mut Context,
624) {
625 this.lv_mut().state.set_flag(flag, enable);
626 if flag == StateFlag::Focused {
627 let source = this.lv().state.id();
628 ctx.broadcast(
629 if enable {
630 Command::RECEIVED_FOCUS
631 } else {
632 Command::RELEASED_FOCUS
633 },
634 source,
635 );
636 }
637 if flag == StateFlag::Active || flag == StateFlag::Selected || flag == StateFlag::Visible {
638 let visible = this.lv().state.state.active && this.lv().state.state.visible;
640 if let Some(h) = this.lv().h_scroll_bar {
641 ctx.request_set_visible(h, visible);
642 }
643 if let Some(v) = this.lv().v_scroll_bar {
644 ctx.request_set_visible(v, visible);
645 }
646 }
647}
648
649fn find_route_key<L: ListViewer + ?Sized>(
655 this: &mut L,
656 ke: KeyEvent,
657 ev: &mut Event,
658 ctx: &mut Context,
659) -> bool {
660 match ke.key {
661 Key::Char(c) if !ke.modifiers.ctrl && !ke.modifiers.alt => {
662 this.lv_mut().query.push(c);
663 find_after_change(this, ev, ctx);
664 true
665 }
666 Key::Backspace => {
667 if this.lv().query.is_empty() {
668 return false;
669 }
670 this.lv_mut().query.pop();
671 find_after_change(this, ev, ctx);
672 true
673 }
674 Key::Esc => {
675 if this.lv().query.is_empty() {
676 return false;
677 }
678 this.lv_mut().query.clear();
679 find_after_change(this, ev, ctx);
680 true
681 }
682 _ => false,
683 }
684}
685
686fn find_notify<L: ListViewer + ?Sized>(this: &mut L, ctx: &mut Context) {
692 let source = this.lv().state.id();
693 ctx.broadcast(Command::LIST_FIND_CHANGED, source);
694 this.on_query_changed(ctx);
695}
696
697fn find_after_change<L: ListViewer + ?Sized>(this: &mut L, ev: &mut Event, ctx: &mut Context) {
699 find_notify(this, ctx);
700 ev.clear();
701}
702
703pub fn handle_event<L: ListViewer + ?Sized>(this: &mut L, ev: &mut Event, ctx: &mut Context) {
712 match *ev {
713 Event::MouseDown(me) => {
726 let size = this.lv().state.size;
727 let num_cols = this.lv().num_cols;
728 let col_width = size.x / num_cols + 1;
729 let top_item = this.lv().top_item;
730 let mouse = me.position;
732 let new_item = mouse.y + size.y * (mouse.x / col_width) + top_item;
733 focus_item_num(this, new_item, ctx);
734 if me.flags.double_click {
735 if this.lv().range > new_item {
738 this.select_item(new_item, ctx);
739 }
740 } else if let Some(id) = this.lv().state.id() {
741 let abs_origin = this.lv().abs_origin;
746 this.lv_mut().track = Some(LvTrack {
747 count: 0,
748 old_item: new_item,
749 });
750 ctx.start_mouse_track(
751 id,
752 abs_origin,
753 TrackMask {
754 mouse_move: true,
755 mouse_auto: true,
756 ..Default::default()
757 },
758 );
759 } else {
760 }
765 ev.clear();
766 }
767
768 Event::MouseMove(me) if this.lv().track.is_some() => {
776 let size = this.lv().state.size;
777 let num_cols = this.lv().num_cols;
778 let col_width = size.x / num_cols + 1;
779 let top_item = this.lv().top_item;
780 let mouse = me.position;
781 let in_view = mouse.x >= 0 && mouse.y >= 0 && mouse.x < size.x && mouse.y < size.y;
783 if in_view {
784 let new_item = mouse.y + size.y * (mouse.x / col_width) + top_item;
785 let old_item = this.lv().track.map(|t| t.old_item).unwrap_or(new_item);
786 if new_item != old_item {
787 focus_item_num(this, new_item, ctx);
788 }
789 if let Some(t) = this.lv_mut().track.as_mut() {
790 t.old_item = new_item;
791 }
792 }
793 ev.clear();
796 }
797
798 Event::MouseAuto(me) if this.lv().track.is_some() => {
807 let size = this.lv().state.size;
808 let num_cols = this.lv().num_cols;
809 let col_width = size.x / num_cols + 1;
810 let top_item = this.lv().top_item;
811 let focused = this.lv().focused;
812 let mouse = me.position;
813 let in_view = mouse.x >= 0 && mouse.y >= 0 && mouse.x < size.x && mouse.y < size.y;
814
815 let new_item = if in_view {
816 mouse.y + size.y * (mouse.x / col_width) + top_item
818 } else {
819 let t = this.lv_mut().track.as_mut().unwrap();
823 t.count += 1;
824 if t.count == MOUSE_AUTOS_TO_SKIP {
825 t.count = 0;
826 if num_cols == 1 {
827 if mouse.y < 0 {
829 focused - 1
830 } else if mouse.y >= size.y {
831 focused + 1
832 } else {
833 focused }
835 } else {
836 if mouse.x < 0 {
838 focused - size.y
839 } else if mouse.x >= size.x {
840 focused + size.y
841 } else if mouse.y < 0 {
842 focused - focused % size.y
843 } else if mouse.y > size.y {
844 focused - focused % size.y + size.y - 1
845 } else {
846 focused
847 }
848 }
849 } else {
850 focused
852 }
853 };
854
855 let old_item = this.lv().track.map(|t| t.old_item).unwrap_or(new_item);
856 if new_item != old_item {
857 focus_item_num(this, new_item, ctx);
858 }
859 if let Some(t) = this.lv_mut().track.as_mut() {
860 t.old_item = new_item;
861 }
862 ev.clear();
863 }
864
865 Event::MouseUp(_) if this.lv().track.is_some() => {
880 this.lv_mut().track = None;
881 let focused = this.lv().focused;
884 focus_item_num(this, focused, ctx);
885 ev.clear();
886 }
887
888 Event::KeyDown(ke) => {
892 if this.lv().find_mode != FindMode::Off && find_route_key(this, ke, ev, ctx) {
895 return;
896 }
897
898 let focused = this.lv().focused;
899 let range = this.lv().range;
900 let size_y = this.lv().state.size.y;
901 let num_cols = this.lv().num_cols;
902
903 let new_item: i32 = if matches!(ke.key, Key::Char(' '))
905 && !ke.modifiers.ctrl
906 && !ke.modifiers.alt
907 && focused < range
908 {
909 this.select_item(focused, ctx);
910 focused
911 } else if matches!(ke.key, Key::PageDown) && ke.modifiers.ctrl {
912 range - 1
917 } else if matches!(ke.key, Key::PageUp) && ke.modifiers.ctrl {
918 0
920 } else {
921 let mapped = ctrl_to_arrow(ke);
923 match mapped.key {
924 Key::Up => focused - 1,
925 Key::Down => focused + 1,
926 Key::Right if num_cols > 1 => focused + size_y,
930 Key::Left if num_cols > 1 => focused - size_y,
931 Key::PageDown => focused + size_y * num_cols,
932 Key::PageUp => focused - size_y * num_cols,
933 Key::Home => this.lv().top_item,
934 Key::End => this.lv().top_item + (size_y * num_cols) - 1,
935 _ => return, }
937 };
938 focus_item_num(this, new_item, ctx);
939 ev.clear();
940 }
941
942 Event::Broadcast { command, source } => {
947 if !this.lv().state.options.selectable {
949 return;
950 }
951 let h = this.lv().h_scroll_bar;
952 let v = this.lv().v_scroll_bar;
953 let from_own_bar = source.is_some() && (source == h || source == v);
954 if command == Command::SCROLL_BAR_CLICKED && from_own_bar {
955 if let Some(id) = this.lv().state.id() {
958 ctx.request_focus(id);
959 }
960 } else if command == Command::SCROLL_BAR_CHANGED && from_own_bar {
961 if let Some(id) = this.lv().state.id() {
964 ctx.request_scroll_sync(id, h, v);
965 }
966 }
967 }
968
969 _ => {}
970 }
971}
972
973#[allow(clippy::too_many_arguments)]
983fn draw_highlighted(
984 ctx: &mut DrawCtx,
985 x: i32,
986 y: i32,
987 text: &str,
988 indent: i32,
989 base: crate::color::Style,
990 accent: crate::color::Style,
991 m0: usize,
992 m1: usize,
993) {
994 let chars: Vec<char> = text.chars().collect();
995 let before: String = chars[..m0].iter().collect();
996 let matched: String = chars[m0..m1].iter().collect();
997 let after: String = chars[m1..].iter().collect();
998 let mut cx = x;
999 let mut rem = indent;
1000 for (piece, style) in [(before, base), (matched, accent), (after, base)] {
1001 let w = piece.chars().count() as i32;
1002 if rem >= w {
1003 rem -= w;
1005 } else {
1006 let drawn = ctx.put_str_part(cx, y, &piece, rem, style);
1007 cx += drawn;
1008 rem = 0;
1009 }
1010 }
1011}
1012
1013pub fn draw<L: ListViewer + ?Sized>(this: &mut L, ctx: &mut DrawCtx) {
1035 this.lv_mut().abs_origin = ctx.origin();
1039 let lv = this.lv();
1040 let st = &lv.state.state;
1041 let list_focused = st.focused; let roles = this.list_roles();
1045 let normal = ctx.content_surface(
1048 SurfaceRoles {
1049 normal: roles.normal,
1050 surface: roles.surface,
1051 inactive: roles.inactive,
1052 },
1053 list_focused,
1054 lv.state.options.selectable,
1055 );
1056 let selected = ctx.style(roles.selected);
1057 let focused_color = if list_focused {
1058 Some(ctx.style(roles.focused))
1059 } else {
1060 None
1061 };
1062 let divider_color = ctx.style(roles.divider);
1063 let empty_color = ctx.style(roles.normal);
1064 let accent = ctx.style(roles.selected);
1068
1069 let size = lv.state.size;
1070 let indent = lv.indent; let num_cols = lv.num_cols;
1072 let top_item = lv.top_item;
1073 let range = lv.range;
1074 let focused = lv.focused;
1075
1076 let col_width = size.x / num_cols + 1;
1077
1078 for i in 0..size.y {
1079 for j in 0..num_cols {
1080 let item = j * size.y + i + top_item;
1081 let cur_col = j * col_width;
1082
1083 let color = if list_focused && focused == item && range > 0 {
1084 focused_color.unwrap_or(normal)
1088 } else if item < range && this.is_selected(item) {
1089 selected
1090 } else if item < range
1091 && let Some(role) = this.item_role(item)
1092 {
1093 crate::color::Style {
1094 fg: ctx.style(role).fg,
1095 ..normal
1096 }
1097 } else {
1098 normal
1099 };
1100
1101 ctx.fill(
1103 crate::view::Rect::new(cur_col, i, cur_col + col_width, i + 1),
1104 ' ',
1105 color,
1106 );
1107
1108 if item < range {
1109 let text = this.get_text(item);
1112 match this.find_query().and_then(|q| find_match(&text, q)) {
1113 Some((m0, m1)) => {
1114 draw_highlighted(ctx, cur_col + 1, i, &text, indent, color, accent, m0, m1);
1115 }
1116 None => {
1117 ctx.put_str_part(cur_col + 1, i, &text, indent, color);
1118 }
1119 }
1120 } else if i == 0 && j == 0 {
1121 match this.find_query() {
1125 Some(q) => {
1126 let msg = format!("No match: {q}");
1127 ctx.put_str(cur_col + 1, i, &msg, empty_color);
1128 }
1129 None => {
1130 ctx.put_str(cur_col + 1, i, EMPTY_TEXT, empty_color);
1131 }
1132 }
1133 }
1134
1135 let vbar = ctx.glyphs().frame_v;
1137 ctx.put_char(cur_col + col_width - 1, i, vbar, divider_color);
1138 }
1139 }
1140 }
1145
1146pub fn focused_cursor<L: ListViewer + ?Sized>(this: &L) -> Option<Point> {
1153 let lv = this.lv();
1154 let st = &lv.state.state;
1155 if !(st.selected && st.active) || lv.range <= 0 {
1156 return None;
1157 }
1158 let size = lv.state.size;
1159 let num_cols = lv.num_cols;
1160 let col_width = size.x / num_cols + 1;
1161 let top_item = lv.top_item;
1162 let focused = lv.focused;
1163 for i in 0..size.y {
1164 for j in 0..num_cols {
1165 let item = j * size.y + i + top_item;
1166 if focused == item {
1167 return Some(Point::new(j * col_width + 1, i));
1168 }
1169 }
1170 }
1171 None
1172}
1173
1174pub const KB_SHIFT: u8 = 0x03;
1182
1183fn ci_char_eq(a: char, b: char) -> bool {
1186 a == b || a.eq_ignore_ascii_case(&b) || a.to_lowercase().eq(b.to_lowercase())
1187}
1188
1189pub(crate) fn find_match(text: &str, query: &str) -> Option<(usize, usize)> {
1194 let q: Vec<char> = query.chars().collect();
1195 if q.is_empty() {
1196 return None;
1197 }
1198 let t: Vec<char> = text.chars().collect();
1199 if q.len() > t.len() {
1200 return None;
1201 }
1202 'outer: for start in 0..=(t.len() - q.len()) {
1203 for k in 0..q.len() {
1204 if !ci_char_eq(t[start + k], q[k]) {
1205 continue 'outer;
1206 }
1207 }
1208 return Some((start, start + q.len()));
1209 }
1210 None
1211}
1212
1213fn ci_prefix_eq(a: &[char], b: &[char], n: usize) -> bool {
1215 if a.len() < n || b.len() < n {
1216 return false;
1217 }
1218 a[..n]
1219 .iter()
1220 .zip(&b[..n])
1221 .all(|(x, y)| x.eq_ignore_ascii_case(y))
1222}
1223
1224pub trait SortedSearch: ListViewer {
1229 fn search_pos(&self) -> i32;
1232 fn set_search_pos(&mut self, pos: i32);
1233 fn shift_state(&self) -> u8;
1236 fn set_shift_state(&mut self, s: u8);
1237 fn search(&self, cur: &[char]) -> i32;
1241}
1242
1243pub fn sorted_handle_event<L: SortedSearch + ?Sized>(
1253 this: &mut L,
1254 ev: &mut Event,
1255 ctx: &mut Context,
1256) {
1257 let old_value = this.lv().focused;
1258 handle_event(this, ev, ctx); if this.lv().find_mode != FindMode::Off {
1263 return;
1264 }
1265
1266 let released = matches!(ev,
1268 Event::Broadcast { command, .. } if *command == Command::RELEASED_FOCUS);
1269 if old_value != this.lv().focused || released {
1270 this.set_search_pos(-1);
1271 }
1272
1273 let ke = match *ev {
1275 Event::KeyDown(ke) => ke,
1276 _ => return,
1277 };
1278
1279 let acting: Option<char> = match ke.key {
1283 Key::Char(c) => Some(c),
1284 Key::Backspace => None,
1285 _ => return, };
1287
1288 let range = this.lv().range;
1289 let value0 = this.lv().focused;
1290 let mut cur: Vec<char> = if value0 < range {
1292 this.get_text(value0).chars().collect()
1293 } else {
1294 Vec::new()
1295 };
1296 let old_pos = this.search_pos();
1297
1298 match acting {
1299 None => {
1300 if this.search_pos() == -1 {
1302 return;
1303 }
1304 this.set_search_pos(this.search_pos() - 1);
1305 if this.search_pos() == -1 {
1306 this.set_shift_state(if ke.modifiers.shift { KB_SHIFT } else { 0 });
1309 }
1310 cur.truncate((this.search_pos() + 1).max(0) as usize);
1311 }
1312 Some('.') => {
1313 match cur.iter().position(|&c| c == '.') {
1315 None => this.set_search_pos(-1),
1316 Some(i) => this.set_search_pos(i as i32),
1317 }
1318 }
1319 Some(c) => {
1320 this.set_search_pos(this.search_pos() + 1);
1322 if this.search_pos() == 0 {
1323 this.set_shift_state(if ke.modifiers.shift { KB_SHIFT } else { 0 });
1325 }
1326 let idx = this.search_pos() as usize;
1327 if idx < cur.len() {
1328 cur[idx] = c;
1329 } else {
1330 cur.push(c);
1331 }
1332 cur.truncate(idx + 1);
1333 }
1334 }
1335
1336 let prefix_len = (this.search_pos() + 1).max(0) as usize;
1347 let value = this.search(&cur);
1348 if value < range {
1349 let new_string: Vec<char> = this.get_text(value).chars().collect();
1350 if ci_prefix_eq(&cur, &new_string, prefix_len) {
1351 if value != old_value {
1352 focus_item(this, value, ctx);
1353 }
1354 } else {
1356 this.set_search_pos(old_pos);
1357 }
1358 } else {
1359 this.set_search_pos(old_pos);
1360 }
1361
1362 let is_alpha = matches!(acting, Some(c) if c.is_ascii_alphabetic());
1364 if this.search_pos() != old_pos || is_alpha {
1365 ev.clear();
1366 }
1367}
1368
1369pub fn sorted_cursor<L: SortedSearch + ?Sized>(this: &L) -> Option<Point> {
1379 let base = focused_cursor(this)?;
1380 Some(Point::new(base.x + (this.search_pos() + 1).max(0), base.y))
1381}
1382
1383#[cfg(test)]
1384mod tests {
1385 use super::*;
1386 use crate::backend::{HeadlessBackend, Renderer};
1387 use crate::screen::Buffer;
1388 use crate::theme::Theme;
1389 use crate::view::{Deferred, Group, Point, Rect};
1390 use std::collections::HashSet;
1391 use std::collections::VecDeque;
1392
1393 struct FakeList {
1399 lv: ListViewerState,
1400 items: Vec<String>,
1401 selected: HashSet<i32>,
1402 }
1403
1404 impl FakeList {
1405 fn new(
1406 bounds: Rect,
1407 num_cols: i32,
1408 items: Vec<String>,
1409 h: Option<ViewId>,
1410 v: Option<ViewId>,
1411 ) -> Self {
1412 let mut lv = ListViewerState::new(bounds, num_cols, h, v);
1413 lv.range = items.len() as i32;
1414 FakeList {
1415 lv,
1416 items,
1417 selected: HashSet::new(),
1418 }
1419 }
1420 }
1421
1422 impl View for FakeList {
1423 fn state(&self) -> &ViewState {
1424 &self.lv.state
1425 }
1426 fn state_mut(&mut self) -> &mut ViewState {
1427 &mut self.lv.state
1428 }
1429 fn draw(&mut self, ctx: &mut DrawCtx) {
1430 draw(self, ctx);
1431 }
1432 fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context) {
1433 handle_event(self, ev, ctx);
1434 }
1435 fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context) {
1436 set_state(self, flag, enable, ctx);
1437 }
1438 fn cursor_request(&self) -> Option<Point> {
1439 focused_cursor(self)
1440 }
1441 fn apply_scroll_sync(&mut self, h: Option<i32>, v: Option<i32>, ctx: &mut Context) {
1442 apply_scroll(self, h, v, ctx);
1443 }
1444 fn as_any_mut(&mut self) -> Option<&mut dyn core::any::Any> {
1445 Some(self)
1446 }
1447 }
1448
1449 impl ListViewer for FakeList {
1450 fn lv(&self) -> &ListViewerState {
1451 &self.lv
1452 }
1453 fn lv_mut(&mut self) -> &mut ListViewerState {
1454 &mut self.lv
1455 }
1456 fn get_text(&self, item: i32) -> String {
1457 self.items.get(item as usize).cloned().unwrap_or_default()
1458 }
1459 fn is_selected(&self, item: i32) -> bool {
1460 self.selected.contains(&item) || item == self.lv.focused
1462 }
1463 }
1464
1465 fn items(n: i32) -> Vec<String> {
1466 (0..n).map(|i| format!("item{i}")).collect()
1467 }
1468
1469 fn make_ctx<'a>(
1470 out: &'a mut VecDeque<Event>,
1471 timers: &'a mut crate::timer::TimerQueue,
1472 deferred: &'a mut Vec<Deferred>,
1473 ) -> Context<'a> {
1474 Context::new(out, timers, 0, deferred)
1475 }
1476
1477 fn mint_id() -> (Group, ViewId) {
1479 let mut g = Group::new(Rect::new(0, 0, 4, 4));
1480 let id = g.insert(Box::new(FakeList::new(
1481 Rect::new(0, 0, 1, 1),
1482 1,
1483 vec![],
1484 None,
1485 None,
1486 )));
1487 (g, id)
1488 }
1489
1490 #[test]
1493 fn ctor_sets_options_and_zeroes_fields() {
1494 let l = FakeList::new(Rect::new(0, 0, 10, 5), 1, vec![], None, None);
1495 assert!(l.lv.state.options.first_click, "ofFirstClick set");
1496 assert!(l.lv.state.options.selectable, "ofSelectable set");
1497 assert_eq!(l.lv.top_item, 0);
1498 assert_eq!(l.lv.focused, 0);
1499 assert_eq!(l.lv.indent, 0);
1500 assert_eq!(l.lv.num_cols, 1);
1501 assert_eq!(l.lv.range, 0);
1503 assert_eq!(l.lv.state.event_mask, crate::event::EventMask::default());
1505 }
1506
1507 #[test]
1510 fn focus_item_num_clamps_negative_and_over_range_and_skips_empty() {
1511 let (_g, v) = mint_id();
1512 let mut out = VecDeque::new();
1513 let mut timers = crate::timer::TimerQueue::new();
1514 let mut deferred = vec![];
1515
1516 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(5), None, Some(v));
1518 {
1519 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1520 focus_item_num(&mut l, -3, &mut ctx);
1521 }
1522 assert_eq!(l.lv.focused, 0, "negative clamps to 0");
1523
1524 {
1526 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1527 focus_item_num(&mut l, 99, &mut ctx);
1528 }
1529 assert_eq!(l.lv.focused, 4, ">= range clamps to range-1");
1530
1531 let mut empty = FakeList::new(Rect::new(0, 0, 10, 5), 1, vec![], None, None);
1533 empty.lv.focused = 7; {
1535 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1536 focus_item_num(&mut empty, 3, &mut ctx);
1537 }
1538 assert_eq!(empty.lv.focused, 7, "range==0 -> focus_item skipped");
1539 }
1540
1541 #[test]
1544 fn focus_item_single_col_scrolls_top_item_both_directions() {
1545 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
1547 let mut out = VecDeque::new();
1548 let mut timers = crate::timer::TimerQueue::new();
1549 let mut deferred = vec![];
1550
1551 {
1553 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1554 focus_item(&mut l, 7, &mut ctx);
1555 }
1556 assert_eq!(l.lv.top_item, 3, "scroll down: topItem = item - size.y + 1");
1557
1558 {
1560 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1561 focus_item(&mut l, 1, &mut ctx);
1562 }
1563 assert_eq!(l.lv.top_item, 1, "scroll up: topItem = item");
1564 }
1565
1566 #[test]
1567 fn focus_item_multi_col_scrolls_top_item() {
1568 let mut l = FakeList::new(Rect::new(0, 0, 10, 3), 2, items(40), None, None);
1570 let mut out = VecDeque::new();
1571 let mut timers = crate::timer::TimerQueue::new();
1572 let mut deferred = vec![];
1573
1574 {
1578 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1579 focus_item(&mut l, 10, &mut ctx);
1580 }
1581 assert_eq!(l.lv.top_item, 6, "multi-col scroll down");
1582
1583 {
1586 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1587 focus_item(&mut l, 2, &mut ctx);
1588 }
1589 assert_eq!(l.lv.top_item, 0, "multi-col scroll up");
1590 }
1591
1592 #[test]
1593 fn focus_item_queues_v_bar_set_value() {
1594 let (_g, v) = mint_id();
1595 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, Some(v));
1596 let mut out = VecDeque::new();
1597 let mut timers = crate::timer::TimerQueue::new();
1598 let mut deferred: Vec<Deferred> = vec![];
1599 {
1600 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1601 focus_item(&mut l, 7, &mut ctx);
1602 }
1603 assert_eq!(deferred.len(), 1, "one setValue op");
1604 assert!(matches!(
1605 deferred[0],
1606 Deferred::ScrollBarSetParams { id, value: Some(7), min: None, max: None, page_step: None, arrow_step: None }
1607 if id == v
1608 ));
1609 }
1610
1611 #[test]
1614 fn set_range_resets_focused_past_end_and_queues_v_params() {
1615 let (_g, v) = mint_id();
1616 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, Some(v));
1617 l.lv.focused = 15;
1618 let mut out = VecDeque::new();
1619 let mut timers = crate::timer::TimerQueue::new();
1620 let mut deferred: Vec<Deferred> = vec![];
1621 {
1622 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1623 set_range(&mut l, 10, &mut ctx); }
1625 assert_eq!(l.lv.range, 10);
1626 assert_eq!(l.lv.focused, 0, "focused reset when >= new range");
1627 assert_eq!(deferred.len(), 1);
1628 assert!(matches!(
1630 deferred[0],
1631 Deferred::ScrollBarSetParams { id, value: Some(0), min: Some(0), max: Some(9), page_step: None, arrow_step: None }
1632 if id == v
1633 ));
1634 }
1635
1636 #[test]
1637 fn set_range_keeps_focused_when_in_range() {
1638 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
1639 l.lv.focused = 3;
1640 let mut out = VecDeque::new();
1641 let mut timers = crate::timer::TimerQueue::new();
1642 let mut deferred: Vec<Deferred> = vec![];
1643 {
1644 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1645 set_range(&mut l, 10, &mut ctx);
1646 }
1647 assert_eq!(l.lv.focused, 3, "focused kept (still in range)");
1648 assert!(deferred.is_empty(), "no v-bar -> no params op");
1649 }
1650
1651 #[test]
1654 fn update_steps_single_col_vbar_and_hbar() {
1655 let (_g, h) = mint_id();
1656 let (_g2, v) = mint_id();
1657 let l = FakeList::new(Rect::new(0, 0, 12, 5), 1, items(5), Some(h), Some(v));
1659 let mut out = VecDeque::new();
1660 let mut timers = crate::timer::TimerQueue::new();
1661 let mut deferred: Vec<Deferred> = vec![];
1662 {
1663 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1664 update_steps(&l, &mut ctx);
1665 }
1666 assert_eq!(deferred.len(), 2);
1667 assert!(matches!(
1669 deferred[0],
1670 Deferred::ScrollBarSetParams { id, value: None, min: None, max: None, page_step: Some(4), arrow_step: Some(1) }
1671 if id == v
1672 ));
1673 assert!(matches!(
1675 deferred[1],
1676 Deferred::ScrollBarSetParams { id, page_step: Some(12), arrow_step: Some(1), .. }
1677 if id == h
1678 ));
1679 }
1680
1681 #[test]
1682 fn update_steps_multi_col_vbar() {
1683 let (_g2, v) = mint_id();
1684 let l = FakeList::new(Rect::new(0, 0, 12, 4), 3, items(5), None, Some(v));
1686 let mut out = VecDeque::new();
1687 let mut timers = crate::timer::TimerQueue::new();
1688 let mut deferred: Vec<Deferred> = vec![];
1689 {
1690 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1691 update_steps(&l, &mut ctx);
1692 }
1693 assert!(matches!(
1695 deferred[0],
1696 Deferred::ScrollBarSetParams { id, page_step: Some(12), arrow_step: Some(4), .. }
1697 if id == v
1698 ));
1699 }
1700
1701 fn key_ev(k: Key) -> Event {
1704 Event::KeyDown(crate::event::KeyEvent::new(
1705 k,
1706 crate::event::KeyModifiers::default(),
1707 ))
1708 }
1709
1710 #[test]
1711 fn key_down_and_up_move_focus_and_clear() {
1712 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
1713 let mut out = VecDeque::new();
1714 let mut timers = crate::timer::TimerQueue::new();
1715 let mut deferred = vec![];
1716
1717 let mut ev = key_ev(Key::Down);
1718 {
1719 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1720 l.handle_event(&mut ev, &mut ctx);
1721 }
1722 assert_eq!(l.lv.focused, 1, "Down -> focused+1");
1723 assert!(ev.is_nothing(), "Down consumed");
1724
1725 let mut ev = key_ev(Key::Up);
1726 {
1727 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1728 l.handle_event(&mut ev, &mut ctx);
1729 }
1730 assert_eq!(l.lv.focused, 0, "Up -> focused-1");
1731 }
1732
1733 #[test]
1734 fn key_home_end_pgdn_pgup() {
1735 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(50), None, None);
1736 l.lv.top_item = 10;
1737 l.lv.focused = 12;
1738 let mut out = VecDeque::new();
1739 let mut timers = crate::timer::TimerQueue::new();
1740 let mut deferred = vec![];
1741
1742 let mut ev = key_ev(Key::Home);
1744 {
1745 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1746 l.handle_event(&mut ev, &mut ctx);
1747 }
1748 assert_eq!(l.lv.focused, 10, "Home -> topItem");
1749
1750 let mut ev = key_ev(Key::End);
1752 {
1753 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1754 l.handle_event(&mut ev, &mut ctx);
1755 }
1756 assert_eq!(l.lv.focused, 14, "End -> topItem + page - 1");
1757
1758 let mut ev = key_ev(Key::PageDown);
1760 {
1761 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1762 l.handle_event(&mut ev, &mut ctx);
1763 }
1764 assert_eq!(l.lv.focused, 19, "PgDn -> +page");
1765
1766 let mut ev = key_ev(Key::PageUp);
1768 {
1769 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1770 l.handle_event(&mut ev, &mut ctx);
1771 }
1772 assert_eq!(l.lv.focused, 14, "PgUp -> -page");
1773 }
1774
1775 #[test]
1776 fn key_ctrl_pgdn_pgup_jump_to_ends() {
1777 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(50), None, None);
1778 l.lv.focused = 20;
1779 let mut out = VecDeque::new();
1780 let mut timers = crate::timer::TimerQueue::new();
1781 let mut deferred = vec![];
1782
1783 let ctrl = crate::event::KeyModifiers {
1784 ctrl: true,
1785 ..Default::default()
1786 };
1787 let mut ev = Event::KeyDown(crate::event::KeyEvent::new(Key::PageDown, ctrl));
1789 {
1790 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1791 l.handle_event(&mut ev, &mut ctx);
1792 }
1793 assert_eq!(l.lv.focused, 49, "Ctrl+PgDn -> range-1");
1794
1795 let mut ev = Event::KeyDown(crate::event::KeyEvent::new(Key::PageUp, ctrl));
1797 {
1798 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1799 l.handle_event(&mut ev, &mut ctx);
1800 }
1801 assert_eq!(l.lv.focused, 0, "Ctrl+PgUp -> 0");
1802 }
1803
1804 #[test]
1805 fn left_right_no_op_single_col_leaves_event_live() {
1806 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
1807 l.lv.focused = 3;
1808 let mut out = VecDeque::new();
1809 let mut timers = crate::timer::TimerQueue::new();
1810 let mut deferred = vec![];
1811
1812 for k in [Key::Left, Key::Right] {
1813 let mut ev = key_ev(k);
1814 {
1815 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1816 l.handle_event(&mut ev, &mut ctx);
1817 }
1818 assert_eq!(l.lv.focused, 3, "{k:?} is a no-op when numCols==1");
1819 assert!(
1820 !ev.is_nothing(),
1821 "{k:?} leaves the event LIVE (C++ return, no clearEvent)"
1822 );
1823 }
1824 }
1825
1826 #[test]
1827 fn left_right_move_by_size_y_multi_col() {
1828 let mut l = FakeList::new(Rect::new(0, 0, 12, 3), 2, items(40), None, None);
1829 l.lv.focused = 5;
1830 let mut out = VecDeque::new();
1831 let mut timers = crate::timer::TimerQueue::new();
1832 let mut deferred = vec![];
1833
1834 let mut ev = key_ev(Key::Right);
1836 {
1837 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1838 l.handle_event(&mut ev, &mut ctx);
1839 }
1840 assert_eq!(l.lv.focused, 8, "Right -> +size.y (multi-col)");
1841 assert!(ev.is_nothing(), "Right consumed (multi-col)");
1842
1843 let mut ev = key_ev(Key::Left);
1845 {
1846 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1847 l.handle_event(&mut ev, &mut ctx);
1848 }
1849 assert_eq!(l.lv.focused, 5, "Left -> -size.y (multi-col)");
1850 }
1851
1852 #[test]
1853 fn space_selects_focused_and_broadcasts() {
1854 let mut group = Group::new(Rect::new(0, 0, 20, 10));
1856 let id = group.insert(Box::new(FakeList::new(
1857 Rect::new(0, 0, 10, 5),
1858 1,
1859 items(20),
1860 None,
1861 None,
1862 )));
1863 if let Some(v) = group.find_mut(id) {
1864 v.state_mut().state.focused = true;
1865 }
1866 let mut out = VecDeque::new();
1867 let mut timers = crate::timer::TimerQueue::new();
1868 let mut deferred = vec![];
1869
1870 let mut ev = key_ev(Key::Char(' '));
1871 {
1872 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1873 group.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
1874 }
1875 assert!(
1877 out.iter().any(|e| matches!(
1878 e,
1879 Event::Broadcast { command, source }
1880 if *command == Command::LIST_ITEM_SELECTED && *source == Some(id)
1881 )),
1882 "Space broadcasts cmListItemSelected with self as source"
1883 );
1884 assert!(ev.is_nothing(), "Space consumed");
1885 }
1886
1887 #[test]
1888 fn double_click_selects_item_under_cursor() {
1889 let mut group = Group::new(Rect::new(0, 0, 20, 10));
1890 let id = group.insert(Box::new(FakeList::new(
1891 Rect::new(0, 0, 10, 5),
1892 1,
1893 items(20),
1894 None,
1895 None,
1896 )));
1897 let mut out = VecDeque::new();
1898 let mut timers = crate::timer::TimerQueue::new();
1899 let mut deferred = vec![];
1900
1901 let me = crate::event::MouseEvent {
1903 position: Point::new(3, 2),
1904 flags: crate::event::MouseEventFlags {
1905 double_click: true,
1906 ..Default::default()
1907 },
1908 ..Default::default()
1909 };
1910 let mut ev = Event::MouseDown(me);
1911 {
1912 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1913 group.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
1914 }
1915 let focused = group
1917 .find_mut(id)
1918 .and_then(|v| v.as_any_mut())
1919 .and_then(|a| a.downcast_mut::<FakeList>())
1920 .map(|l| l.lv.focused)
1921 .unwrap();
1922 assert_eq!(focused, 2, "click positioned focus to item 2");
1923 assert!(
1924 out.iter().any(|e| matches!(
1925 e,
1926 Event::Broadcast { command, .. } if *command == Command::LIST_ITEM_SELECTED
1927 )),
1928 "double-click selects -> cmListItemSelected"
1929 );
1930 assert!(ev.is_nothing(), "mouse-down consumed");
1931 }
1932
1933 #[test]
1934 fn scrollbar_changed_filter_requests_sync_only_for_own_bars() {
1935 let mut group = Group::new(Rect::new(0, 0, 30, 20));
1936 let (_gh, h) = mint_id();
1937 let (_gv, v) = mint_id();
1938 let id = group.insert(Box::new(FakeList::new(
1939 Rect::new(0, 0, 10, 5),
1940 1,
1941 items(20),
1942 Some(h),
1943 Some(v),
1944 )));
1945 let mut out = VecDeque::new();
1946 let mut timers = crate::timer::TimerQueue::new();
1947 let mut deferred: Vec<Deferred> = vec![];
1948
1949 let mut ev = Event::Broadcast {
1951 command: Command::SCROLL_BAR_CHANGED,
1952 source: Some(h),
1953 };
1954 {
1955 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1956 group.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
1957 }
1958 assert_eq!(deferred.len(), 1);
1959 assert!(matches!(
1960 deferred[0],
1961 Deferred::ScrollSync { target, h: rh, v: rv }
1962 if target == id && rh == Some(h) && rv == Some(v)
1963 ));
1964
1965 deferred.clear();
1967 let mut ev = Event::Broadcast {
1968 command: Command::SCROLL_BAR_CHANGED,
1969 source: Some(id),
1970 };
1971 {
1972 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1973 group.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
1974 }
1975 assert!(deferred.is_empty(), "foreign source ignored (filter bites)");
1976
1977 let mut ev = Event::Broadcast {
1979 command: Command::SCROLL_BAR_CLICKED,
1980 source: Some(v),
1981 };
1982 {
1983 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
1984 group.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
1985 }
1986 assert_eq!(deferred.len(), 1);
1987 assert!(matches!(deferred[0], Deferred::FocusById(fid) if fid == id));
1988 }
1989
1990 #[test]
1993 fn apply_scroll_h_updates_indent_v_focuses() {
1994 let (_g, v) = mint_id();
1995 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, Some(v));
1996 let mut out = VecDeque::new();
1997 let mut timers = crate::timer::TimerQueue::new();
1998 let mut deferred: Vec<Deferred> = vec![];
1999 {
2000 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2001 apply_scroll(&mut l, Some(4), Some(8), &mut ctx);
2002 }
2003 assert_eq!(l.lv.indent, 4, "h branch refreshes the cached indent");
2004 assert_eq!(l.lv.focused, 8, "v branch focusItemNum(8)");
2005 }
2006
2007 #[test]
2010 fn focused_cursor_visible_and_offscreen() {
2011 let mut l = FakeList::new(Rect::new(0, 0, 16, 3), 2, items(20), None, None);
2015 l.lv.state.state.selected = true;
2016 l.lv.state.state.active = true;
2017
2018 l.lv.focused = 4;
2023 assert_eq!(
2024 focused_cursor(&l),
2025 Some(Point::new(10, 1)),
2026 "focused item 4 -> col1 row1 -> view-local (10, 1)"
2027 );
2028
2029 l.lv.focused = 2;
2031 assert_eq!(
2032 focused_cursor(&l),
2033 Some(Point::new(1, 2)),
2034 "focused item 2 -> col0 row2 -> view-local (1, 2)"
2035 );
2036
2037 l.lv.focused = 9;
2040 assert_eq!(focused_cursor(&l), None, "focused below page -> None");
2041
2042 l.lv.top_item = 6; l.lv.focused = 3; assert_eq!(focused_cursor(&l), None, "focused above top_item -> None");
2046 }
2047
2048 fn render(l: &mut FakeList, w: u16, h: u16) -> String {
2051 let theme = Theme::classic_blue();
2052 let (backend, screen) = HeadlessBackend::new(w, h);
2053 let mut r = Renderer::new(Box::new(backend));
2054 r.render(|buf: &mut Buffer| {
2055 let bounds = l.state().get_bounds();
2056 let mut dc = DrawCtx::new(buf, &theme, bounds, bounds.a);
2057 l.draw(&mut dc);
2058 });
2059 screen.snapshot()
2060 }
2061
2062 #[test]
2063 fn snapshot_single_col_active_focused_and_selected() {
2064 let mut l = FakeList::new(Rect::new(0, 0, 12, 4), 1, items(3), None, None);
2065 l.lv.state.state.selected = true;
2067 l.lv.state.state.active = true;
2068 l.lv.state.state.focused = true;
2069 l.lv.focused = 1;
2070 l.selected.insert(2); insta::assert_snapshot!(render(&mut l, 12, 4));
2072 }
2073
2074 #[test]
2075 fn snapshot_multi_col() {
2076 let mut l = FakeList::new(Rect::new(0, 0, 16, 3), 2, items(8), None, None);
2079 l.lv.state.state.selected = true;
2080 l.lv.state.state.active = true;
2081 l.lv.state.state.focused = true;
2082 insta::assert_snapshot!(render(&mut l, 16, 3));
2083 }
2084
2085 #[test]
2086 fn snapshot_empty_shows_placeholder() {
2087 let mut l = FakeList::new(Rect::new(0, 0, 12, 3), 1, vec![], None, None);
2088 l.lv.state.state.selected = true;
2089 l.lv.state.state.active = true;
2090 insta::assert_snapshot!(render(&mut l, 12, 3));
2091 }
2092
2093 #[test]
2094 fn snapshot_find_highlights_first_match() {
2095 let mut fake = FakeList::new(
2096 Rect::new(0, 0, 14, 4),
2097 1,
2098 vec!["banana".into(), "orange".into(), "grape".into()],
2099 None,
2100 None,
2101 );
2102 fake.lv.state.state.selected = true;
2103 fake.lv.state.state.active = true;
2104 fake.lv.state.state.focused = true;
2105 fake.lv.range = 3;
2106 fake.lv.find_mode = FindMode::Highlight;
2107 fake.lv.query = "an".into();
2108 insta::assert_snapshot!(render(&mut fake, 14, 4));
2109 }
2110
2111 #[test]
2112 fn snapshot_find_empty_shows_no_match_placeholder() {
2113 let mut fake = FakeList::new(Rect::new(0, 0, 16, 3), 1, vec![], None, None);
2114 fake.lv.state.state.selected = true;
2115 fake.lv.state.state.active = true;
2116 fake.lv.range = 0;
2117 fake.lv.find_mode = FindMode::Filter;
2118 fake.lv.query = "xyz".into();
2119 insta::assert_snapshot!(render(&mut fake, 16, 3));
2120 }
2121
2122 fn surface_bg_at(theme: &Theme, owner_active: bool, list_focused: bool) -> crate::color::Color {
2135 let mut l = FakeList::new(Rect::new(0, 0, 10, 2), 1, items(2), None, None);
2136 l.lv.state.state.selected = true;
2137 l.lv.state.state.active = true;
2138 l.lv.state.state.focused = list_focused;
2139 let bounds = l.state().get_bounds();
2140 let mut buf = Buffer::new(10, 2);
2141 let mut dc = DrawCtx::new(&mut buf, theme, bounds, bounds.a);
2142 dc.set_owner_active(owner_active);
2143 l.draw(&mut dc);
2144 buf.get(1, 1).style().bg
2145 }
2146
2147 #[test]
2154 fn surface_axis_tracks_owner_active_not_own_state() {
2155 use crate::color::{Color, Style};
2156
2157 let mut theme = Theme::classic_blue();
2158 theme.set_style(
2162 Role::ListSurface,
2163 Style::new(Color::bios_rgb(0xA), Color::bios_rgb(0x5)),
2164 );
2165 theme.set_style(
2166 Role::ListInactive,
2167 Style::new(Color::bios_rgb(0xE), Color::bios_rgb(0x4)),
2168 );
2169 let normal_bg = theme.style(Role::ListNormal).bg;
2170 let surface_bg = theme.style(Role::ListSurface).bg;
2171 let inactive_bg = theme.style(Role::ListInactive).bg;
2172 assert!(
2173 normal_bg != surface_bg && surface_bg != inactive_bg && normal_bg != inactive_bg,
2174 "test theme must distinguish all three roles"
2175 );
2176
2177 assert_eq!(surface_bg_at(&theme, false, true), inactive_bg);
2179 assert_eq!(surface_bg_at(&theme, false, false), inactive_bg);
2180
2181 assert_eq!(surface_bg_at(&theme, true, true), normal_bg);
2183
2184 assert_eq!(surface_bg_at(&theme, true, false), surface_bg);
2186 }
2187
2188 #[test]
2193 fn non_selectable_list_never_shows_surface() {
2194 use crate::color::{Color, Style};
2195
2196 let mut theme = Theme::classic_blue();
2197 theme.set_style(
2198 Role::ListSurface,
2199 Style::new(Color::bios_rgb(0xA), Color::bios_rgb(0x5)),
2200 );
2201 theme.set_style(
2202 Role::ListInactive,
2203 Style::new(Color::bios_rgb(0xE), Color::bios_rgb(0x4)),
2204 );
2205 let normal_bg = theme.style(Role::ListNormal).bg;
2206 let inactive_bg = theme.style(Role::ListInactive).bg;
2207
2208 let bg_at = |owner_active: bool, list_focused: bool| {
2209 let mut l = FakeList::new(Rect::new(0, 0, 10, 2), 1, items(2), None, None);
2210 l.lv.state.state.selected = true;
2211 l.lv.state.state.active = true;
2212 l.lv.state.state.focused = list_focused;
2213 l.lv.state.options.selectable = false;
2214 let bounds = l.state().get_bounds();
2215 let mut buf = Buffer::new(10, 2);
2216 let mut dc = DrawCtx::new(&mut buf, &theme, bounds, bounds.a);
2217 dc.set_owner_active(owner_active);
2218 l.draw(&mut dc);
2219 buf.get(1, 1).style().bg
2220 };
2221
2222 assert_eq!(bg_at(true, false), normal_bg);
2224 assert_eq!(bg_at(true, true), normal_bg);
2225 assert_eq!(bg_at(false, false), inactive_bg);
2227 }
2228
2229 #[test]
2235 fn highlight_axis_tracks_own_state_focused_not_owner_active() {
2236 let render_with = |list_focused: bool| {
2237 let mut l = FakeList::new(Rect::new(0, 0, 10, 2), 1, items(2), None, None);
2238 l.lv.state.state.selected = true;
2239 l.lv.state.state.active = true;
2240 l.lv.state.state.focused = list_focused;
2241 l.lv.focused = 0;
2242 let theme = Theme::classic_blue();
2243 let bounds = l.state().get_bounds();
2244 let mut buf = Buffer::new(10, 2);
2245 let mut dc = DrawCtx::new(&mut buf, &theme, bounds, bounds.a);
2246 dc.set_owner_active(true); l.draw(&mut dc);
2248 crate::screen::snapshot::snapshot(&buf, None)
2249 };
2250
2251 let focused_list = render_with(true);
2252 let unfocused_sibling = render_with(false);
2253 assert_ne!(
2254 focused_list, unfocused_sibling,
2255 "current-row highlight must track the list's own state.focused, \
2256 not merely owner_active"
2257 );
2258 }
2259
2260 #[test]
2269 fn list_current_item_bright_only_in_the_focused_pane() {
2270 let mut list_a = FakeList::new(Rect::new(0, 0, 8, 2), 1, items(2), None, None);
2271 list_a.lv.state.state.selected = true;
2272 list_a.lv.state.state.active = true;
2273 list_a.lv.state.state.focused = true; list_a.lv.focused = 0;
2275
2276 let mut list_b = FakeList::new(Rect::new(0, 0, 8, 2), 1, items(2), None, None);
2277 list_b.lv.state.state.selected = true;
2278 list_b.lv.state.state.active = true;
2279 list_b.lv.state.state.focused = false; list_b.lv.focused = 0;
2281
2282 let mut pane_a = Group::new(Rect::new(0, 0, 8, 2));
2283 pane_a.insert(Box::new(list_a));
2284 pane_a.state_mut().state.focused = true; let mut pane_b = Group::new(Rect::new(9, 0, 17, 2));
2287 pane_b.insert(Box::new(list_b));
2288 pane_b.state_mut().state.focused = false; let mut splitter = Group::new(Rect::new(0, 0, 17, 2));
2291 splitter.insert(Box::new(pane_a));
2292 splitter.insert(Box::new(pane_b));
2293
2294 let theme = Theme::classic_blue();
2295 let mut buf = Buffer::new(17, 2);
2296 let mut dc = DrawCtx::new(&mut buf, &theme, Rect::new(0, 0, 17, 2), Point::new(0, 0));
2297 splitter.draw(&mut dc);
2298 insta::assert_snapshot!(crate::screen::snapshot::snapshot(&buf, None));
2299 }
2300
2301 fn mouse_down_at(x: i32, y: i32) -> Event {
2309 Event::MouseDown(crate::event::MouseEvent {
2310 position: Point::new(x, y),
2311 buttons: crate::event::MouseButtons {
2312 left: true,
2313 ..Default::default()
2314 },
2315 ..Default::default()
2316 })
2317 }
2318
2319 fn mouse_move_at(x: i32, y: i32) -> Event {
2320 Event::MouseMove(crate::event::MouseEvent {
2321 position: Point::new(x, y),
2322 buttons: crate::event::MouseButtons {
2323 left: true,
2324 ..Default::default()
2325 },
2326 ..Default::default()
2327 })
2328 }
2329
2330 fn mouse_auto_at(x: i32, y: i32) -> Event {
2331 Event::MouseAuto(crate::event::MouseEvent {
2332 position: Point::new(x, y),
2333 ..Default::default()
2334 })
2335 }
2336
2337 fn mouse_up_at(x: i32, y: i32) -> Event {
2338 Event::MouseUp(crate::event::MouseEvent {
2339 position: Point::new(x, y),
2340 ..Default::default()
2341 })
2342 }
2343
2344 fn double_click_at(x: i32, y: i32) -> Event {
2345 Event::MouseDown(crate::event::MouseEvent {
2346 position: Point::new(x, y),
2347 flags: crate::event::MouseEventFlags {
2348 double_click: true,
2349 ..Default::default()
2350 },
2351 buttons: crate::event::MouseButtons {
2352 left: true,
2353 ..Default::default()
2354 },
2355 ..Default::default()
2356 })
2357 }
2358
2359 fn give_id(l: &mut FakeList) -> ViewId {
2361 let id = ViewId::next();
2362 l.lv.state.id = Some(id);
2363 id
2364 }
2365
2366 #[test]
2369 fn mouse_down_arms_tracking_and_pushes_capture() {
2370 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2372 let id = give_id(&mut l);
2373 let mut out = VecDeque::new();
2374 let mut timers = crate::timer::TimerQueue::new();
2375 let mut deferred: Vec<Deferred> = vec![];
2376
2377 let mut ev = mouse_down_at(3, 2);
2378 {
2379 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2380 l.handle_event(&mut ev, &mut ctx);
2381 }
2382 assert!(ev.is_nothing(), "MouseDown consumed");
2383 assert_eq!(l.lv.focused, 2, "focus positioned to item 2");
2384 assert!(l.lv.track.is_some(), "track state armed");
2385 assert_eq!(deferred.len(), 1, "one PushCapture deferred");
2387 assert!(
2388 matches!(deferred[0], Deferred::PushCapture(_)),
2389 "deferred[0] is PushCapture"
2390 );
2391 if let Deferred::PushCapture(ref h) = deferred[0] {
2392 assert_eq!(h.view(), Some(id), "capture tracks the list's id");
2393 }
2394 }
2395
2396 #[test]
2399 fn mouse_down_without_id_is_single_shot() {
2400 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2401 let mut out = VecDeque::new();
2403 let mut timers = crate::timer::TimerQueue::new();
2404 let mut deferred: Vec<Deferred> = vec![];
2405
2406 let mut ev = mouse_down_at(3, 2);
2407 {
2408 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2409 l.handle_event(&mut ev, &mut ctx);
2410 }
2411 assert!(l.lv.track.is_none(), "no track without an id");
2412 assert!(deferred.is_empty(), "no capture pushed for id-less list");
2413 }
2414
2415 #[test]
2417 fn double_click_selects_and_does_not_arm_tracking() {
2418 let mut g = Group::new(Rect::new(0, 0, 20, 10));
2419 let id = g.insert(Box::new(FakeList::new(
2420 Rect::new(0, 0, 10, 5),
2421 1,
2422 items(20),
2423 None,
2424 None,
2425 )));
2426 let mut out = VecDeque::new();
2427 let mut timers = crate::timer::TimerQueue::new();
2428 let mut deferred: Vec<Deferred> = vec![];
2429
2430 let mut ev = double_click_at(3, 2);
2431 {
2432 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2433 g.find_mut(id).unwrap().handle_event(&mut ev, &mut ctx);
2434 }
2435 assert!(ev.is_nothing(), "double-click consumed");
2436 assert!(
2438 deferred
2439 .iter()
2440 .all(|d| !matches!(d, Deferred::PushCapture(_))),
2441 "double-click does NOT arm tracking"
2442 );
2443 assert!(
2445 out.iter().any(|e| matches!(e,
2446 Event::Broadcast { command, .. } if *command == Command::LIST_ITEM_SELECTED
2447 )),
2448 "double-click selects (cmListItemSelected)"
2449 );
2450 }
2451
2452 #[test]
2454 fn mouse_move_in_view_recomputes_focus() {
2455 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2456 give_id(&mut l);
2457 let mut out = VecDeque::new();
2458 let mut timers = crate::timer::TimerQueue::new();
2459 let mut deferred: Vec<Deferred> = vec![];
2460
2461 let mut ev = mouse_down_at(0, 0);
2463 {
2464 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2465 l.handle_event(&mut ev, &mut ctx);
2466 }
2467 assert_eq!(l.lv.focused, 0);
2468 deferred.clear();
2469
2470 let mut ev = mouse_move_at(2, 3);
2472 {
2473 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2474 l.handle_event(&mut ev, &mut ctx);
2475 }
2476 assert!(ev.is_nothing(), "MouseMove consumed");
2477 assert_eq!(l.lv.focused, 3, "focus moves with the mouse");
2478 assert!(l.lv.track.is_some(), "still tracking after move");
2479 }
2480
2481 #[test]
2484 fn mouse_move_out_of_view_is_noop() {
2485 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2486 give_id(&mut l);
2487 let mut out = VecDeque::new();
2488 let mut timers = crate::timer::TimerQueue::new();
2489 let mut deferred: Vec<Deferred> = vec![];
2490
2491 let mut ev = mouse_down_at(0, 2);
2492 {
2493 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2494 l.handle_event(&mut ev, &mut ctx);
2495 }
2496 let focused_after_down = l.lv.focused;
2497 deferred.clear();
2498
2499 let mut ev = mouse_move_at(0, -1);
2501 {
2502 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2503 l.handle_event(&mut ev, &mut ctx);
2504 }
2505 assert_eq!(
2506 l.lv.focused, focused_after_down,
2507 "out-of-view MouseMove does not change focus"
2508 );
2509 }
2510
2511 #[test]
2513 fn mouse_auto_in_view_recomputes_focus() {
2514 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2515 give_id(&mut l);
2516 let mut out = VecDeque::new();
2517 let mut timers = crate::timer::TimerQueue::new();
2518 let mut deferred: Vec<Deferred> = vec![];
2519
2520 let mut ev = mouse_down_at(0, 0);
2521 {
2522 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2523 l.handle_event(&mut ev, &mut ctx);
2524 }
2525 deferred.clear();
2526
2527 let mut ev = mouse_auto_at(0, 4);
2529 {
2530 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2531 l.handle_event(&mut ev, &mut ctx);
2532 }
2533 assert!(ev.is_nothing(), "MouseAuto consumed");
2534 assert_eq!(l.lv.focused, 4, "in-view MouseAuto repositions focus");
2535 }
2536
2537 #[test]
2540 fn mouse_auto_out_of_view_skips_then_steps_single_col() {
2541 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2542 give_id(&mut l);
2543 let mut out = VecDeque::new();
2544 let mut timers = crate::timer::TimerQueue::new();
2545 let mut deferred: Vec<Deferred> = vec![];
2546
2547 let mut ev = mouse_down_at(0, 2);
2549 {
2550 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2551 l.handle_event(&mut ev, &mut ctx);
2552 }
2553 assert_eq!(l.lv.focused, 2);
2554 deferred.clear();
2555
2556 for tick in 1..=3 {
2558 let mut ev = mouse_auto_at(0, 7); let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2560 l.handle_event(&mut ev, &mut ctx);
2561 assert_eq!(
2562 l.lv.focused, 2,
2563 "tick {tick}: focus stays at 2 before threshold"
2564 );
2565 }
2566 let mut ev = mouse_auto_at(0, 7);
2568 {
2569 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2570 l.handle_event(&mut ev, &mut ctx);
2571 }
2572 assert_eq!(l.lv.focused, 3, "4th tick steps focus by +1 (below view)");
2573 for tick in 1..=3 {
2575 let mut ev = mouse_auto_at(0, 7);
2576 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2577 l.handle_event(&mut ev, &mut ctx);
2578 assert_eq!(l.lv.focused, 3, "after reset, tick {tick}: no step");
2579 }
2580 }
2581
2582 #[test]
2584 fn mouse_auto_out_of_view_above_steps_backward() {
2585 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2586 give_id(&mut l);
2587 let mut out = VecDeque::new();
2588 let mut timers = crate::timer::TimerQueue::new();
2589 let mut deferred: Vec<Deferred> = vec![];
2590
2591 let mut ev = mouse_down_at(0, 2);
2593 {
2594 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2595 l.handle_event(&mut ev, &mut ctx);
2596 }
2597 l.lv.focused = 5;
2598 l.lv.track = Some(LvTrack {
2599 count: 0,
2600 old_item: 5,
2601 });
2602 deferred.clear();
2603
2604 for _ in 1..=3 {
2606 let mut ev = mouse_auto_at(0, -1);
2607 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2608 l.handle_event(&mut ev, &mut ctx);
2609 }
2610 assert_eq!(l.lv.focused, 5, "first 3 ticks: no step");
2611 let mut ev = mouse_auto_at(0, -1);
2612 {
2613 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2614 l.handle_event(&mut ev, &mut ctx);
2615 }
2616 assert_eq!(l.lv.focused, 4, "4th tick steps focus by -1 (above view)");
2617 }
2618
2619 #[test]
2621 fn mouse_up_clears_track_and_refocuses() {
2622 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2623 give_id(&mut l);
2624 let mut out = VecDeque::new();
2625 let mut timers = crate::timer::TimerQueue::new();
2626 let mut deferred: Vec<Deferred> = vec![];
2627
2628 let mut ev = mouse_down_at(0, 3);
2630 {
2631 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2632 l.handle_event(&mut ev, &mut ctx);
2633 }
2634 assert!(l.lv.track.is_some());
2635 deferred.clear();
2636
2637 let mut ev = mouse_up_at(0, 3);
2639 {
2640 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2641 l.handle_event(&mut ev, &mut ctx);
2642 }
2643 assert!(ev.is_nothing(), "MouseUp consumed");
2644 assert!(l.lv.track.is_none(), "track cleared on MouseUp");
2645 }
2646
2647 #[test]
2650 fn stray_mouse_up_falls_through() {
2651 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2652 give_id(&mut l);
2653 let mut out = VecDeque::new();
2654 let mut timers = crate::timer::TimerQueue::new();
2655 let mut deferred: Vec<Deferred> = vec![];
2656
2657 let mut ev = mouse_up_at(0, 3);
2659 {
2660 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2661 l.handle_event(&mut ev, &mut ctx);
2662 }
2663 assert!(
2664 !ev.is_nothing(),
2665 "stray MouseUp falls through (not consumed)"
2666 );
2667 }
2668
2669 #[test]
2671 fn stray_mouse_move_falls_through() {
2672 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(20), None, None);
2673 give_id(&mut l);
2674 let mut out = VecDeque::new();
2675 let mut timers = crate::timer::TimerQueue::new();
2676 let mut deferred: Vec<Deferred> = vec![];
2677
2678 let mut ev = mouse_move_at(3, 2);
2679 {
2680 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2681 l.handle_event(&mut ev, &mut ctx);
2682 }
2683 assert!(
2684 !ev.is_nothing(),
2685 "stray MouseMove falls through (not consumed)"
2686 );
2687 }
2688
2689 #[test]
2692 fn mouse_auto_multi_col_steps_by_size_y() {
2693 let mut l = FakeList::new(Rect::new(0, 0, 12, 4), 2, items(40), None, None);
2695 give_id(&mut l);
2696 l.lv.focused = 8;
2697 l.lv.track = Some(LvTrack {
2698 count: 0,
2699 old_item: 8,
2700 });
2701 let mut out = VecDeque::new();
2702 let mut timers = crate::timer::TimerQueue::new();
2703 let mut deferred: Vec<Deferred> = vec![];
2704
2705 for _ in 1..=3 {
2707 let mut ev = mouse_auto_at(13, 2); let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2709 l.handle_event(&mut ev, &mut ctx);
2710 }
2711 assert_eq!(l.lv.focused, 8, "3 ticks: no step yet");
2712 let mut ev = mouse_auto_at(13, 2);
2713 {
2714 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2715 l.handle_event(&mut ev, &mut ctx);
2716 }
2717 assert_eq!(l.lv.focused, 12, "4th tick: +size.y = +4 (right of view)");
2718 }
2719
2720 #[test]
2725 fn set_state_visible_false_hides_both_scroll_bars() {
2726 let (_gh, h) = mint_id();
2727 let (_gv, v) = mint_id();
2728
2729 let mut l = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(5), Some(h), Some(v));
2731 l.lv.state.state.active = true;
2735 l.lv.state.state.visible = true;
2736
2737 let mut out = VecDeque::new();
2738 let mut timers = crate::timer::TimerQueue::new();
2739 let mut deferred: Vec<Deferred> = vec![];
2740
2741 {
2743 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2744 l.set_state(StateFlag::Visible, false, &mut ctx);
2745 }
2746
2747 assert_eq!(
2749 deferred.len(),
2750 2,
2751 "expected 2 SetVisible ops, got {}",
2752 deferred.len()
2753 );
2754 assert!(
2755 matches!(deferred[0], Deferred::SetVisible(id, false) if id == h),
2756 "first op must be SetVisible(h_scroll_bar, false)"
2757 );
2758 assert!(
2759 matches!(deferred[1], Deferred::SetVisible(id, false) if id == v),
2760 "second op must be SetVisible(v_scroll_bar, false)"
2761 );
2762 }
2763
2764 #[test]
2765 fn find_query_reflects_mode_and_emptiness() {
2766 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2767 assert_eq!(fake.find_query(), None, "Off → None");
2768 fake.lv.find_mode = FindMode::Highlight;
2769 assert_eq!(fake.find_query(), None, "empty query → None");
2770 fake.lv.query = "ab".into();
2771 assert_eq!(fake.find_query(), Some("ab"));
2772 fake.lv.find_mode = FindMode::Off;
2773 assert_eq!(fake.find_query(), None, "Off overrides a non-empty query");
2774 }
2775
2776 fn find_broadcasts(out: &VecDeque<Event>) -> (usize, Option<ViewId>) {
2781 let mut count = 0;
2782 let mut last_source = None;
2783 for e in out.iter() {
2784 if let Event::Broadcast { command, source } = e
2785 && *command == Command::LIST_FIND_CHANGED
2786 {
2787 count += 1;
2788 last_source = *source;
2789 }
2790 }
2791 (count, last_source)
2792 }
2793
2794 #[test]
2795 fn set_find_query_sets_query_and_broadcasts_once() {
2796 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2797 fake.lv.find_mode = FindMode::Highlight;
2798 let mut out = VecDeque::new();
2799 let mut timers = crate::timer::TimerQueue::new();
2800 let mut deferred = vec![];
2801 {
2802 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2803 fake.set_find_query("ab", &mut ctx);
2804 }
2805 assert_eq!(fake.find_query(), Some("ab"), "query is set");
2806 let (count, source) = find_broadcasts(&out);
2807 assert_eq!(count, 1, "exactly one LIST_FIND_CHANGED");
2808 assert_eq!(source, fake.state().id(), "source = this list's id");
2809 }
2810
2811 #[test]
2812 fn set_find_query_same_text_is_a_noop() {
2813 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2814 fake.lv.find_mode = FindMode::Highlight;
2815 fake.lv.query = "ab".into();
2816 let mut out = VecDeque::new();
2817 let mut timers = crate::timer::TimerQueue::new();
2818 let mut deferred = vec![];
2819 {
2820 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2821 fake.set_find_query("ab", &mut ctx);
2822 }
2823 assert_eq!(fake.lv.query, "ab", "unchanged");
2824 assert_eq!(
2825 find_broadcasts(&out).0,
2826 0,
2827 "no broadcast on the change guard"
2828 );
2829 }
2830
2831 #[test]
2832 fn set_find_query_empty_clears_like_clear_find() {
2833 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2834 fake.lv.find_mode = FindMode::Highlight;
2835 fake.lv.query = "ab".into();
2836 let mut out = VecDeque::new();
2837 let mut timers = crate::timer::TimerQueue::new();
2838 let mut deferred = vec![];
2839 {
2840 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2841 fake.set_find_query("", &mut ctx);
2842 }
2843 assert_eq!(fake.find_query(), None, "empty query reads as None");
2844 assert_eq!(fake.lv.query, "", "query emptied");
2845 assert_eq!(find_broadcasts(&out).0, 1, "empties and notifies once");
2846 }
2847
2848 #[test]
2849 fn set_find_query_off_mode_is_total_noop() {
2850 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2851 let mut out = VecDeque::new();
2853 let mut timers = crate::timer::TimerQueue::new();
2854 let mut deferred = vec![];
2855 {
2856 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2857 fake.set_find_query("x", &mut ctx);
2858 }
2859 assert_eq!(fake.lv.query, "", "Off: query untouched");
2860 assert_eq!(find_broadcasts(&out).0, 0, "Off: no broadcast");
2861 }
2862
2863 #[test]
2864 fn clear_find_delegates_to_set_find_query() {
2865 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(3), None, None);
2866 fake.lv.find_mode = FindMode::Highlight;
2867 fake.lv.query = "ab".into();
2868 let mut out = VecDeque::new();
2869 let mut timers = crate::timer::TimerQueue::new();
2870 let mut deferred = vec![];
2871 {
2872 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2873 fake.clear_find(&mut ctx);
2874 }
2875 assert_eq!(fake.find_query(), None, "clear_find still empties");
2876 assert_eq!(find_broadcasts(&out).0, 1, "clear_find still notifies once");
2877
2878 out.clear();
2880 {
2881 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2882 fake.clear_find(&mut ctx);
2883 }
2884 assert_eq!(
2885 find_broadcasts(&out).0,
2886 0,
2887 "already-empty clear_find is a no-op"
2888 );
2889 }
2890
2891 #[test]
2892 fn find_match_first_occurrence_char_indexed() {
2893 assert_eq!(find_match("banana", "an"), Some((1, 3)), "middle");
2894 assert_eq!(find_match("banana", "ba"), Some((0, 2)), "start");
2895 assert_eq!(find_match("banana", "na"), Some((2, 4)), "first of repeats");
2896 assert_eq!(
2897 find_match("Banana", "an"),
2898 Some((1, 3)),
2899 "case-insensitive text"
2900 );
2901 assert_eq!(
2902 find_match("banana", "BAN"),
2903 Some((0, 3)),
2904 "case-insensitive query"
2905 );
2906 assert_eq!(find_match("banana", "xyz"), None, "no match");
2907 assert_eq!(find_match("ab", ""), None, "empty query");
2908 assert_eq!(find_match("a", "abc"), None, "query longer than text");
2909 assert_eq!(
2910 find_match("café", "é"),
2911 Some((3, 4)),
2912 "multibyte char index"
2913 );
2914 assert_eq!(find_match("naïve", "ï"), Some((2, 3)), "multibyte mid-word");
2915 }
2916
2917 #[test]
2918 fn filtered_view_narrows_only_in_filter_mode() {
2919 let src = vec!["apple".to_string(), "banana".into(), "orange".into()];
2920 assert_eq!(
2921 filtered_view(&src, FindMode::Off, "an"),
2922 src,
2923 "Off: full source"
2924 );
2925 assert_eq!(
2926 filtered_view(&src, FindMode::Highlight, "an"),
2927 src,
2928 "Highlight: full source"
2929 );
2930 assert_eq!(
2931 filtered_view(&src, FindMode::Filter, ""),
2932 src,
2933 "empty query: full source"
2934 );
2935 assert_eq!(
2936 filtered_view(&src, FindMode::Filter, "an"),
2937 vec!["banana".to_string(), "orange".into()],
2938 "Filter narrows, order preserved"
2939 );
2940 }
2941
2942 #[test]
2945 fn find_mode_accumulates_query_and_broadcasts_on_change() {
2946 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(5), None, None);
2947 fake.lv.find_mode = FindMode::Highlight;
2948 let mut out = VecDeque::new();
2949 let mut timers = crate::timer::TimerQueue::new();
2950 let mut deferred = vec![];
2951 for c in ['a', 'b', ' ', 'c'] {
2952 let mut ev = key_ev(Key::Char(c));
2953 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2954 fake.handle_event(&mut ev, &mut ctx);
2955 assert!(ev.is_nothing(), "find key consumed");
2956 }
2957 assert_eq!(fake.lv.query, "ab c", "Space appends to the query");
2958 let broadcasts = out
2959 .iter()
2960 .filter(|e| {
2961 matches!(e,
2962 Event::Broadcast { command, .. } if *command == Command::LIST_FIND_CHANGED)
2963 })
2964 .count();
2965 assert_eq!(broadcasts, 4, "one broadcast per query change");
2966 }
2967
2968 #[test]
2969 fn find_backspace_and_esc_behaviour() {
2970 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(5), None, None);
2971 fake.lv.find_mode = FindMode::Highlight;
2972 let mut out = VecDeque::new();
2973 let mut timers = crate::timer::TimerQueue::new();
2974 let mut deferred = vec![];
2975
2976 fake.lv.query = "ab".into();
2978 {
2979 let mut ev = key_ev(Key::Backspace);
2980 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2981 fake.handle_event(&mut ev, &mut ctx);
2982 assert!(ev.is_nothing());
2983 }
2984 assert_eq!(fake.lv.query, "a");
2985
2986 fake.lv.query.clear();
2988 out.clear();
2989 {
2990 let mut ev = key_ev(Key::Backspace);
2991 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
2992 fake.handle_event(&mut ev, &mut ctx);
2993 assert!(!ev.is_nothing(), "empty Backspace propagates");
2994 }
2995 assert!(out.is_empty(), "no broadcast on a no-op Backspace");
2996
2997 fake.lv.query = "ab".into();
2999 {
3000 let mut ev = key_ev(Key::Esc);
3001 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
3002 fake.handle_event(&mut ev, &mut ctx);
3003 assert!(ev.is_nothing(), "Esc with a query is consumed");
3004 }
3005 assert_eq!(fake.lv.query, "");
3006
3007 {
3009 let mut ev = key_ev(Key::Esc);
3010 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
3011 fake.handle_event(&mut ev, &mut ctx);
3012 assert!(!ev.is_nothing(), "empty-query Esc propagates");
3013 }
3014 }
3015
3016 #[test]
3017 fn find_mode_lets_arrows_navigate_and_keeps_query() {
3018 let mut fake = FakeList::new(Rect::new(0, 0, 10, 5), 1, items(5), None, None);
3019 fake.lv.find_mode = FindMode::Highlight;
3020 fake.lv.query = "a".into();
3021 fake.lv.focused = 0;
3022 let mut out = VecDeque::new();
3023 let mut timers = crate::timer::TimerQueue::new();
3024 let mut deferred = vec![];
3025 let mut ev = key_ev(Key::Down);
3026 {
3027 let mut ctx = make_ctx(&mut out, &mut timers, &mut deferred);
3028 fake.handle_event(&mut ev, &mut ctx);
3029 }
3030 assert_eq!(fake.lv.focused, 1, "Down still navigates in find mode");
3031 assert_eq!(fake.lv.query, "a", "query persists across navigation");
3032 }
3033}