1use std::{fmt, ops::Range, sync::Arc};
2
3use crate::{
4 AccessibilityAutoComplete, AccessibilityPopover, AccessibilityRole, AnchorPlacement,
5 ComboboxConfirm, ComboboxNext, ComboboxPageDown, ComboboxPageUp, ComboboxPrevious, Element,
6 ElementId, Entity, EventContext, FocusHandle, Key, MAX_VALIDATION_MESSAGE_BYTES, PickerError,
7 PickerFilter, PickerFilterMode, PickerItem, PickerState, StateAccessor, View, ViewContext,
8 VirtualList, WindowHandle, div, element::ElementKind,
9};
10
11pub const MAX_AUTOCOMPLETE_VISIBLE_ROWS: usize = 64;
13pub const MAX_AUTOCOMPLETE_VALUE_BYTES: usize = 64 * 1024;
15
16const AUTOCOMPLETE_KEY_CONTEXT: &str = "Combobox";
17const SURFACE_ID_TAG: u64 = 0xd12d_e762_27b8_d77d;
18const OPTION_ID_TAG: u64 = 0x7673_faca_7f67_69de;
19
20#[derive(Clone, Copy, Debug, PartialEq)]
24pub struct AutocompletePopoverLayout {
25 pub width: f32,
26 pub row_height: f32,
27 pub max_visible_rows: usize,
28 pub placement: AnchorPlacement,
29 pub anchor_gap: f32,
30}
31
32impl AutocompletePopoverLayout {
33 pub fn new(width: f32, row_height: f32) -> Self {
34 Self {
35 width: finite_clamped(width, 1.0, 4_096.0, 280.0),
36 row_height: finite_clamped(row_height, 20.0, 256.0, 36.0),
37 max_visible_rows: 8,
38 placement: AnchorPlacement::BottomStart,
39 anchor_gap: 4.0,
40 }
41 }
42
43 pub fn width(mut self, width: f32) -> Self {
44 self.width = finite_clamped(width, 1.0, 4_096.0, 280.0);
45 self
46 }
47
48 pub fn row_height(mut self, row_height: f32) -> Self {
49 self.row_height = finite_clamped(row_height, 20.0, 256.0, 36.0);
50 self
51 }
52
53 pub fn max_visible_rows(mut self, rows: usize) -> Self {
54 self.max_visible_rows = rows.clamp(1, MAX_AUTOCOMPLETE_VISIBLE_ROWS);
55 self
56 }
57
58 pub const fn placement(mut self, placement: AnchorPlacement) -> Self {
59 self.placement = placement;
60 self
61 }
62
63 pub fn anchor_gap(mut self, gap: f32) -> Self {
64 self.anchor_gap = finite_clamped(gap, 0.0, 512.0, 4.0);
65 self
66 }
67
68 fn sanitized(mut self) -> Self {
69 self.width = finite_clamped(self.width, 1.0, 4_096.0, 280.0);
70 self.row_height = finite_clamped(self.row_height, 20.0, 256.0, 36.0);
71 self.max_visible_rows = self
72 .max_visible_rows
73 .clamp(1, MAX_AUTOCOMPLETE_VISIBLE_ROWS);
74 self.anchor_gap = finite_clamped(self.anchor_gap, 0.0, 512.0, 4.0);
75 self
76 }
77
78 fn popover_height(self) -> f32 {
79 self.max_visible_rows as f32 * self.row_height
80 }
81}
82
83impl Default for AutocompletePopoverLayout {
84 fn default() -> Self {
85 Self::new(280.0, 36.0)
86 }
87}
88
89#[derive(Clone, Copy, Debug, Eq, PartialEq)]
91pub struct AutocompleteListState {
92 pub result_count: usize,
93 pub total_match_count: usize,
94 pub active_index: Option<usize>,
95 pub results_truncated: bool,
96}
97
98#[derive(Clone, Debug, PartialEq)]
100pub struct AutocompleteOptionState {
101 pub result_index: usize,
102 pub source_index: usize,
103 pub active: bool,
104 pub disabled: bool,
105 pub label_ranges: Arc<[Range<usize>]>,
106}
107
108#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
110pub enum AutocompleteSelectionBehavior {
111 #[default]
113 CompleteInput,
114 DismissOnly,
116}
117
118#[derive(Clone, Debug, PartialEq)]
119struct AutocompleteMatchSnapshot {
120 result_index: usize,
121 source_index: usize,
122 label_ranges: Arc<[Range<usize>]>,
123}
124
125struct AutocompletePopoverSnapshot<T> {
126 items: Arc<[PickerItem<T>]>,
127 matches: Arc<[AutocompleteMatchSnapshot]>,
128 total_match_count: usize,
129 active_index: Option<usize>,
130 source_revision: u64,
131}
132
133impl<T> Clone for AutocompletePopoverSnapshot<T> {
134 fn clone(&self) -> Self {
135 Self {
136 items: self.items.clone(),
137 matches: self.matches.clone(),
138 total_match_count: self.total_match_count,
139 active_index: self.active_index,
140 source_revision: self.source_revision,
141 }
142 }
143}
144
145impl<T> AutocompletePopoverSnapshot<T> {
146 fn list_state(&self) -> AutocompleteListState {
147 AutocompleteListState {
148 result_count: self.matches.len(),
149 total_match_count: self.total_match_count,
150 active_index: self.active_index,
151 results_truncated: self.total_match_count > self.matches.len(),
152 }
153 }
154}
155
156pub(crate) struct AutocompleteAccess<V: 'static, S: 'static, T> {
162 outer: StateAccessor<V, S>,
163 inner: fn(&mut S) -> &mut AutocompleteState<T>,
164}
165
166impl<V: 'static, S: 'static, T> Clone for AutocompleteAccess<V, S, T> {
167 fn clone(&self) -> Self {
168 Self {
169 outer: self.outer.clone(),
170 inner: self.inner,
171 }
172 }
173}
174
175impl<V: 'static, S: 'static, T> AutocompleteAccess<V, S, T> {
176 pub(crate) fn new(
177 outer: StateAccessor<V, S>,
178 inner: fn(&mut S) -> &mut AutocompleteState<T>,
179 ) -> Self {
180 Self { outer, inner }
181 }
182
183 fn get<'a>(&self, view: &'a mut V) -> &'a mut AutocompleteState<T> {
184 (self.inner)(self.outer.get(view))
185 }
186}
187
188fn autocomplete_identity<T>(state: &mut AutocompleteState<T>) -> &mut AutocompleteState<T> {
189 state
190}
191
192pub struct AutocompleteState<T> {
198 picker: PickerState<T>,
199 value: Arc<str>,
200 popover: Option<WindowHandle>,
201 popover_snapshot: Option<Entity<AutocompletePopoverSnapshot<T>>>,
202 source_revision: u64,
203 disabled: bool,
204 invalid: bool,
205 validation_message: Option<Arc<str>>,
206 validation_message_truncated: bool,
207 layout: AutocompletePopoverLayout,
208 selection_behavior: AutocompleteSelectionBehavior,
209}
210
211impl<T> fmt::Debug for AutocompleteState<T> {
212 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
213 formatter
214 .debug_struct("AutocompleteState")
215 .field("picker", &self.picker)
216 .field("value", &self.value)
217 .field("popover", &self.popover)
218 .field("popover_snapshot", &self.popover_snapshot)
219 .field("source_revision", &self.source_revision)
220 .field("disabled", &self.disabled)
221 .field("invalid", &self.invalid)
222 .field(
223 "validation_message_truncated",
224 &self.validation_message_truncated,
225 )
226 .field("layout", &self.layout)
227 .field("selection_behavior", &self.selection_behavior)
228 .finish_non_exhaustive()
229 }
230}
231
232impl<T> AutocompleteState<T> {
233 pub fn new(items: impl IntoIterator<Item = PickerItem<T>>) -> Result<Self, PickerError> {
234 Ok(Self {
235 picker: PickerState::new(items)?,
236 value: Arc::from(""),
237 popover: None,
238 popover_snapshot: None,
239 source_revision: 1,
240 disabled: false,
241 invalid: false,
242 validation_message: None,
243 validation_message_truncated: false,
244 layout: AutocompletePopoverLayout::default(),
245 selection_behavior: AutocompleteSelectionBehavior::CompleteInput,
246 })
247 }
248
249 pub fn with_layout(mut self, layout: AutocompletePopoverLayout) -> Self {
250 self.layout = layout.sanitized();
251 self
252 }
253
254 pub fn with_filter_mode(mut self, filter_mode: PickerFilterMode) -> Self {
255 self.picker.set_filter_mode(filter_mode);
256 self
257 }
258
259 pub fn with_filter(mut self, filter: PickerFilter) -> Self {
264 self.picker.set_filter(Some(filter));
265 self
266 }
267
268 pub fn with_value(mut self, value: impl Into<Arc<str>>) -> Self {
274 self.value = bounded_value(value.into());
275 self.picker.set_query(&self.value);
276 self
277 }
278
279 pub const fn layout(&self) -> AutocompletePopoverLayout {
280 self.layout
281 }
282
283 pub fn set_layout(&mut self, layout: AutocompletePopoverLayout, cx: &mut EventContext) -> bool {
285 let layout = layout.sanitized();
286 if self.layout == layout {
287 return false;
288 }
289 self.layout = layout;
290 self.close(cx);
291 true
292 }
293
294 pub const fn selection_behavior(&self) -> AutocompleteSelectionBehavior {
295 self.selection_behavior
296 }
297
298 pub fn set_selection_behavior(&mut self, behavior: AutocompleteSelectionBehavior) -> bool {
299 if self.selection_behavior == behavior {
300 return false;
301 }
302 self.selection_behavior = behavior;
303 true
304 }
305
306 pub fn value(&self) -> &Arc<str> {
307 &self.value
308 }
309
310 pub(crate) fn picker_query(&self) -> &Arc<str> {
311 self.picker.query()
312 }
313
314 pub fn set_value(&mut self, value: impl Into<Arc<str>>, cx: &mut EventContext) -> bool {
316 let value = bounded_value(value.into());
317 if self.value == value {
318 return false;
319 }
320 self.value = value;
321 self.picker.set_query(&self.value);
322 self.sync_popover(cx);
323 true
324 }
325
326 pub(crate) fn set_display_value(&mut self, value: impl Into<Arc<str>>) -> bool {
327 let value = bounded_value(value.into());
328 if self.value == value {
329 return false;
330 }
331 self.value = value;
332 true
333 }
334
335 pub(crate) fn set_query_only(&mut self, query: &str, cx: &mut EventContext) -> bool {
336 if !self.picker.set_query(query) {
337 return false;
338 }
339 self.sync_popover(cx);
340 true
341 }
342
343 pub fn items(&self) -> &[PickerItem<T>] {
344 self.picker.items()
345 }
346
347 pub fn set_items(
349 &mut self,
350 items: impl IntoIterator<Item = PickerItem<T>>,
351 cx: &mut EventContext,
352 ) -> Result<(), PickerError> {
353 self.picker.set_items(items)?;
354 self.source_revision = self.source_revision.wrapping_add(1).max(1);
355 self.sync_popover(cx);
356 Ok(())
357 }
358
359 pub const fn filter_mode(&self) -> PickerFilterMode {
360 self.picker.filter_mode()
361 }
362
363 pub fn set_filter_mode(
364 &mut self,
365 filter_mode: PickerFilterMode,
366 cx: &mut EventContext,
367 ) -> bool {
368 if !self.picker.set_filter_mode(filter_mode) {
369 return false;
370 }
371 self.sync_popover(cx);
372 true
373 }
374
375 pub fn filter(&self) -> Option<&PickerFilter> {
377 self.picker.filter()
378 }
379
380 pub fn set_filter(&mut self, filter: Option<PickerFilter>, cx: &mut EventContext) -> bool {
385 if !self.picker.set_filter(filter) {
386 return false;
387 }
388 self.sync_popover(cx);
389 true
390 }
391
392 pub const fn popover_window(&self) -> Option<WindowHandle> {
393 self.popover
394 }
395
396 pub const fn is_open(&self) -> bool {
397 self.popover.is_some()
398 }
399
400 pub const fn is_disabled(&self) -> bool {
401 self.disabled
402 }
403
404 pub fn set_disabled(&mut self, disabled: bool, cx: &mut EventContext) -> bool {
405 if self.disabled == disabled {
406 return false;
407 }
408 self.disabled = disabled;
409 if disabled {
410 self.close(cx);
411 }
412 true
413 }
414
415 pub const fn is_invalid(&self) -> bool {
416 self.invalid
417 }
418
419 pub fn set_invalid(&mut self, invalid: bool) -> bool {
420 if self.invalid == invalid {
421 return false;
422 }
423 self.invalid = invalid;
424 true
425 }
426
427 pub fn validation_message(&self) -> Option<&Arc<str>> {
428 self.validation_message.as_ref()
429 }
430
431 pub fn set_validation_message(&mut self, message: impl Into<Arc<str>>) -> bool {
432 let (message, truncated) = bounded_validation_message(message.into());
433 if self.validation_message == message && self.validation_message_truncated == truncated {
434 return false;
435 }
436 self.validation_message = message;
437 self.validation_message_truncated = truncated;
438 true
439 }
440
441 pub fn clear_validation_message(&mut self) -> bool {
442 if self.validation_message.take().is_none() && !self.validation_message_truncated {
443 return false;
444 }
445 self.validation_message_truncated = false;
446 true
447 }
448
449 pub fn result_count(&self) -> usize {
450 self.picker.result_count()
451 }
452
453 pub fn total_match_count(&self) -> usize {
454 self.picker.total_match_count()
455 }
456
457 pub fn active_result_index(&self) -> Option<usize> {
458 self.picker.selected_result_index()
459 }
460
461 pub fn active_source_index(&self) -> Option<usize> {
462 self.picker.selected_source_index()
463 }
464
465 pub fn close(&mut self, cx: &mut EventContext) -> bool {
466 self.popover_snapshot = None;
467 let Some(popover) = self.popover.take() else {
468 return false;
469 };
470 cx.close_window_handle(popover);
471 true
472 }
473
474 pub fn surface_id(id: impl Into<ElementId>) -> ElementId {
475 derived_autocomplete_id(id.into(), SURFACE_ID_TAG, 0)
476 }
477
478 pub fn option_id_for_source(
479 &self,
480 id: impl Into<ElementId>,
481 source_index: usize,
482 ) -> Option<ElementId> {
483 let item = self.picker.item_at(source_index)?;
484 Some(autocomplete_option_id(id.into(), item, source_index))
485 }
486
487 fn snapshot(&self) -> AutocompletePopoverSnapshot<T> {
488 let mut matches = Vec::with_capacity(self.picker.result_count());
489 for result_index in 0..self.picker.result_count() {
490 let matched = self
491 .picker
492 .match_at(result_index)
493 .expect("bounded autocomplete match exists");
494 matches.push(AutocompleteMatchSnapshot {
495 result_index,
496 source_index: matched.source_index(),
497 label_ranges: matched.shared_label_ranges(),
498 });
499 }
500 AutocompletePopoverSnapshot {
501 items: self.picker.shared_items(),
502 matches: Arc::from(matches),
503 total_match_count: self.picker.total_match_count(),
504 active_index: self.picker.selected_result_index(),
505 source_revision: self.source_revision,
506 }
507 }
508
509 fn sync_popover(&mut self, cx: &mut EventContext) {
510 let Some(entity) = self.popover_snapshot.clone() else {
511 return;
512 };
513 let snapshot = self.snapshot();
514 entity.update(cx, |current, _cx| *current = snapshot);
515 }
516
517 #[allow(clippy::too_many_arguments)]
519 pub fn element<V, PopoverRoot, RenderOption, ValueChanged, Select>(
520 &mut self,
521 cx: &mut ViewContext<'_, V>,
522 id: impl Into<ElementId>,
523 label: impl Into<Arc<str>>,
524 access: fn(&mut V) -> &mut AutocompleteState<T>,
525 input: Element,
526 popover_root: PopoverRoot,
527 render_option: RenderOption,
528 value_changed: ValueChanged,
529 select: Select,
530 ) -> Element
531 where
532 V: 'static,
533 T: Clone + 'static,
534 PopoverRoot: Fn(AutocompleteListState) -> Element + Clone + 'static,
535 RenderOption: Fn(&PickerItem<T>, AutocompleteOptionState) -> Element + Clone + 'static,
536 ValueChanged: Fn(&mut V, Arc<str>, &mut EventContext) + Clone + 'static,
537 Select: Fn(&mut V, T, &mut EventContext) + Clone + 'static,
538 {
539 self.element_with(
540 cx,
541 id,
542 label,
543 StateAccessor::from(access),
544 input,
545 popover_root,
546 render_option,
547 value_changed,
548 select,
549 )
550 }
551
552 #[allow(clippy::too_many_arguments)]
557 pub fn element_with<V, PopoverRoot, RenderOption, ValueChanged, Select>(
558 &mut self,
559 cx: &mut ViewContext<'_, V>,
560 id: impl Into<ElementId>,
561 label: impl Into<Arc<str>>,
562 access: StateAccessor<V, AutocompleteState<T>>,
563 input: Element,
564 popover_root: PopoverRoot,
565 render_option: RenderOption,
566 value_changed: ValueChanged,
567 select: Select,
568 ) -> Element
569 where
570 V: 'static,
571 T: Clone + 'static,
572 PopoverRoot: Fn(AutocompleteListState) -> Element + Clone + 'static,
573 RenderOption: Fn(&PickerItem<T>, AutocompleteOptionState) -> Element + Clone + 'static,
574 ValueChanged: Fn(&mut V, Arc<str>, &mut EventContext) + Clone + 'static,
575 Select: Fn(&mut V, T, &mut EventContext) + Clone + 'static,
576 {
577 let select_with_source =
578 move |view: &mut V, _source_index: usize, value: T, cx: &mut EventContext| {
579 select(view, value, cx);
580 };
581 self.element_with_source(
582 cx,
583 id,
584 label,
585 AutocompleteAccess::new(access, autocomplete_identity::<T>),
586 input,
587 popover_root,
588 render_option,
589 value_changed,
590 select_with_source,
591 |_view, _cx| {},
592 None,
593 )
594 }
595
596 #[allow(clippy::too_many_arguments)]
602 pub(crate) fn element_with_source<
603 V,
604 S,
605 PopoverRoot,
606 RenderOption,
607 ValueChanged,
608 Select,
609 Dismiss,
610 >(
611 &mut self,
612 cx: &mut ViewContext<'_, V>,
613 id: impl Into<ElementId>,
614 label: impl Into<Arc<str>>,
615 access_source: AutocompleteAccess<V, S, T>,
616 input: Element,
617 popover_root: PopoverRoot,
618 render_option: RenderOption,
619 value_changed: ValueChanged,
620 select: Select,
621 dismiss: Dismiss,
622 accessibility_selection: Option<usize>,
623 ) -> Element
624 where
625 V: 'static,
626 S: 'static,
627 T: Clone + 'static,
628 PopoverRoot: Fn(AutocompleteListState) -> Element + Clone + 'static,
629 RenderOption: Fn(&PickerItem<T>, AutocompleteOptionState) -> Element + Clone + 'static,
630 ValueChanged: Fn(&mut V, Arc<str>, &mut EventContext) + Clone + 'static,
631 Select: Fn(&mut V, usize, T, &mut EventContext) + Clone + 'static,
632 Dismiss: Fn(&mut V, &mut EventContext) + Clone + 'static,
633 {
634 let mut input = input;
635 match &mut input.kind {
636 ElementKind::TextInput(input) if !input.multiline => {
637 if input.value != self.value {
638 input.value = self.value.clone();
639 input.highlights = Arc::from([]);
640 }
641 }
642 _ => panic!("AutocompleteState::element requires a single-line text_input element"),
643 }
644 let id = id.into();
645 let label = label.into();
646 let focus = FocusHandle::new(id);
647 let surface_id = Self::surface_id(id);
648 let renderers = AutocompleteRenderers {
649 popover_root,
650 render_option,
651 };
652 let layout = self.layout;
653 self.picker
654 .set_result_viewport_height(layout.popover_height());
655 if let Some(active) = self.picker.selected_result_index() {
656 self.picker.select_result(active);
657 }
658
659 let child_dismiss = dismiss.clone();
660 let access = access_source.clone();
661 cx.on_any_child_window_closed(move |view, closed, cx| {
662 let state = access.get(view);
663 if state.popover == Some(closed) {
664 state.popover = None;
665 state.popover_snapshot = None;
666 child_dismiss(view, cx);
667 cx.invalidate();
668 }
669 });
670
671 let access = access_source.clone();
672 let preview = cx.action_listener(id, move |view, action: &AutocompletePreview, cx| {
673 if action.control != id {
674 cx.propagate();
675 return;
676 }
677 let changed = {
678 let state = access.get(view);
679 if state.popover != Some(action.popover)
680 || state.source_revision != action.source_revision
681 {
682 return;
683 }
684 state.picker.select_result(action.result_index)
685 };
686 if changed {
687 access.get(view).sync_popover(cx);
688 cx.invalidate();
689 }
690 });
691
692 let commit_value_changed = value_changed.clone();
693 let commit_select = select.clone();
694 let access = access_source.clone();
695 let commit = cx.action_listener(id, move |view, action: &AutocompleteCommit, cx| {
696 if action.control != id {
697 cx.propagate();
698 return;
699 }
700 commit_autocomplete_source(
701 view,
702 cx,
703 &access,
704 Some((action.popover, action.source_revision)),
705 action.source_index,
706 &commit_value_changed,
707 &commit_select,
708 );
709 });
710
711 let input_renderers = renderers.clone();
712 let input_label = label.clone();
713 let input_value_changed = value_changed.clone();
714 let access = access_source.clone();
715 let input_listener = cx.input_listener(id, move |view, value, cx| {
716 let (changed, value) = {
717 let state = access.get(view);
718 let changed = state.set_value(value, cx);
719 (changed, state.value.clone())
720 };
721 if changed {
722 input_value_changed(view, value, cx);
723 }
724 open_autocomplete_popover(
725 view,
726 cx,
727 id,
728 input_label.clone(),
729 &access,
730 input_renderers.clone(),
731 );
732 if changed {
733 cx.invalidate();
734 }
735 });
736
737 let click_renderers = renderers.clone();
738 let click_label = label.clone();
739 let access = access_source.clone();
740 let click = cx.listener(id, move |view, cx| {
741 open_autocomplete_popover(
742 view,
743 cx,
744 id,
745 click_label.clone(),
746 &access,
747 click_renderers.clone(),
748 );
749 cx.focus(focus);
750 });
751
752 let previous_renderers = renderers.clone();
753 let previous_label = label.clone();
754 let access = access_source.clone();
755 let previous = cx.action_listener(id, move |view, _: &ComboboxPrevious, cx| {
756 if access.get(view).is_open() {
757 if access.get(view).picker.select_previous() {
758 access.get(view).sync_popover(cx);
759 cx.invalidate();
760 }
761 } else {
762 open_autocomplete_popover(
763 view,
764 cx,
765 id,
766 previous_label.clone(),
767 &access,
768 previous_renderers.clone(),
769 );
770 }
771 });
772 let next_renderers = renderers.clone();
773 let next_label = label.clone();
774 let access = access_source.clone();
775 let next = cx.action_listener(id, move |view, _: &ComboboxNext, cx| {
776 if access.get(view).is_open() {
777 if access.get(view).picker.select_next() {
778 access.get(view).sync_popover(cx);
779 cx.invalidate();
780 }
781 } else {
782 open_autocomplete_popover(
783 view,
784 cx,
785 id,
786 next_label.clone(),
787 &access,
788 next_renderers.clone(),
789 );
790 }
791 });
792 let page_up_renderers = renderers.clone();
793 let page_up_label = label.clone();
794 let access = access_source.clone();
795 let page_up = cx.action_listener(id, move |view, _: &ComboboxPageUp, cx| {
796 if access.get(view).is_open() {
797 if access.get(view).picker.select_page_up() {
798 access.get(view).sync_popover(cx);
799 cx.invalidate();
800 }
801 } else {
802 open_autocomplete_popover(
803 view,
804 cx,
805 id,
806 page_up_label.clone(),
807 &access,
808 page_up_renderers.clone(),
809 );
810 }
811 });
812 let page_down_renderers = renderers;
813 let page_down_label = label.clone();
814 let access = access_source.clone();
815 let page_down = cx.action_listener(id, move |view, _: &ComboboxPageDown, cx| {
816 if access.get(view).is_open() {
817 if access.get(view).picker.select_page_down() {
818 access.get(view).sync_popover(cx);
819 cx.invalidate();
820 }
821 } else {
822 open_autocomplete_popover(
823 view,
824 cx,
825 id,
826 page_down_label.clone(),
827 &access,
828 page_down_renderers.clone(),
829 );
830 }
831 });
832
833 let confirm_value_changed = value_changed;
834 let confirm_select = select;
835 let access = access_source.clone();
836 let confirm = cx.action_listener(id, move |view, _: &ComboboxConfirm, cx| {
837 let source_index = access.get(view).active_source_index();
838 let Some(source_index) = source_index else {
839 cx.propagate();
840 return;
841 };
842 if !commit_autocomplete_source(
843 view,
844 cx,
845 &access,
846 None,
847 source_index,
848 &confirm_value_changed,
849 &confirm_select,
850 ) {
851 cx.propagate();
852 }
853 });
854
855 let key_dismiss = dismiss.clone();
856 let access = access_source.clone();
857 let key_down = cx.key_down_listener(id, move |view, event, cx| {
858 if event.key == Key::Escape {
859 if access.get(view).close(cx) {
860 key_dismiss(view, cx);
861 cx.invalidate();
862 cx.prevent_default();
863 cx.stop_propagation();
864 }
865 } else if event.key == Key::Tab && access.get(view).close(cx) {
866 key_dismiss(view, cx);
867 cx.invalidate();
868 }
869 });
870
871 let mut input = input
872 .id(id)
873 .track_focus(focus)
874 .on_input(input_listener)
875 .on_click(click)
876 .on_key_down(key_down)
877 .key_context(AUTOCOMPLETE_KEY_CONTEXT)
878 .on_action(preview)
879 .on_action(commit)
880 .on_action(previous)
881 .on_action(next)
882 .on_action(page_up)
883 .on_action(page_down)
884 .on_action(confirm)
885 .accessibility_role(AccessibilityRole::EditableComboBox)
886 .accessibility_label(label.clone())
887 .accessibility_auto_complete(AccessibilityAutoComplete::List)
888 .accessibility_has_popover(AccessibilityPopover::ListBox)
889 .accessibility_expanded(self.is_open())
890 .disabled(self.disabled)
891 .invalid(self.invalid)
892 .app_region_no_drag()
893 .cursor_text();
894 if let Some(message) = self.validation_message.clone() {
895 input = input.validation_message_retained(message, self.validation_message_truncated);
896 }
897
898 let mut proxy = None;
899 if self.is_open() {
900 let outside_dismiss = dismiss;
901 let access = access_source.clone();
902 let outside = cx.mouse_down_listener(id, move |view, _event, cx| {
903 if access.get(view).close(cx) {
904 outside_dismiss(view, cx);
905 cx.invalidate();
906 }
907 });
908 input = input.on_mouse_down_out(outside);
909 input = input.accessibility_controls(surface_id);
910 if let Some(active) = self.picker.selected_result_index()
911 && let Some(matched) = self.picker.match_at(active)
912 {
913 input = input.accessibility_active_descendant(autocomplete_option_id(
914 id,
915 matched.item(),
916 matched.source_index(),
917 ));
918 }
919 proxy = Some(self.accessibility_proxy(id, label, surface_id, accessibility_selection));
920 }
921
922 let mut root = div().relative().child(input);
923 if let Some(proxy) = proxy {
924 root = root.child(proxy);
925 }
926 root
927 }
928
929 fn accessibility_proxy(
930 &self,
931 id: ElementId,
932 label: Arc<str>,
933 surface_id: ElementId,
934 committed_source: Option<usize>,
935 ) -> Element {
936 let visible = self.picker.virtual_list().visible_rows().range;
937 let active = self.picker.selected_result_index();
938 let mut result_indices = visible.collect::<Vec<_>>();
939 if let Some(active) = active
940 && !result_indices.contains(&active)
941 {
942 result_indices.push(active);
943 }
944 if let Some(committed_source) = committed_source
945 && let Some(committed_result) = (0..self.picker.result_count()).find(|result_index| {
946 self.picker
947 .match_at(*result_index)
948 .is_some_and(|matched| matched.source_index() == committed_source)
949 })
950 && !result_indices.contains(&committed_result)
951 {
952 result_indices.push(committed_result);
953 }
954 result_indices.sort_unstable();
955 result_indices.dedup();
956 result_indices.truncate(MAX_AUTOCOMPLETE_VISIBLE_ROWS.saturating_add(4));
957
958 let mut options = Vec::with_capacity(result_indices.len());
959 for result_index in result_indices {
960 let Some(matched) = self.picker.match_at(result_index) else {
961 continue;
962 };
963 let item = matched.item();
964 options.push(
965 div()
966 .id(autocomplete_option_id(id, item, matched.source_index()))
967 .accessibility_role(AccessibilityRole::ListBoxOption)
968 .accessibility_label(item.label().clone())
969 .accessibility_position_in_set(result_index)
970 .accessibility_size_of_set(self.picker.result_count())
971 .selected(
972 committed_source.map_or(active == Some(result_index), |source| {
973 source == matched.source_index()
974 }),
975 )
976 .disabled(item.is_disabled())
977 .absolute()
978 .size(1.0, 1.0),
979 );
980 }
981 div()
982 .id(surface_id)
983 .absolute()
984 .size(1.0, 1.0)
985 .overflow_hidden()
986 .accessibility_role(AccessibilityRole::ListBox)
987 .accessibility_label(label)
988 .accessibility_size_of_set(self.picker.result_count())
989 .children(options)
990 }
991}
992
993#[derive(Clone)]
994struct AutocompleteRenderers<PopoverRoot, RenderOption> {
995 popover_root: PopoverRoot,
996 render_option: RenderOption,
997}
998
999#[derive(Clone, Copy, Debug, Eq, PartialEq)]
1000struct AutocompletePreview {
1001 control: ElementId,
1002 popover: WindowHandle,
1003 source_revision: u64,
1004 result_index: usize,
1005}
1006
1007#[derive(Clone, Copy, Debug, Eq, PartialEq)]
1008struct AutocompleteCommit {
1009 control: ElementId,
1010 popover: WindowHandle,
1011 source_revision: u64,
1012 source_index: usize,
1013}
1014
1015fn open_autocomplete_popover<V, S, T, PopoverRoot, RenderOption>(
1016 view: &mut V,
1017 cx: &mut EventContext,
1018 id: ElementId,
1019 label: Arc<str>,
1020 access: &AutocompleteAccess<V, S, T>,
1021 renderers: AutocompleteRenderers<PopoverRoot, RenderOption>,
1022) where
1023 V: 'static,
1024 S: 'static,
1025 T: Clone + 'static,
1026 PopoverRoot: Fn(AutocompleteListState) -> Element + Clone + 'static,
1027 RenderOption: Fn(&PickerItem<T>, AutocompleteOptionState) -> Element + Clone + 'static,
1028{
1029 let (snapshot, layout) = {
1030 let state = access.get(view);
1031 if state.disabled || state.popover.is_some() {
1032 return;
1033 }
1034 (state.snapshot(), state.layout)
1035 };
1036 let entity = Entity::new(snapshot);
1037 let popover = AutocompletePopoverView::new(id, entity.clone(), layout, renderers);
1038 let result = crate::SystemPopover::new(layout.width, layout.popover_height())
1039 .placement(layout.placement)
1040 .gap(layout.anchor_gap)
1041 .grab(false)
1042 .accepts_key_focus(false)
1043 .open(cx, id, label.to_string(), popover);
1044 if let Ok(handle) = result {
1045 let state = access.get(view);
1046 state.popover = Some(handle);
1047 state.popover_snapshot = Some(entity);
1048 cx.invalidate();
1049 }
1050}
1051
1052fn commit_autocomplete_source<V, S, T, ValueChanged, Select>(
1053 view: &mut V,
1054 cx: &mut EventContext,
1055 access: &AutocompleteAccess<V, S, T>,
1056 expected: Option<(WindowHandle, u64)>,
1057 source_index: usize,
1058 value_changed: &ValueChanged,
1059 select: &Select,
1060) -> bool
1061where
1062 S: 'static,
1063 T: Clone,
1064 ValueChanged: Fn(&mut V, Arc<str>, &mut EventContext),
1065 Select: Fn(&mut V, usize, T, &mut EventContext),
1066{
1067 let (value, completed_value) = {
1068 let state = access.get(view);
1069 let Some(popover) = state.popover else {
1070 return false;
1071 };
1072 if let Some((expected_popover, expected_revision)) = expected
1073 && (popover != expected_popover || state.source_revision != expected_revision)
1074 {
1075 return false;
1076 }
1077 let Some(item) = state
1078 .picker
1079 .item_at(source_index)
1080 .filter(|item| !item.is_disabled())
1081 else {
1082 return false;
1083 };
1084 let value = item.value().clone();
1085 let label = item.label().clone();
1086 let completed_value = if state.selection_behavior
1087 == AutocompleteSelectionBehavior::CompleteInput
1088 && state.value != label
1089 {
1090 state.value = label.clone();
1091 state.picker.set_query(&label);
1092 Some(label)
1093 } else {
1094 None
1095 };
1096 state.close(cx);
1097 (value, completed_value)
1098 };
1099 if let Some(value) = completed_value {
1100 value_changed(view, value, cx);
1101 }
1102 select(view, source_index, value, cx);
1103 cx.invalidate();
1104 true
1105}
1106
1107struct AutocompletePopoverView<T, PopoverRoot, RenderOption> {
1108 control: ElementId,
1109 snapshot: Entity<AutocompletePopoverSnapshot<T>>,
1110 list: VirtualList,
1111 layout: AutocompletePopoverLayout,
1112 renderers: AutocompleteRenderers<PopoverRoot, RenderOption>,
1113}
1114
1115impl<T, PopoverRoot, RenderOption> AutocompletePopoverView<T, PopoverRoot, RenderOption> {
1116 fn new(
1117 control: ElementId,
1118 snapshot: Entity<AutocompletePopoverSnapshot<T>>,
1119 layout: AutocompletePopoverLayout,
1120 renderers: AutocompleteRenderers<PopoverRoot, RenderOption>,
1121 ) -> Self {
1122 let (len, active) =
1123 snapshot.read(|snapshot| (snapshot.matches.len(), snapshot.active_index));
1124 let mut list = VirtualList::new(len, layout.row_height).with_overscan(1);
1125 list.set_viewport_height(layout.popover_height());
1126 if let Some(active) = active {
1127 list.scroll_to_reveal(active);
1128 }
1129 Self {
1130 control,
1131 snapshot,
1132 list,
1133 layout,
1134 renderers,
1135 }
1136 }
1137}
1138
1139impl<T, PopoverRoot, RenderOption> View for AutocompletePopoverView<T, PopoverRoot, RenderOption>
1140where
1141 T: Clone + 'static,
1142 PopoverRoot: Fn(AutocompleteListState) -> Element + Clone + 'static,
1143 RenderOption: Fn(&PickerItem<T>, AutocompleteOptionState) -> Element + Clone + 'static,
1144{
1145 fn render(&mut self, cx: &mut ViewContext<'_, Self>) -> impl crate::IntoElement {
1146 let snapshot = cx.observe(&self.snapshot, Clone::clone);
1147 self.list.set_len(snapshot.matches.len());
1148 self.list.set_viewport_height(self.layout.popover_height());
1149 if let Some(active) = snapshot.active_index {
1150 self.list.scroll_to_reveal(active);
1151 }
1152
1153 let popover = cx.window_handle();
1154 let mut rows = Vec::with_capacity(self.list.visible_rows().len());
1155 for result_index in self.list.visible_rows().range {
1156 let Some(matched) = snapshot.matches.get(result_index) else {
1157 continue;
1158 };
1159 let Some(item) = snapshot.items.get(matched.source_index) else {
1160 continue;
1161 };
1162 let option_state = AutocompleteOptionState {
1163 result_index: matched.result_index,
1164 source_index: matched.source_index,
1165 active: snapshot.active_index == Some(result_index),
1166 disabled: item.is_disabled(),
1167 label_ranges: matched.label_ranges.clone(),
1168 };
1169 let row_id = autocomplete_option_id(self.control, item, matched.source_index);
1170 let mut row = (self.renderers.render_option)(item, option_state.clone())
1171 .id(row_id)
1172 .clickable()
1173 .tab_index(-1)
1174 .disabled(option_state.disabled)
1175 .selected(option_state.active)
1176 .absolute()
1177 .top(result_index as f32 * self.layout.row_height - self.list.scroll_offset())
1178 .left(0.0)
1179 .w_full()
1180 .h(self.layout.row_height)
1181 .app_region_no_drag()
1182 .user_select_none()
1183 .cursor_default();
1184 if !option_state.disabled {
1185 let control = self.control;
1186 let source_revision = snapshot.source_revision;
1187 let hover = cx.hover_listener(row_id, move |_view, hovered, cx| {
1188 if *hovered {
1189 cx.dispatch_action_to_popover_owner(AutocompletePreview {
1190 control,
1191 popover,
1192 source_revision,
1193 result_index,
1194 });
1195 }
1196 });
1197 let source_index = matched.source_index;
1198 let click = cx.listener(row_id, move |_view, cx| {
1199 if cx.dispatch_action_to_popover_owner(AutocompleteCommit {
1200 control,
1201 popover,
1202 source_revision,
1203 source_index,
1204 }) {
1205 cx.close_window();
1206 }
1207 });
1208 row = row.on_hover(hover).on_click(click);
1209 }
1210 rows.push(row);
1211 }
1212
1213 let options = div()
1214 .relative()
1215 .size_full()
1216 .overflow_hidden()
1217 .virtual_scroll(&self.list)
1218 .children(rows);
1219 (self.renderers.popover_root)(snapshot.list_state())
1220 .id(AutocompleteState::<T>::surface_id(self.control))
1221 .size_full()
1222 .overflow_hidden()
1223 .app_region_no_drag()
1224 .user_select_none()
1225 .cursor_default()
1226 .accessibility_hidden(true)
1227 .child(options)
1228 }
1229}
1230
1231fn autocomplete_option_id<T>(
1232 control: ElementId,
1233 item: &PickerItem<T>,
1234 source_index: usize,
1235) -> ElementId {
1236 derived_autocomplete_id(
1237 control,
1238 OPTION_ID_TAG,
1239 item.stable_id()
1240 .map_or(source_index as u64, ElementId::as_u64),
1241 )
1242}
1243
1244fn derived_autocomplete_id(parent: ElementId, tag: u64, value: u64) -> ElementId {
1245 let mut hash = parent.as_u64() ^ tag ^ value.wrapping_mul(0x9e37_79b9_7f4a_7c15);
1246 hash ^= hash >> 30;
1247 hash = hash.wrapping_mul(0xbf58_476d_1ce4_e5b9);
1248 hash ^= hash >> 27;
1249 hash = hash.wrapping_mul(0x94d0_49bb_1331_11eb);
1250 hash ^= hash >> 31;
1251 if hash == 0 || hash == parent.as_u64() || hash == u64::MAX {
1252 hash ^= tag.rotate_left(17);
1253 }
1254 ElementId::new(hash)
1255}
1256
1257fn bounded_value(value: Arc<str>) -> Arc<str> {
1258 if value.len() <= MAX_AUTOCOMPLETE_VALUE_BYTES {
1259 return value;
1260 }
1261 let mut end = MAX_AUTOCOMPLETE_VALUE_BYTES;
1262 while !value.is_char_boundary(end) {
1263 end -= 1;
1264 }
1265 Arc::from(&value[..end])
1266}
1267
1268fn finite_clamped(value: f32, minimum: f32, maximum: f32, fallback: f32) -> f32 {
1269 if value.is_finite() {
1270 value.clamp(minimum, maximum)
1271 } else {
1272 fallback
1273 }
1274}
1275
1276fn bounded_validation_message(message: Arc<str>) -> (Option<Arc<str>>, bool) {
1277 if message.is_empty() {
1278 return (None, false);
1279 }
1280 if message.len() <= MAX_VALIDATION_MESSAGE_BYTES {
1281 return (Some(message), false);
1282 }
1283 let mut end = MAX_VALIDATION_MESSAGE_BYTES;
1284 while !message.is_char_boundary(end) {
1285 end -= 1;
1286 }
1287 (Some(Arc::from(&message[..end])), true)
1288}
1289
1290#[cfg(test)]
1291mod tests {
1292 use super::*;
1293 use crate::{
1294 Application, Color, IntoElement, MouseDownEvent, WindowOptions, button,
1295 combobox_key_bindings, text, text_input,
1296 };
1297
1298 fn options() -> [PickerItem<&'static str>; 4] {
1299 [
1300 PickerItem::new("Apple", "apple").id("apple"),
1301 PickerItem::new("Disabled", "disabled")
1302 .id("disabled")
1303 .disabled(true),
1304 PickerItem::new("Apricot", "apricot").id("apricot"),
1305 PickerItem::new("Banana", "banana").id("banana"),
1306 ]
1307 }
1308
1309 fn popover_root(state: AutocompleteListState) -> Element {
1310 div()
1311 .bg(Color::BLACK)
1312 .child(text(format!("{} results", state.result_count)))
1313 }
1314
1315 fn option_row(item: &PickerItem<&'static str>, state: AutocompleteOptionState) -> Element {
1316 text(item.label().clone())
1317 .opacity(if state.active { 1.0 } else { 0.8 })
1318 .into_element()
1319 }
1320
1321 struct AutocompleteOwner {
1322 autocomplete: AutocompleteState<&'static str>,
1323 values: Vec<Arc<str>>,
1324 selected: Vec<&'static str>,
1325 }
1326
1327 impl AutocompleteOwner {
1328 fn new(behavior: AutocompleteSelectionBehavior) -> Self {
1329 let mut autocomplete = AutocompleteState::new(options())
1330 .unwrap()
1331 .with_layout(AutocompletePopoverLayout::new(220.0, 32.0).max_visible_rows(2));
1332 autocomplete.set_selection_behavior(behavior);
1333 Self {
1334 autocomplete,
1335 values: Vec::new(),
1336 selected: Vec::new(),
1337 }
1338 }
1339
1340 fn autocomplete(view: &mut Self) -> &mut AutocompleteState<&'static str> {
1341 &mut view.autocomplete
1342 }
1343 }
1344
1345 impl View for AutocompleteOwner {
1346 fn render(&mut self, cx: &mut ViewContext<'_, Self>) -> impl crate::IntoElement {
1347 let input = text_input(self.autocomplete.value().clone())
1348 .w(220.0)
1349 .h(36.0);
1350 let autocomplete = self.autocomplete.element(
1351 cx,
1352 "fruit",
1353 "Fruit",
1354 Self::autocomplete,
1355 input,
1356 popover_root,
1357 option_row,
1358 |view, value, _cx| view.values.push(value),
1359 |view, value, _cx| view.selected.push(value),
1360 );
1361 div().children([
1362 autocomplete,
1363 button().id("after-autocomplete").child("After"),
1364 ])
1365 }
1366 }
1367
1368 #[test]
1369 fn with_value_seeds_the_query_and_stays_bounded_before_a_context_exists() {
1370 let state = AutocompleteState::new(options()).unwrap().with_value("ap");
1371 assert_eq!(state.value().as_ref(), "ap");
1372 assert_eq!(state.picker_query().as_ref(), "ap");
1373 assert_eq!(state.result_count(), 2);
1374
1375 let long = "é".repeat(MAX_AUTOCOMPLETE_VALUE_BYTES);
1376 let state = AutocompleteState::new(options()).unwrap().with_value(long);
1377 let retained = state.value();
1378 assert!(retained.len() <= MAX_AUTOCOMPLETE_VALUE_BYTES);
1379 assert!(retained.is_char_boundary(retained.len()));
1380 }
1381
1382 #[test]
1383 fn free_form_value_survives_escape_and_unmatched_return_propagates() {
1384 let (mut cx, owner) = Application::new()
1385 .bind_keys(combobox_key_bindings())
1386 .into_test_context(
1387 WindowOptions::default(),
1388 AutocompleteOwner::new(AutocompleteSelectionBehavior::CompleteInput),
1389 )
1390 .unwrap();
1391 let window = owner.window_handle();
1392 cx.focus(window, "fruit").unwrap();
1393 cx.simulate_input(window, "custom value").unwrap();
1394 assert!(cx.read(owner, |view| view.autocomplete.is_open()).unwrap());
1395 assert_eq!(
1396 cx.read(owner, |view| view.autocomplete.result_count())
1397 .unwrap(),
1398 0
1399 );
1400 cx.simulate_keystrokes(window, "escape").unwrap();
1401 assert_eq!(
1402 cx.read(owner, |view| view.autocomplete.value().clone())
1403 .unwrap(),
1404 Arc::from("custom value")
1405 );
1406 assert!(!cx.read(owner, |view| view.autocomplete.is_open()).unwrap());
1407 assert_eq!(cx.focused(window).unwrap(), Some("fruit".into()));
1408 assert!(!cx.dispatch_action(window, ComboboxConfirm).unwrap());
1409 assert!(cx.read(owner, |view| view.selected.is_empty()).unwrap());
1410
1411 cx.click(window, "fruit").unwrap();
1412 cx.simulate_keystrokes(window, "tab").unwrap();
1413 assert_eq!(
1414 cx.focused(window).unwrap(),
1415 Some("after-autocomplete".into())
1416 );
1417 assert_eq!(
1418 cx.read(owner, |view| view.autocomplete.value().clone())
1419 .unwrap(),
1420 Arc::from("custom value")
1421 );
1422 }
1423
1424 #[test]
1425 fn keyboard_commit_completes_by_default_and_dismiss_only_preserves_text() {
1426 for (behavior, expected_value) in [
1427 (
1428 AutocompleteSelectionBehavior::CompleteInput,
1429 Arc::<str>::from("Apple"),
1430 ),
1431 (
1432 AutocompleteSelectionBehavior::DismissOnly,
1433 Arc::<str>::from("ap"),
1434 ),
1435 ] {
1436 let (mut cx, owner) = Application::new()
1437 .bind_keys(combobox_key_bindings())
1438 .into_test_context(WindowOptions::default(), AutocompleteOwner::new(behavior))
1439 .unwrap();
1440 let window = owner.window_handle();
1441 cx.focus(window, "fruit").unwrap();
1442 cx.simulate_input(window, "ap").unwrap();
1443 cx.simulate_keystrokes(window, "enter").unwrap();
1444
1445 assert_eq!(
1446 cx.read(owner, |view| view.autocomplete.value().clone())
1447 .unwrap(),
1448 expected_value
1449 );
1450 assert_eq!(
1451 cx.read(owner, |view| view.selected.clone()).unwrap(),
1452 vec!["apple"]
1453 );
1454 assert!(!cx.read(owner, |view| view.autocomplete.is_open()).unwrap());
1455 assert_eq!(cx.focused(window).unwrap(), Some("fruit".into()));
1456 }
1457 }
1458
1459 #[test]
1460 fn never_key_child_row_click_commits_without_moving_owner_input_focus() {
1461 let (mut cx, owner) = Application::new()
1462 .bind_keys(combobox_key_bindings())
1463 .into_test_context(
1464 WindowOptions::default(),
1465 AutocompleteOwner::new(AutocompleteSelectionBehavior::CompleteInput),
1466 )
1467 .unwrap();
1468 let window = owner.window_handle();
1469 cx.focus(window, "fruit").unwrap();
1470 cx.click(window, "fruit").unwrap();
1471 let (popover, row) = cx
1472 .read(owner, |view| {
1473 (
1474 view.autocomplete.popover_window().unwrap(),
1475 view.autocomplete.option_id_for_source("fruit", 0).unwrap(),
1476 )
1477 })
1478 .unwrap();
1479 assert_eq!(
1480 cx.window_state(popover).unwrap().kind,
1481 crate::WindowKind::SystemPopover
1482 );
1483 assert_eq!(cx.focused(window).unwrap(), Some("fruit".into()));
1484 cx.click(popover, row).unwrap();
1485
1486 assert!(!cx.is_window_open(popover));
1487 assert_eq!(cx.focused(window).unwrap(), Some("fruit".into()));
1488 assert_eq!(
1489 cx.read(owner, |view| view.selected.clone()).unwrap(),
1490 vec!["apple"]
1491 );
1492 assert_eq!(
1493 cx.read(owner, |view| view.autocomplete.popover_window())
1494 .unwrap(),
1495 None
1496 );
1497 }
1498
1499 #[test]
1500 fn owner_outside_press_closes_without_rewriting_free_form_text() {
1501 let (mut cx, owner) = Application::new()
1502 .bind_keys(combobox_key_bindings())
1503 .into_test_context(
1504 WindowOptions::default(),
1505 AutocompleteOwner::new(AutocompleteSelectionBehavior::CompleteInput),
1506 )
1507 .unwrap();
1508 let window = owner.window_handle();
1509 cx.focus(window, "fruit").unwrap();
1510 cx.simulate_input(window, "custom").unwrap();
1511 let popover = cx
1512 .read(owner, |view| view.autocomplete.popover_window().unwrap())
1513 .unwrap();
1514 assert!(
1515 !cx.simulate_mouse_down(window, "after-autocomplete", MouseDownEvent::default())
1516 .unwrap()
1517 );
1518 assert!(!cx.is_window_open(popover));
1519 assert_eq!(
1520 cx.read(owner, |view| view.autocomplete.value().clone())
1521 .unwrap(),
1522 Arc::from("custom")
1523 );
1524 }
1525
1526 #[test]
1527 fn open_source_replacement_updates_the_same_child_and_rejects_invalid_input() {
1528 let (mut cx, owner) = Application::new()
1529 .bind_keys(combobox_key_bindings())
1530 .into_test_context(
1531 WindowOptions::default(),
1532 AutocompleteOwner::new(AutocompleteSelectionBehavior::CompleteInput),
1533 )
1534 .unwrap();
1535 let window = owner.window_handle();
1536 cx.focus(window, "fruit").unwrap();
1537 cx.click(window, "fruit").unwrap();
1538 let popover = cx
1539 .read(owner, |view| view.autocomplete.popover_window().unwrap())
1540 .unwrap();
1541 cx.update(owner, |view, cx| {
1542 view.autocomplete
1543 .set_items(
1544 [
1545 PickerItem::new("Cherry", "cherry").id("cherry"),
1546 PickerItem::new("Citrus", "citrus").id("citrus"),
1547 ],
1548 cx,
1549 )
1550 .unwrap();
1551 cx.invalidate();
1552 })
1553 .unwrap();
1554 assert_eq!(
1555 cx.read(owner, |view| view.autocomplete.popover_window())
1556 .unwrap(),
1557 Some(popover)
1558 );
1559 let row = cx
1560 .read(owner, |view| {
1561 view.autocomplete.option_id_for_source("fruit", 0).unwrap()
1562 })
1563 .unwrap();
1564 cx.click(popover, row).unwrap();
1565 assert_eq!(
1566 cx.read(owner, |view| view.selected.clone()).unwrap(),
1567 vec!["cherry"]
1568 );
1569
1570 let mut state = AutocompleteState::new(options()).unwrap();
1571 let mut event = EventContext::default();
1572 let error = state
1573 .set_items(
1574 [
1575 PickerItem::new("One", "one").id("duplicate"),
1576 PickerItem::new("Two", "two").id("duplicate"),
1577 ],
1578 &mut event,
1579 )
1580 .unwrap_err();
1581 assert_eq!(
1582 error,
1583 PickerError::DuplicateId {
1584 id: "duplicate".into()
1585 }
1586 );
1587 assert_eq!(state.items().len(), 4);
1588 }
1589
1590 #[test]
1591 fn async_filter_none_value_bounds_and_child_policy_are_exact() {
1592 let mut state = AutocompleteState::new(options())
1593 .unwrap()
1594 .with_filter_mode(PickerFilterMode::None);
1595 let mut cx = EventContext::default();
1596 assert!(state.set_value("not locally matched", &mut cx));
1597 assert_eq!(state.result_count(), options().len());
1598
1599 let oversized = Arc::<str>::from("é".repeat(MAX_AUTOCOMPLETE_VALUE_BYTES));
1600 assert!(state.set_value(oversized, &mut cx));
1601 assert!(state.value().len() <= MAX_AUTOCOMPLETE_VALUE_BYTES);
1602 assert!(state.value().is_char_boundary(state.value().len()));
1603
1604 let options = crate::SystemPopover::new(240.0, 120.0)
1605 .grab(false)
1606 .accepts_key_focus(false)
1607 .window_options("Autocomplete");
1608 let popover = options.popover.expect("system popover options");
1609 assert!(!options.focus);
1610 assert!(!popover.grab);
1611 assert!(!popover.accepts_key_focus);
1612 }
1613
1614 #[test]
1615 fn large_sources_mount_only_visible_child_rows_and_settled_windows_sleep() {
1616 let items = (0..20_000).map(|index| PickerItem::new(format!("Item {index}"), index));
1617 let mut state = AutocompleteState::new(items)
1618 .unwrap()
1619 .with_layout(AutocompletePopoverLayout::new(240.0, 30.0).max_visible_rows(5));
1620 state
1621 .picker
1622 .set_result_viewport_height(state.layout.popover_height());
1623 let snapshot = Entity::new(state.snapshot());
1624 let popover = AutocompletePopoverView::new(
1625 "large-autocomplete".into(),
1626 snapshot,
1627 state.layout,
1628 AutocompleteRenderers {
1629 popover_root: |_state: AutocompleteListState| div(),
1630 render_option: |_item: &PickerItem<usize>, _state: AutocompleteOptionState| div(),
1631 },
1632 );
1633 assert!(popover.list.visible_rows().len() <= 7);
1634
1635 let (mut cx, owner) = Application::new()
1636 .bind_keys(combobox_key_bindings())
1637 .into_test_context(
1638 WindowOptions::default(),
1639 AutocompleteOwner::new(AutocompleteSelectionBehavior::CompleteInput),
1640 )
1641 .unwrap();
1642 let window = owner.window_handle();
1643 cx.focus(window, "fruit").unwrap();
1644 cx.click(window, "fruit").unwrap();
1645 let child = cx
1646 .read(owner, |view| view.autocomplete.popover_window().unwrap())
1647 .unwrap();
1648 let owner_renders = cx.render_count(window).unwrap();
1649 let child_renders = cx.render_count(child).unwrap();
1650 cx.run_until_idle().unwrap();
1651 assert_eq!(cx.render_count(window).unwrap(), owner_renders);
1652 assert_eq!(cx.render_count(child).unwrap(), child_renders);
1653 }
1654}