Struct VecListModel 

pub struct VecListModel<T, K> { /* private fields */ }

Convenient fully-resident model. Database and paged sources generally implement ListModel directly instead.

Implementations

impl<T, K> VecListModel<T, K>

where K: Clone + Eq + Hash,

pub fn new( items: Vec<T>, key: impl FnMut(&T) -> K, ) -> Result<VecListModel<T, K>, DuplicateListKey>

Build the key index once.

pub fn empty() -> VecListModel<T, K>

No rows, for a host that shows its list before the first rows are read (Self::push fills it).

pub fn with_parents( self, parent: impl FnMut(&T) -> Option<K>, ) -> VecListModel<T, K>

The rows stand as a tree: each under the row of the item parent names, which stands over it in the same list (VirtualList::with_tree). A row outside the tree names no parent, as does one pushed later.

pub fn with_branches(self, branch: impl FnMut(&T) -> bool) -> VecListModel<T, K>

The rows that take subtasks: a folder is one before its contents are read, so it shows the disclosure that opens it. Read when set, as Self::with_parents does.

pub fn item(&self, index: usize) -> Option<&T>

pub fn items(&self) -> &[T]

pub fn push(&mut self, key: K, item: T) -> Result<(), DuplicateListKey>

pub fn remove(&mut self, index: usize) -> Option<T>

pub fn move_item(&mut self, from: usize, to: usize) -> bool

Trait Implementations

impl<T, K> ListModel for VecListModel<T, K>

where K: Clone + Eq + Hash + 'static,

type Key = K

fn len(&self) -> usize

fn key_at(&self, index: usize) -> Option<<VecListModel<T, K> as ListModel>::Key>

fn index_of( &self, key: &<VecListModel<T, K> as ListModel>::Key, ) -> Option<usize>

fn accepts_children(&self, index: usize) -> bool

Whether the row index takes other rows as its subtasks: a tree’s drag offers a drop into it (DropPlacement::Inside), and the keyboard indents a row into it. false for a leaf, or a model that holds no tree.

fn has_subtasks(&self, index: usize) -> bool

Whether the row index has subtasks to disclose, whether or not any of them stands in the list: a folder read when it opens shows the disclosure that reads it. false for a leaf, or a model that holds no tree.

fn tree_at( &self, index: usize, ) -> Option<TreeRow<<VecListModel<T, K> as ListModel>::Key>>

What the row stands as in a tree (VirtualList::with_tree): the row it is under, and what the list shows of its subtasks. None for a row outside a tree, or a model that holds none.

fn is_empty(&self) -> bool

fn row_state(&self, _index: usize) -> Arrival<(), &str>

Where a logical row’s data stands: Arrival::Pending (saying where it comes from), ready, or failed with the reason. A paged model keeps stable keys and geometry while its rows arrive; the list reserves a pending row’s slot and paints its placeholder there (crate::widget::ArrivingRows), and builds the row’s delegate only once it is ready.

fn can_retry(&self, _index: usize) -> bool

Whether row index, failed, can be asked for again: its failure then offers a retry, which calls Self::retry.

fn retry(&mut self, _index: usize)

Ask again for row index after it failed.

fn request_range(&mut self, _range: Range<usize>)

Opportunity to enqueue work for the visible window plus overscan.

fn poll_changed(&mut self) -> bool

Drain a model-owned invalidation wakeup. Return true after logical order, count, key, or row-state changes. Use VirtualList::invalidate_rows as well when ready delegate content changed without changing state.

fn poll_changes(&mut self) -> Vec<ListModelChange<Self::Key>>

Drain specific model changes. Prefer this to Self::poll_changed when an asynchronous source can identify its batch: stable delegates then survive structural changes and only named content rows rebuild.

fn needs_poll(&self) -> bool

Keep scheduling frames while Self::poll_changed or Self::poll_changes may observe an in-flight asynchronous source.

fn label(&self, _index: usize) -> Option<String>

The name a person reads row index by, which typing its first letters in the focused list moves to (crate::type_ahead). None for a row without one, or a model that names no rows.

fn key_presenting(&self, _id: &str) -> Option<Self::Key>

The key of the row showing the resource id, when the model can say: a host that renders rows as they show offers this (crate::component::RowSource).

fn group_at(&self, _index: usize) -> Option<RowGroup>

What the row index is grouped by, when the model groups its rows: the list draws the heading over the first row of each group (RowGroup), a disclosure the keyboard reaches like a row and assistive technology reads as one. None for a row in no group, or a model that groups nothing.

fn renames(&self, _index: usize) -> bool

Whether the row index can be renamed in place (VirtualList::on_rename): F2, a double click and VirtualList::begin_rename open a field only over a row that does.

fn discloses(&self) -> bool

Whether the list heads or nests its rows, keeping a disclosure gutter left of its column.

fn opens_in_place(&self, _index: usize) -> bool

Whether the row index opens into its item where it stands: the row carries the item’s document under it, and choosing the row opens it there rather than anywhere else. false for a row that opens elsewhere, or a model whose rows open nothing.