Struct PanelList 

pub struct PanelList<D = DefaultPanelListData>
where
    D: PanelListData,
{ /* private fields */ }

Represents the final UI list in a panel layout node.

Panel widgets should wrap their children node on this type to support Z-index sorting and to easily track associated item data.

By default the associated item data is a DefaultPanelListData that represents the offset of each item inside the panel, but it can be any type that implements PanelListData. The panel list default render implementation uses this data to position the children widgets. Note that you must commit_data changes to this data at the end of a layout pass.

Panel widgets can also mark the list using track_info_range to implement getter properties such as is_odd or is_even.

Implementations

impl PanelList

pub fn new(list: impl IntoUiNode) -> PanelList

New from list and default data.

impl<D> PanelList<D>

where D: PanelListData,

pub fn new_custom(list: impl IntoUiNode) -> PanelList<D>

New from list and custom data type.

pub fn track_info_range( self, info_id: impl Into<StateId<PanelListRange>>, ) -> PanelList<D>

Enable tracking the first and last child in the parent widget info.

The info is set in the info_id, it can be used to identify the children widgets that are the panel children as the info tree may track extra widgets as children when they are set by other properties, like background.

pub fn into_parts( self, ) -> (UiNode, Vec<Mutex<RawMutex, D>>, FrameValueKey<PxTransform>, Option<StateId<PanelListRange>>)

Into list and associated data.

pub fn from_parts( list: UiNode, data: Vec<Mutex<RawMutex, D>>, offset_key: FrameValueKey<PxTransform>, info_id: Option<StateId<PanelListRange>>, ) -> PanelList<D>

New from list and associated data.

Panics

Panics if the list and data don’t have the same length.

pub fn info_id(&self) -> Option<StateId<PanelListRange>>

Gets the ID set on the parent widget info if track_info_range was enabled.

pub fn with_child<R>( &mut self, index: usize, visitor: impl FnOnce(&mut UiNode, &mut D) -> R, ) -> R

Call visitor with a exclusive reference to the child node and associated data identified by index.

Panics if the index is out of bounds.

pub fn for_each_child( &mut self, visitor: impl FnMut(usize, &mut UiNode, &mut D), )

Call visitor for each child node of self, one at a time.

The closure parameters are the child index, the child and the associated data.

pub fn try_for_each_child<B>( &mut self, visitor: &mut dyn FnMut(usize, &mut UiNode, &mut D) -> ControlFlow<B>, ) -> ControlFlow<B>

where B: VarValue,

Call visitor for each child node of self, one at a time, with control flow.

The closure parameters are the child index, the child and the associated data.

pub fn par_each_child( &mut self, visitor: impl Fn(usize, &mut UiNode, &mut D) + Sync, )

where D: Sync,

Calls visitor for each child node in parallel.

The closure parameters are the child index, the child and the associated data.

pub fn par_fold_reduce<T>( &mut self, identity: T, fold: impl Fn(T, usize, &mut UiNode, &mut D) -> T + Sync, reduce: impl Fn(T, T) -> T + Send + Sync, ) -> T

where T: VarValue,

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

The reduce call is associative, the order is preserved in the result.

pub fn measure_list( &mut self, wm: &mut WidgetMeasure, measure: impl Fn(usize, &mut UiNode, &mut D, &mut WidgetMeasure) -> Size2D<Px, Px> + Sync, fold_size: impl Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Sync, ) -> Size2D<Px, Px>

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

pub fn layout_list( &mut self, wl: &mut WidgetLayout, layout: impl Fn(usize, &mut UiNode, &mut D, &mut WidgetLayout) -> Size2D<Px, Px> + Sync, fold_size: impl Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Sync, ) -> Size2D<Px, Px>

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

pub fn render_list( &mut self, frame: &mut FrameBuilder, render: impl Fn(usize, &mut UiNode, &mut D, &mut FrameBuilder) + Sync, )

Call render for each node with associated data.

Note that the PanelListData child offset and reference frame are already pushed when render is called.

pub fn render_update_list( &mut self, update: &mut FrameUpdate, render_update: impl Fn(usize, &mut UiNode, &mut D, &mut FrameUpdate) + Sync, )

Call render_update for each node with associated data.

Note that the PanelListData child offset and reference frame are already pushed when render_update is called.

pub fn for_each_z_sorted( &mut self, visitor: impl FnMut(usize, &mut UiNode, &mut D), )

Iterate over the list in the Z order.

pub fn z_map(&mut self, index: usize) -> usize

Gets the index sorted in the list.

pub fn data(&mut self, index: usize) -> &mut D

Reference the associated data.

pub fn commit_data(&mut self) -> PanelListDataChanges

Calls commit for each child data, aggregate changes.

This must be called after the last update to the children data in a layout pass. Note that you can call commit directly in a for_each iteration if that iteration is the last in the layout pass.

pub fn offset_key(&self) -> FrameValueKey<PxTransform>

Key used to define reference frames for each item.

The default implementation of render_all uses this key and the item index.

Trait Implementations

impl<D> UiNodeImpl for PanelList<D>

where D: PanelListData,

fn children_len(&self) -> usize

Gets the current count of children nodes.

fn with_child(&mut self, index: usize, visitor: &mut dyn FnMut(&mut UiNode))

Visit a child node by index. If the index is not valid visitor is not called.

fn is_list(&self) -> bool

Gets if the node represents a list of other nodes.

fn for_each_child(&mut self, visitor: &mut dyn FnMut(usize, &mut UiNode))

Call visitor for each child node of self, one at a time.

fn try_for_each_child( &mut self, visitor: &mut dyn FnMut(usize, &mut UiNode) -> ControlFlow<BoxAnyVarValue>, ) -> ControlFlow<BoxAnyVarValue>

Call visitor for each child node of self, one at a time, with control flow.

fn par_each_child(&mut self, visitor: &(dyn Fn(usize, &mut UiNode) + Sync))

Calls visitor for each child node in parallel.

fn par_fold_reduce( &mut self, identity: BoxAnyVarValue, fold: &(dyn Fn(BoxAnyVarValue, usize, &mut UiNode) -> BoxAnyVarValue + Sync), reduce: &(dyn Fn(BoxAnyVarValue, BoxAnyVarValue) -> BoxAnyVarValue + Sync), ) -> BoxAnyVarValue

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

fn init(&mut self)

Initializes the node in a new UI context.

fn deinit(&mut self)

Deinitializes the node in the current UI context.

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

Builds widget info.

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

Receives an event.

fn update(&mut self, updates: &WidgetUpdates)

Receives variable and other non-event updates.

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

Does update and if the node is a list notifies list changes to the observer.

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

Computes the widget size given the contextual layout metrics without actually updating the widget layout.

fn measure_list( &mut self, wm: &mut WidgetMeasure, measure: &(dyn Fn(usize, &mut UiNode, &mut WidgetMeasure) -> Size2D<Px, Px> + Sync), fold_size: &(dyn Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Sync), ) -> Size2D<Px, Px>

If the node is_list measure each child and combine the size using fold_size.

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

Computes the widget layout given the contextual layout metrics.

fn layout_list( &mut self, wl: &mut WidgetLayout, layout: &(dyn Fn(usize, &mut UiNode, &mut WidgetLayout) -> Size2D<Px, Px> + Sync), fold_size: &(dyn Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Sync), ) -> Size2D<Px, Px>

If the node is_list layout each child and combine the size using fold_size.

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

Generates render instructions and updates transforms and hit-test areas.

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

Updates values in the last generated frame.

fn as_widget(&mut self) -> Option<&mut (dyn WidgetUiNodeImpl + 'static)>

Gets the node implementation as a WidgetUiNodeImpl, if the node defines a widget instance scope.

fn render_list( &mut self, frame: &mut FrameBuilder, render: &(dyn Fn(usize, &mut UiNode, &mut FrameBuilder) + Sync), )

If the node is_list render each child.

fn render_update_list( &mut self, update: &mut FrameUpdate, render_update: &(dyn Fn(usize, &mut UiNode, &mut FrameUpdate) + Sync), )

If the node is_list render_update each child.