Skip to main content

quickgui/
autocomplete.rs

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
11/// Maximum option rows mounted by one autocomplete popover before virtual scrolling takes over.
12pub const MAX_AUTOCOMPLETE_VISIBLE_ROWS: usize = 64;
13/// Maximum UTF-8 bytes retained for one free-form autocomplete value.
14pub 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/// Structural geometry for the separate native suggestion surface.
21///
22/// No color, typography, border, radius, shadow, or animation token is retained here.
23#[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/// State supplied to the caller-owned suggestion-surface renderer.
90#[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/// State supplied to one caller-owned suggestion renderer.
99#[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/// What committing a suggestion does to the free-form input value.
109#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
110pub enum AutocompleteSelectionBehavior {
111    /// Replace the current free-form value with the committed suggestion label.
112    #[default]
113    CompleteInput,
114    /// Report the suggestion while preserving the exact free-form value.
115    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
156/// A per-instance path from the owning view to one autocomplete's retained state.
157///
158/// The outer hop is a cloneable [`StateAccessor`] so a host that declares many autocompletes in
159/// one view can address each one; the inner hop stays a plain projection because it depends only
160/// on the wrapping state's type, never on which instance is being edited.
161pub(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
192/// Controlled, free-form autocomplete state with an overflow-capable native suggestion panel.
193///
194/// The owner input remains the native key and IME target. The visual child panel is never key,
195/// while a bounded semantic listbox proxy remains in the owner's AccessKit tree. Closed state owns
196/// no native window, entity, timer, task, observer, renderer, or scheduler source.
197pub 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    /// Install an application-supplied filter predicate before a runtime context exists.
260    ///
261    /// This is Base UI's `filter` prop. The predicate replaces [`Self::filter_mode`] entirely;
262    /// [`Self::set_filter`] passing `None` restores it.
263    pub fn with_filter(mut self, filter: PickerFilter) -> Self {
264        self.picker.set_filter(Some(filter));
265        self
266    }
267
268    /// Set the initial free-form value before a runtime context exists.
269    ///
270    /// This is the constructor-time equivalent of [`Self::set_value`]: a state that has never been
271    /// mounted owns no popover to synchronize, so no [`EventContext`] is needed. The value is
272    /// bounded by [`MAX_AUTOCOMPLETE_VALUE_BYTES`] exactly as it is at runtime.
273    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    /// Replace native popover geometry, closing an open fixed-size child first.
284    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    /// Replace the free-form value and recompute or forward the bounded suggestion query.
315    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    /// Atomically replace suggestions and update an open child without reopening its surface.
348    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    /// The application-supplied filter predicate, when one is installed.
376    pub fn filter(&self) -> Option<&PickerFilter> {
377        self.picker.filter()
378    }
379
380    /// Replace the built-in filter policy with an application-supplied predicate.
381    ///
382    /// Passing `None` restores [`Self::filter_mode`]. The open suggestion surface, if any, is
383    /// resynchronized exactly once.
384    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    /// Build the complete unstyled interaction from caller-owned input, popover, and row elements.
518    #[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    /// Build the autocomplete against a per-instance retained-state accessor.
553    ///
554    /// A host that renders many declared autocompletes through one view passes an accessor that
555    /// captures which [`AutocompleteState`] each registered listener resolves.
556    #[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    /// Internal composition hook shared with the constrained combobox.
597    ///
598    /// The public free-form API intentionally reports only the application value. A constrained
599    /// combobox additionally needs the exact source identity and every dismissal path so it can
600    /// restore its last committed label without duplicating the native popover engine.
601    #[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}