Struct zng_app::widget::node::MatchNodeChildren

pub struct MatchNodeChildren<L> { /* private fields */ }

Children node of match_node_list.

When the closure does not delegate to this list the delegation happens after the closure returns. The UiNodeList methods that flag as delegated are all the *_all methods and the methods that access mutable references to each child and the UiNodeList::with_node. You can use the children accessor to visit children without flagging as delegated.

Implementations

impl<L: UiNodeList> MatchNodeChildren<L>

pub fn delegated(&mut self)

Flags the current operation as delegated, stopping the default delegation after the closure ends.

Note that each *_all method and the methods that give mutable access to children already flags this.

pub fn has_delegated(&self) -> bool

If the current operation was already delegated to the children.

pub fn children(&mut self) -> &mut L

Reference the children.

Note that if you delegate using this reference you must call delegated.

Trait Implementations

impl<L: UiNodeList> UiNodeList for MatchNodeChildren<L>

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

where F: FnOnce(&mut BoxedUiNode) -> R,

Visit the specific node.

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

where F: FnMut(usize, &mut BoxedUiNode),

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 BoxedUiNode) + 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 BoxedUiNode) -> 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) -> BoxedUiNodeList

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

fn drain_into(&mut self, vec: &mut Vec<BoxedUiNode>)

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 update_all( &mut self, updates: &WidgetUpdates, observer: &mut dyn UiNodeListObserver, )

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

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 measure_each<F, S>( &mut self, wm: &mut WidgetMeasure, measure: F, fold_size: S, ) -> PxSize

where F: Fn(usize, &mut BoxedUiNode, &mut WidgetMeasure) -> PxSize + Send + Sync, S: Fn(PxSize, PxSize) -> PxSize + Send + Sync,

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, ) -> PxSize

where F: Fn(usize, &mut BoxedUiNode, &mut WidgetLayout) -> PxSize + Send + Sync, S: Fn(PxSize, PxSize) -> PxSize + Send + Sync,

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

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 downcast_unbox<L: UiNodeList>(self) -> Result<L, BoxedUiNodeList>

where 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

where Self: Sized,

Access to mut dyn Any methods.

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

where Self: Sized,

Runs the UiNodeOp.