Struct zng::widget::node::SortingList

pub struct SortingList { /* private fields */ }

Represents a sorted view into an UiNodeList.

The underlying list is not changed, a sorted index map is used to iterate the underlying list.

Note that the *_all methods are not sorted, only the other accessors map to the sorted position of nodes. The sorting is lazy and gets invalidated on every init and every time there are changes observed in update_all.

Implementations

impl SortingList

pub fn new( list: impl UiNodeList, sort: impl Fn(&mut Box<dyn UiNodeBoxed>, &mut Box<dyn UiNodeBoxed>) -> Ordering + Send + 'static, ) -> SortingList

New from list and sort function.

pub fn list(&mut self) -> &mut Box<dyn UiNodeListBoxed>

Mutable borrow the inner list.

You must call invalidate_sort if any modification is done to the list.

pub fn invalidate_sort(&mut self)

Invalidate the sort, the list will resort on the nest time the sorted positions are needed.

Note that you can also invalidate sort from the inside using SORTING_LIST::invalidate_sort.

Trait Implementations

impl UiNodeList for SortingList

fn with_node<R, F>(&mut self, index: usize, f: F) -> R

where F: FnOnce(&mut Box<dyn UiNodeBoxed>) -> R,

Visit the specific node.

fn for_each<F>(&mut self, f: F)

where F: FnMut(usize, &mut Box<dyn UiNodeBoxed>),

Calls f for each node in the list with the index, sequentially.

fn par_each<F>(&mut self, f: F)

where F: Fn(usize, &mut Box<dyn UiNodeBoxed>) + Send + Sync,

Calls f for each node in the list with the index, in parallel.

fn par_fold_reduce<T, I, F, R>(&mut self, identity: I, fold: F, _: R) -> T

where T: Send + 'static, I: Fn() -> T + Send + Sync, F: Fn(T, usize, &mut Box<dyn UiNodeBoxed>) -> T + Send + Sync, R: Fn(T, T) -> T + Send + Sync,

Calls fold for each node in the list in parallel, with fold accumulators produced by identity, then merges the folded results using reduce to produce the final value also in parallel.

fn len(&self) -> usize

Gets the current number of nodes in the list.

fn boxed(self) -> Box<dyn UiNodeListBoxed>

Gets self boxed, or itself if it is already boxed.

fn drain_into(&mut self, vec: &mut Vec<Box<dyn UiNodeBoxed>>)

Move all nodes into vec.

fn init_all(&mut self)

Init the list in a context, all nodes are also inited.

fn deinit_all(&mut self)

Deinit the list in a context, all nodes are also deinited.

fn info_all(&mut self, info: &mut WidgetInfoBuilder)

Rebuilds the list in a context, all node info is rebuilt.

fn event_all(&mut self, update: &EventUpdate)

Receive an event for the list in a context, all nodes are also notified.

fn update_all( &mut self, updates: &WidgetUpdates, observer: &mut dyn UiNodeListObserver, )

Receive updates for the list in a context, all nodes are also updated.

fn render_all(&mut self, frame: &mut FrameBuilder)

Render all nodes.

fn render_update_all(&mut self, update: &mut FrameUpdate)

Render all nodes.

fn is_empty(&self) -> bool

Returns true if the list does not contain any nodes.

fn measure_each<F, S>( &mut self, wm: &mut WidgetMeasure, measure: F, fold_size: S, ) -> Size2D<Px, Px>

where F: Fn(usize, &mut Box<dyn UiNodeBoxed>, &mut WidgetMeasure) -> Size2D<Px, Px> + Send + Sync, S: Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Send + Sync, Self: Sized,

Call measure for each node and combines the final size using fold_size.

fn layout_each<F, S>( &mut self, wl: &mut WidgetLayout, layout: F, fold_size: S, ) -> Size2D<Px, Px>

where F: Fn(usize, &mut Box<dyn UiNodeBoxed>, &mut WidgetLayout) -> Size2D<Px, Px> + Send + Sync, S: Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Send + Sync, Self: Sized,

Call layout for each node and combines the final size using fold_size.

fn downcast_unbox<L>(self) -> Result<L, Box<dyn UiNodeListBoxed>>

where L: UiNodeList, Self: Sized,

Downcast to L, if self is L or is a BoxedUiNodeList that is L.

fn actual_type_id(&self) -> TypeId

Returns the type_id of the unboxed list.

fn as_any(&mut self) -> &mut (dyn Any + 'static)

where Self: Sized,

Access to mut dyn Any methods.

fn op(&mut self, op: UiNodeOp<'_>)

where Self: Sized,

Runs the UiNodeOp.