Struct RepeatInstance

pub struct RepeatInstance {
    pub base: BaseInstance,
}

A special “control-flow” primitive associated with the for statement. Repeat allows for nodes to be rendered dynamically per data specified in source_expression. That is: for a source_expression of length n, Repeat will render its template n times, each with an embedded component context (RepeatItem) with an index i and a pointer to that relevant datum source_expression[i]

Fields

base: BaseInstance

Trait Implementations

impl InstanceNode for RepeatInstance

fn instantiate(args: InstantiationArgs) -> Rc<Self>

where Self: Sized,

fn resolve_debug( &self, f: &mut Formatter<'_>, _expanded_node: Option<&ExpandedNode>, ) -> Result

fn base(&self) -> &BaseInstance

Retrieves the base instance, containing common functionality that all instances share

fn update( self: Rc<Self>, expanded_node: &Rc<ExpandedNode>, context: &mut RuntimeContext, )

Updates the expanded node, recomputing it’s properties and possibly updating it’s children

fn handle_mount( &self, _expanded_node: &Rc<ExpandedNode>, _context: &mut RuntimeContext, )

Fires during the tick when a node is first attached to the render tree. For example, this event fires by all nodes on the global first tick, and by all nodes in a subtree when a Conditional subsequently turns on a subtree (i.e. when the Conditionals criterion becomes true after being false through the end of at least 1 frame.) A use-case: send a message to native renderers that a Text element should be rendered and tracked

fn get_size(&self, expanded_node: &ExpandedNode) -> (Size, Size)

Returns the bounds of an InstanceNode. This computation requires a stateful ExpandedNode, yet requires customization at the trait-implementor level (dyn InstanceNode), thus this method accepts an expanded_node parameter. The default implementation retrieves the expanded_node’s pax_runtime_api::CommonProperties and pax_runtime_api::CommonProperties

fn get_clipping_size( &self, expanded_node: &ExpandedNode, ) -> Option<(Size, Size)>

fn handle_native_patches( &self, expanded_node: &ExpandedNode, context: &mut RuntimeContext, )

Used by elements that need to communicate across native rendering bridge (for example: Text, Clipping masks, scroll containers) Called by engine after [expand_node], passed calculated size and transform matrix coefficients for convenience Expected to induce side-effects (if appropriate) via enqueueing messages to the native message queue

fn handle_pre_render( &self, expanded_node: &ExpandedNode, context: &mut RuntimeContext, rcs: &mut dyn RenderContext, )

Second lifecycle method during each render loop, occurs after properties have been computed, but before rendering Example use-case: perform side-effects to the drawing contexts. This is how [Frame] performs clipping, for example. Occurs in a pre-order traversal of the render tree.

fn render( &self, expanded_node: &ExpandedNode, context: &mut RuntimeContext, rcs: &mut dyn RenderContext, )

Third lifecycle method during each render loop, occurs after all descendents have been rendered. Occurs in a post-order traversal of the render tree. Most primitives are expected to draw their contents to the rendering context during this event.

fn handle_post_render( &self, context: &mut RuntimeContext, rcs: &mut dyn RenderContext, )

Fourth and final lifecycle method during each render loop, occurs after all descendents have been rendered AND the current node has been rendered. Useful for clean-up, e.g. this is where Frame cleans up the drawing contexts to stop clipping. Occurs in a post-order traversal of the render tree.

fn handle_unmount( &self, expanded_node: &Rc<ExpandedNode>, context: &mut RuntimeContext, )

Fires during element unmount, when an element is about to be removed from the render tree (e.g. by a Conditional) A use-case: send a message to native renderers that a Text element should be removed

fn handle_scroll(&self, args_scroll: ArgsScroll)

Invoked by event interrupts to pass scroll information to render node