Struct VirtualList 

pub struct VirtualList<T: 'static> {
    pub selection: RwSignal<Option<usize>>,
    /* private fields */
}

Fields

selection: RwSignal<Option<usize>>

Implementations

impl<T> VirtualList<T>

pub fn new<DF, I>(data_fn: DF) -> Self

where DF: Fn() -> I + 'static, I: VirtualVector<T>, T: Hash + Eq + IntoView + 'static,

pub fn with_view<DF, I, V>( data_fn: DF, view_fn: impl Fn(T) -> V + 'static, ) -> Self

where DF: Fn() -> I + 'static, I: VirtualVector<T>, T: Hash + Eq + 'static, V: IntoView,

pub fn with_key<DF, I, K>( data_fn: DF, key_fn: impl Fn(&T) -> K + 'static, ) -> Self

where DF: Fn() -> I + 'static, I: VirtualVector<T>, T: IntoView + 'static, K: Hash + Eq + 'static,

pub fn full<DF, I, KF, K, VF, V>(data_fn: DF, key_fn: KF, view_fn: VF) -> Self

where DF: Fn() -> I + 'static, I: VirtualVector<T>, KF: Fn(&T) -> K + 'static, K: Eq + Hash + 'static, VF: Fn(usize, T) -> V + 'static, V: IntoView + 'static, T: 'static,

impl<T: 'static> VirtualList<T>

pub fn selection(&self) -> RwSignal<Option<usize>>

pub fn on_select(self, on_select: impl Fn(Option<usize>) + 'static) -> Self

Sets a callback function to be called whenever the selection changes in the virtual list.

The callback function receives an Option<usize> parameter representing the currently selected item index. When None, no item is selected. When Some(index), the item at that index is currently selected.

This is a convenience helper that creates a new effect internally. Calling this method multiple times will not override previous on_select calls - each call creates a separate effect that will all be triggered on selection changes. For more control, you can manually create effects using the selection signal returned by selection().

Parameters

• on_select - A function that takes Option<usize> and will be called on selection changes

Returns

Returns self to allow method chaining.

Example

use floem::prelude::*;

virtual_list(
    move || 1..=1000000,
    |item| *item,
    |index, item| format!("{index}: {item}")
)
.on_select(|selection| {
    match selection {
        Some(index) => println!("Selected item at index: {index}"),
        None => println!("No item selected"),
    }
});

Methods from Deref<Target = VirtualStack<(usize, T)>>

pub fn scroll_to_idx(&self, index: usize)

Scrolls to bring the item at the given index into view

Trait Implementations

impl<T: 'static> Deref for VirtualList<T>

type Target = VirtualStack<(usize, T)>

The resulting type after dereferencing.

fn deref(&self) -> &VirtualStack<(usize, T)>

Dereferences the value.

impl<T: 'static> DerefMut for VirtualList<T>

fn deref_mut(&mut self) -> &mut VirtualStack<(usize, T)>

Mutably dereferences the value.

impl<T: 'static> IntoView for VirtualList<T>

type V = VirtualStack<(usize, T)>

The final View type this converts to.

type Intermediate = VirtualStack<(usize, T)>

Intermediate type that has a ViewId before full view construction.

fn into_intermediate(self) -> Self::Intermediate

Converts to the intermediate form which has a ViewId.

fn into_view(self) -> Self::V

Converts the value into a View.

fn into_any(self) -> AnyView

Converts the value into a AnyView.