vizia_core/views/

virtual_list.rs

use std::{
    collections::BTreeSet,
    ops::{Deref, Range},
    time::{Duration, Instant},
};

use crate::prelude::*;

/// A view for creating a list of items from a binding to an iteratable list. Rather than creating a view for each item, items are recycled in the list.
pub struct VirtualList {
    /// Whether the scrollbar should scroll to the cursor when pressed.
    scroll_to_cursor: Signal<bool>,
    /// Callback that is called when the list is scrolled.
    on_scroll: Option<Box<dyn Fn(&mut EventContext, f32, f32) + Send + Sync>>,
    /// The number of items in the list.
    num_items: Signal<usize>,
    /// The extent of each item in the list (height for vertical, width for horizontal).
    item_height: f32,
    /// The orientation of the list, either vertical or horizontal.
    orientation: Signal<Orientation>,
    /// The range of visible items in the list.
    visible_range: Signal<Range<usize>>,
    /// The horizontal scroll position of the list.
    scroll_x: Signal<f32>,
    /// The vertical scroll position of the list.
    scroll_y: Signal<f32>,
    /// Whether the horizontal scrollbar should be visible.
    show_horizontal_scrollbar: Signal<bool>,
    /// Whether the vertical scrollbar should be visible.
    show_vertical_scrollbar: Signal<bool>,
    /// The set of selected items in the list.
    selection: Signal<BTreeSet<usize>>,
    /// The selectable state of the list.
    selectable: Signal<Selectable>,
    /// The index of the currently focused item in the list.
    focused: Signal<Option<usize>>,
    /// Whether focused list items should show focus visibility.
    focus_visibility: Signal<bool>,
    /// Whether the selection should follow the focus.
    selection_follows_focus: Signal<bool>,
    /// Callback that is called when an item is selected.
    on_select: Option<Box<dyn Fn(&mut EventContext, usize)>>,
    /// Returns the searchable text for each item index when type-ahead is enabled.
    type_ahead_text: Option<Box<dyn Fn(&mut EventContext, usize) -> Option<String>>>,
    /// Buffered type-ahead query built from rapid character input.
    type_ahead_buffer: String,
    /// Timestamp of the last accepted type-ahead character.
    type_ahead_last_input: Option<Instant>,
    /// Maximum elapsed time before resetting type-ahead buffer.
    type_ahead_timeout: Duration,
}

impl VirtualList {
    fn find_type_ahead_match(
        &self,
        cx: &mut EventContext,
        query: &str,
        start_index: usize,
    ) -> Option<usize> {
        let get_text = self.type_ahead_text.as_ref()?;
        let num_items = self.num_items.get();
        if num_items == 0 {
            return None;
        }

        for offset in 0..num_items {
            let index = (start_index + offset) % num_items;
            let item_text = get_text(cx, index)
                .map(|text| text.trim_start().to_lowercase())
                .unwrap_or_default();

            if !item_text.is_empty() && item_text.starts_with(query) {
                return Some(index);
            }
        }

        None
    }

    fn try_type_ahead(&mut self, cx: &mut EventContext, typed: char) -> bool {
        if self.type_ahead_text.is_none() {
            return false;
        }

        let num_items = self.num_items.get();
        if num_items == 0 || typed.is_control() || typed.is_whitespace() {
            return false;
        }

        let now = Instant::now();
        let within_timeout = self
            .type_ahead_last_input
            .is_some_and(|last| now.saturating_duration_since(last) <= self.type_ahead_timeout);

        let ch = typed.to_lowercase().collect::<String>();
        let query = if within_timeout {
            let repeated_char_cycle = !self.type_ahead_buffer.is_empty()
                && self.type_ahead_buffer.chars().all(|c| c == typed.to_ascii_lowercase());

            if repeated_char_cycle {
                ch.clone()
            } else {
                format!("{}{}", self.type_ahead_buffer, ch)
            }
        } else {
            ch.clone()
        };

        let start_index = self.focused.get().map(|focused| (focused + 1) % num_items).unwrap_or(0);

        if let Some(index) = self.find_type_ahead_match(cx, &query, start_index) {
            self.type_ahead_buffer = query;
            self.type_ahead_last_input = Some(now);
            self.focus_visibility.set(true);
            self.focused.set(Some(index));

            if self.selection_follows_focus.get() {
                cx.emit(ListEvent::SelectFocused);
            }

            true
        } else {
            self.type_ahead_buffer.clear();
            self.type_ahead_last_input = Some(now);
            false
        }
    }

    fn evaluate_index(index: usize, start: usize, end: usize) -> usize {
        match end - start {
            0 => 0,
            len => start + (len - (start % len) + index) % len,
        }
    }

    /// Builds a memo that resolves the item at `index` from the backing list,
    /// guarding against stale indices.
    ///
    /// Recycled items keep a captured `index` and re-evaluate whenever the
    /// backing list changes. When the list shrinks (or empties) the item can
    /// briefly reference an out-of-bounds index before the enclosing binding
    /// rebuilds and removes it, so the index is clamped to the current length
    /// and the previous value is reused while the list is transiently empty.
    fn resolve_item<L, T>(
        list: impl SignalWith<L> + Copy + 'static,
        index: usize,
        list_len: impl 'static + Fn(&L) -> usize,
        list_index: impl 'static + Fn(&L, usize) -> T,
    ) -> Memo<T>
    where
        L: 'static,
        T: Clone + PartialEq + 'static,
    {
        Memo::new(move |prev| {
            list.with(|list| {
                let len = list_len(list);
                if len == 0 {
                    // The list emptied while this recycled item still references
                    // a stale index; keep the previous value until it is removed.
                    prev.cloned().unwrap_or_else(|| list_index(list, 0))
                } else {
                    list_index(list, index.min(len - 1))
                }
            })
        })
    }

    fn recalc(&self, cx: &mut EventContext) {
        let num_items = self.num_items.get();
        if num_items == 0 {
            self.visible_range.set_if_changed(0..0);
            return;
        }

        let current = cx.current();
        let current_extent = match self.orientation.get() {
            Orientation::Horizontal => cx.cache.get_width(current),
            Orientation::Vertical => cx.cache.get_height(current),
        };
        if current_extent == f32::MAX {
            return;
        }

        let item_extent = self.item_height;
        let total_extent = item_extent * (num_items as f32);
        let visible_extent = current_extent / cx.scale_factor();

        let mut num_visible_items = (visible_extent / item_extent).ceil();
        num_visible_items += 1.0; // To account for partially-visible items.

        let visible_items_extent = item_extent * num_visible_items;
        let empty_extent = (total_extent - visible_items_extent).max(0.0);

        // The pixel offsets within the container to the visible area.
        let axis_scroll = match self.orientation.get() {
            Orientation::Horizontal => self.scroll_x.get(),
            Orientation::Vertical => self.scroll_y.get(),
        };
        let visible_start = empty_extent * axis_scroll;
        let visible_end = visible_start + visible_items_extent;

        // The indices of the first and last item of the visible area.
        let mut start_index = (visible_start / item_extent).trunc() as usize;
        let mut end_index = 1 + (visible_end / item_extent).trunc() as usize;

        // Ensure we always have (num_visible_items + 1) items when possible
        let desired_range_size = (num_visible_items as usize) + 1;
        end_index = end_index.min(num_items);

        let current_range_size = end_index.saturating_sub(start_index);

        if current_range_size < desired_range_size {
            match end_index == num_items {
                // Try to extend backwards if we're at the end of the list
                true => {
                    start_index =
                        start_index.saturating_sub(desired_range_size - current_range_size);
                }
                // Try to extend forwards if we have room
                false if end_index < num_items => {
                    end_index = (start_index + desired_range_size).min(num_items);
                }
                _ => {}
            }
        }

        self.visible_range.set_if_changed(start_index..end_index);
    }
}

impl VirtualList {
    /// Creates a new [VirtualList] view.
    pub fn new<V: View, S, L, T>(
        cx: &mut Context,
        list: S,
        item_height: f32,
        item_content: impl 'static + Copy + Fn(&mut Context, usize, Memo<T>) -> Handle<V>,
    ) -> Handle<Self>
    where
        S: Res<L> + 'static,
        L: Deref<Target = [T]> + Clone + 'static,
        T: Clone + PartialEq + 'static,
    {
        Self::new_generic(
            cx,
            list,
            |list| list.len(),
            |list, index| list[index].clone(),
            item_height,
            item_content,
        )
    }

    /// Creates a new [VirtualList] view with a binding to the given source and a template for constructing the list items.
    pub fn new_generic<V: View, S, L, T>(
        cx: &mut Context,
        list: S,
        list_len: impl 'static + Copy + Fn(&L) -> usize,
        list_index: impl 'static + Copy + Fn(&L, usize) -> T,
        item_height: f32,
        item_content: impl 'static + Copy + Fn(&mut Context, usize, Memo<T>) -> Handle<V>,
    ) -> Handle<Self>
    where
        S: Res<L> + 'static,
        L: Clone + 'static,
        T: Clone + PartialEq + 'static,
    {
        let list = list.to_signal(cx);
        let num_items = list.map(list_len).to_signal(cx);
        let visible_range = Signal::new(0..0);
        let scroll_x = Signal::new(0.0);
        let scroll_y = Signal::new(0.0);
        let show_horizontal_scrollbar = Signal::new(false);
        let show_vertical_scrollbar = Signal::new(true);
        let orientation = Signal::new(Orientation::Vertical);
        let selection = Signal::new(BTreeSet::default());
        let selectable = Signal::new(Selectable::None);
        let focused = Signal::new(None);
        let focus_visibility = Signal::new(false);
        let selection_follows_focus = Signal::new(false);
        let scroll_to_cursor = Signal::new(true);

        Self {
            scroll_to_cursor,
            on_scroll: None,
            num_items,
            item_height,
            orientation,
            visible_range,
            scroll_x,
            scroll_y,
            show_horizontal_scrollbar,
            show_vertical_scrollbar,
            selection,
            selectable,
            focused,
            focus_visibility,
            selection_follows_focus,
            on_select: None,
            type_ahead_text: None,
            type_ahead_buffer: String::new(),
            type_ahead_last_input: None,
            type_ahead_timeout: Duration::from_millis(1000),
        }
        .build(cx, |cx| {
            Keymap::from(vec![
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                    KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                    KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Home),
                    KeymapEntry::new("Focus First", |cx| cx.emit(ListEvent::FocusFirst)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::End),
                    KeymapEntry::new("Focus Last", |cx| cx.emit(ListEvent::FocusLast)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Enter),
                    KeymapEntry::new("Select Focused", |cx| cx.emit(ListEvent::SelectFocused)),
                ),
            ])
            .build(cx);

            Binding::new(cx, orientation, move |cx| {
                let orientation = orientation.get();
                if orientation == Orientation::Horizontal {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                } else {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                }
            });

            ScrollView::new(cx, move |cx| {
                Binding::new(cx, orientation, move |cx| {
                    let orientation = orientation.get();
                    Binding::new(cx, num_items, move |cx| {
                        let num_items = num_items.get();

                        match orientation {
                            Orientation::Horizontal => cx.emit(ScrollEvent::SetX(0.0)),
                            Orientation::Vertical => cx.emit(ScrollEvent::SetY(0.0)),
                        }

                        let num_visible_items = visible_range.map(Range::len);

                        match orientation {
                            Orientation::Horizontal => {
                                HStack::new(cx, |cx| {
                                    Binding::new(cx, num_visible_items, move |cx| {
                                        for i in 0..num_visible_items.get().min(num_items) {
                                            let item_index = visible_range.map(move |range| {
                                                Self::evaluate_index(i, range.start, range.end)
                                            });
                                            Binding::new(cx, item_index, move |cx| {
                                                let index = item_index.get();
                                                let item = Self::resolve_item(
                                                    list, index, list_len, list_index,
                                                );

                                                ListItem::new(
                                                    cx,
                                                    index,
                                                    item,
                                                    selection,
                                                    focused,
                                                    focus_visibility,
                                                    move |cx, index, item| {
                                                        item_content(cx, index, item)
                                                            .height(Percentage(100.0));
                                                    },
                                                )
                                                .min_size(Auto)
                                                .width(Pixels(item_height))
                                                .height(Percentage(100.0))
                                                .position_type(PositionType::Absolute)
                                                .bind(item_index, move |handle| {
                                                    let index = item_index.get();
                                                    handle.left(Pixels(index as f32 * item_height));
                                                });
                                            });
                                        }
                                    })
                                })
                                .width(Pixels(num_items as f32 * item_height))
                                .height(Stretch(1.0));
                            }

                            Orientation::Vertical => {
                                VStack::new(cx, |cx| {
                                    Binding::new(cx, num_visible_items, move |cx| {
                                        for i in 0..num_visible_items.get().min(num_items) {
                                            let item_index = visible_range.map(move |range| {
                                                Self::evaluate_index(i, range.start, range.end)
                                            });
                                            Binding::new(cx, item_index, move |cx| {
                                                let index = item_index.get();
                                                let item = Self::resolve_item(
                                                    list, index, list_len, list_index,
                                                );

                                                ListItem::new(
                                                    cx,
                                                    index,
                                                    item,
                                                    selection,
                                                    focused,
                                                    focus_visibility,
                                                    move |cx, index, item| {
                                                        item_content(cx, index, item)
                                                            .height(Percentage(100.0));
                                                    },
                                                )
                                                .min_width(Auto)
                                                .height(Pixels(item_height))
                                                .position_type(PositionType::Absolute)
                                                .bind(item_index, move |handle| {
                                                    let index = item_index.get();
                                                    handle.top(Pixels(index as f32 * item_height));
                                                });
                                            });
                                        }
                                    })
                                })
                                .height(Pixels(num_items as f32 * item_height));
                            }
                        }
                    })
                })
            })
            .show_horizontal_scrollbar(show_horizontal_scrollbar)
            .show_vertical_scrollbar(show_vertical_scrollbar)
            .scroll_to_cursor(scroll_to_cursor)
            .scroll_x(scroll_x)
            .scroll_y(scroll_y)
            .on_scroll(|cx, x, y| {
                if y.is_finite() && x.is_finite() {
                    cx.emit(ListEvent::Scroll(x, y));
                }
            });
        })
        .toggle_class("selectable", selectable.map(|s| *s != Selectable::None))
        .orientation(orientation)
        .navigable(true)
        .role(Role::ListBox)
    }
}

impl View for VirtualList {
    fn element(&self) -> Option<&'static str> {
        Some("virtual-list")
    }

    fn event(&mut self, cx: &mut EventContext, event: &mut Event) {
        event.take(|list_event, meta| match list_event {
            ListEvent::Select(index) => {
                let selectable = self.selectable.get();
                let mut selection = self.selection.get();
                let mut focused = self.focused.get();

                match selectable {
                    Selectable::Single => {
                        if selection.contains(&index) {
                            selection.clear();
                            focused = None;
                        } else {
                            selection.clear();
                            selection.insert(index);
                            focused = Some(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::Multi => {
                        if selection.contains(&index) {
                            selection.remove(&index);
                            focused = None;
                        } else {
                            selection.insert(index);
                            focused = Some(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::None => {}
                }

                self.selection.set(selection);
                self.focused.set(focused);

                meta.consume();
            }

            ListEvent::SelectFocused => {
                if let Some(focused) = self.focused.get() {
                    self.focus_visibility.set(true);
                    cx.emit(ListEvent::Select(focused))
                }
                meta.consume();
            }

            ListEvent::ClearSelection => {
                self.selection.set(BTreeSet::default());
                meta.consume();
            }

            ListEvent::FocusNext => {
                let mut focused = self.focused.get();
                let num_items = self.num_items.get();
                if let Some(f) = &mut focused {
                    if *f < num_items.saturating_sub(1) {
                        *f = f.saturating_add(1);
                        if self.selection_follows_focus.get() {
                            self.focus_visibility.set(true);
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    focused = Some(0);
                    if self.selection_follows_focus.get() {
                        self.focus_visibility.set(true);
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                self.focused.set(focused);

                meta.consume();
            }

            ListEvent::FocusPrev => {
                let mut focused = self.focused.get();
                let num_items = self.num_items.get();
                if let Some(f) = &mut focused {
                    if *f > 0 {
                        *f = f.saturating_sub(1);
                        if self.selection_follows_focus.get() {
                            self.focus_visibility.set(true);
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    focused = Some(num_items.saturating_sub(1));
                    if self.selection_follows_focus.get() {
                        self.focus_visibility.set(true);
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                self.focused.set(focused);

                meta.consume();
            }

            ListEvent::FocusFirst => {
                if self.num_items.get() > 0 {
                    self.focus_visibility.set(true);
                    self.focused.set(Some(0));
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::FocusLast => {
                let num_items = self.num_items.get();
                if num_items > 0 {
                    self.focus_visibility.set(true);
                    self.focused.set(Some(num_items.saturating_sub(1)));
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::Scroll(x, y) => {
                self.scroll_x.set(x);
                self.scroll_y.set(y);

                self.recalc(cx);

                if let Some(callback) = &self.on_scroll {
                    (callback)(cx, x, y);
                }

                meta.consume();
            }
        });

        event.map(|window_event, meta| match window_event {
            WindowEvent::Press { mouse } => {
                self.focus_visibility.set(!*mouse);
            }

            WindowEvent::CharInput(c) => {
                if *c == ' ' && meta.target == cx.current() {
                    cx.emit(ListEvent::SelectFocused);
                    meta.consume();
                } else if self.try_type_ahead(cx, *c) {
                    meta.consume();
                }
            }

            WindowEvent::GeometryChanged(geo) => {
                if geo.intersects(GeoChanged::WIDTH_CHANGED | GeoChanged::HEIGHT_CHANGED) {
                    self.recalc(cx);
                }
            }

            _ => {}
        });
    }
}

impl Handle<'_, VirtualList> {
    /// Sets the selected items of the list from a signal of indices.
    pub fn selection<R>(self, selection: impl Res<R> + 'static) -> Self
    where
        R: Deref<Target = [usize]> + Clone + 'static,
    {
        let selection = selection.to_signal(self.cx);
        self.bind(selection, move |handle| {
            selection.with(|selected_indices| {
                handle.modify(|list| {
                    let mut selection = BTreeSet::default();
                    let mut focused = None;
                    for idx in selected_indices.deref().iter().copied() {
                        selection.insert(idx);
                        focused = Some(idx);
                    }
                    list.selection.set(selection);
                    list.focused.set(focused);
                });
            });
        })
    }

    /// Sets the callback triggered when a [ListItem] is selected.
    pub fn on_select<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize),
    {
        self.modify(|list| list.on_select = Some(Box::new(callback)))
    }

    /// Set the selectable state of the [List].
    pub fn selectable<U: Into<Selectable> + Clone + 'static>(
        self,
        selectable: impl Res<U> + 'static,
    ) -> Self {
        let selectable = selectable.to_signal(self.cx);
        self.bind(selectable, move |handle| {
            let selectable = selectable.get();
            let s = selectable.into();
            handle.modify(|list| list.selectable.set(s));
        })
    }

    /// Sets whether the selection should follow the focus.
    pub fn selection_follows_focus<U: Into<bool> + Clone + 'static>(
        self,
        flag: impl Res<U> + 'static,
    ) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let selection_follows_focus = flag.get();
            let s = selection_follows_focus.into();
            handle.modify(|list| list.selection_follows_focus.set(s));
        })
    }

    /// Sets the orientation of the [VirtualList].
    pub fn horizontal<U: Into<bool> + Clone + 'static>(
        self,
        horizontal: impl Res<U> + 'static,
    ) -> Self {
        let horizontal = horizontal.to_signal(self.cx);
        self.bind(horizontal, move |handle| {
            let horizontal = horizontal.get();
            let horizontal = horizontal.into();
            handle.modify(|list| {
                list.orientation.set(if horizontal {
                    Orientation::Horizontal
                } else {
                    Orientation::Vertical
                });
            });
        })
    }

    /// Sets whether the scrollbar should move to the cursor when pressed.
    pub fn scroll_to_cursor(self, flag: bool) -> Self {
        self.modify(|virtual_list: &mut VirtualList| {
            virtual_list.scroll_to_cursor.set(flag);
        })
    }

    /// Sets a callback which will be called when a scrollview is scrolled, either with the mouse wheel, touchpad, or using the scroll bars.
    pub fn on_scroll(
        self,
        callback: impl Fn(&mut EventContext, f32, f32) + 'static + Send + Sync,
    ) -> Self {
        self.modify(|list| list.on_scroll = Some(Box::new(callback)))
    }

    /// Set the horizontal scroll position of the [ScrollView]. Accepts a value or lens to an 'f32' between 0 and 1.
    pub fn scroll_x(self, scrollx: impl Res<f32> + 'static) -> Self {
        let scrollx = scrollx.to_signal(self.cx);
        self.bind(scrollx, move |handle| {
            let sx = scrollx.get();
            handle.modify(|list| list.scroll_x.set(sx));
        })
    }

    /// Set the vertical scroll position of the [ScrollView]. Accepts a value or lens to an 'f32' between 0 and 1.
    pub fn scroll_y(self, scrollx: impl Res<f32> + 'static) -> Self {
        let scrollx = scrollx.to_signal(self.cx);
        self.bind(scrollx, move |handle| {
            let sy = scrollx.get();
            handle.modify(|list| list.scroll_y.set(sy));
        })
    }

    /// Sets whether the horizontal scrollbar should be visible.
    pub fn show_horizontal_scrollbar(self, flag: impl Res<bool> + 'static) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let s = flag.get();
            handle.modify(|list| list.show_horizontal_scrollbar.set(s));
        })
    }

    /// Sets whether the vertical scrollbar should be visible.
    pub fn show_vertical_scrollbar(self, flag: impl Res<bool> + 'static) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let s = flag.get();
            handle.modify(|list| list.show_vertical_scrollbar.set(s));
        })
    }

    /// Enables type-ahead navigation by providing searchable text per item index.
    pub fn type_ahead_text<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize) -> Option<String>,
    {
        self.modify(|list: &mut VirtualList| list.type_ahead_text = Some(Box::new(callback)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn evaluate_indices(range: Range<usize>) -> Vec<usize> {
        (0..range.len())
            .map(|index| VirtualList::evaluate_index(index, range.start, range.end))
            .collect()
    }

    #[test]
    fn test_evaluate_index() {
        // Move forward by 0
        assert_eq!(evaluate_indices(0..4), [0, 1, 2, 3]);
        // Move forward by 1
        assert_eq!(evaluate_indices(1..5), [4, 1, 2, 3]);
        // Move forward by 2
        assert_eq!(evaluate_indices(2..6), [4, 5, 2, 3]);
        // Move forward by 3
        assert_eq!(evaluate_indices(3..7), [4, 5, 6, 3]);
        // Move forward by 4
        assert_eq!(evaluate_indices(4..8), [4, 5, 6, 7]);
        // Move forward by 5
        assert_eq!(evaluate_indices(5..9), [8, 5, 6, 7]);
        // Move forward by 6
        assert_eq!(evaluate_indices(6..10), [8, 9, 6, 7]);
        // Move forward by 7
        assert_eq!(evaluate_indices(7..11), [8, 9, 10, 7]);
        // Move forward by 8
        assert_eq!(evaluate_indices(8..12), [8, 9, 10, 11]);
        // Move forward by 9
        assert_eq!(evaluate_indices(9..13), [12, 9, 10, 11]);
    }
}