Struct ChainList 

pub struct ChainList<P: Chained, K, T> { /* private fields */ }

A chain’s items as a ListModel: every held part’s items, oldest first, after a row standing for the earlier parts while there are any (ChainRow::Earlier, pending while one is on its way, failed with why when the workspace’s hosts have none of it). Showing that row opens the part before (ChainPager::reached_top); a VirtualList keeps the row the reader looks at in place as items come in above it.

Implementations

impl<P: Chained, K: Clone + Eq + Hash + 'static, T> ChainList<P, K, T>

pub fn new( chain: Chain<P>, rows: impl Fn(&[(u64, Rc<P::State>)]) -> Vec<(K, T)> + 'static, ) -> Self

The items rows reads from the parts chain holds.

pub fn pager(&mut self) -> &mut ChainPager<P>

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

The item of row index; None for the earlier parts’ row.

Trait Implementations

impl<P: Chained, K: Clone + Eq + Hash + 'static, T> ListModel for ChainList<P, K, T>

type Key = ChainRow<K>

fn len(&self) -> usize

fn key_at(&self, index: usize) -> Option<Self::Key>

fn index_of(&self, key: &Self::Key) -> Option<usize>

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 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 is_empty(&self) -> bool

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 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 tree_at(&self, _index: usize) -> Option<TreeRow<Self::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 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 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 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 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.