Struct zng::widget::node::PanelList

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

Represents the final UiNodeList in a panel layout node.

Panel widgets should wrap their children list 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 UiNodeList) -> PanelList

New from list and default data.

impl<D> PanelList<D>

where D: PanelListData,

pub fn new_custom(list: impl UiNodeList) -> 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, ) -> (Box<dyn UiNodeListBoxed>, Vec<Mutex<RawMutex, D>>, FrameValueKey<PxTransform>, Option<StateId<PanelListRange>>)

Into list and associated data.

pub fn from_parts( list: Box<dyn UiNodeListBoxed>, 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_node<R, F>(&mut self, index: usize, f: F) -> R

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

Visit the specific node with associated data, panic if index is out of bounds.

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

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

Calls f for each node in the list with the index and associated data.

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

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

Calls f for each node in the list with the index and associated data in parallel.

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

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

Calls fold for each node in the list with the index and associated data in parallel.

This method behaves the same as UiNodeList::par_fold_reduce, with the added data.

pub 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 D, &mut WidgetMeasure) -> Size2D<Px, Px> + Send + Sync, S: Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Send + Sync,

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

The call to measure can be parallel if Parallel::LAYOUT is enabled, the inputs are the child index, node, data and the WidgetMeasure.

pub 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 D, &mut WidgetLayout) -> Size2D<Px, Px> + Send + Sync, S: Fn(Size2D<Px, Px>, Size2D<Px, Px>) -> Size2D<Px, Px> + Send + Sync,

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

The call to layout can be parallel if Parallel::LAYOUT is enabled, the inputs are the child index, node, data and the WidgetLayout.

pub fn for_each_z_sorted( &mut self, f: impl FnMut(usize, &mut Box<dyn UiNodeBoxed>, &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> UiNodeList for PanelList<D>

where D: PanelListData,

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, reduce: 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.