Struct pax_runtime::slot::SlotInstance

pub struct SlotInstance { /* private fields */ }

A special “control-flow” primitive (a la yield or perhaps goto) — represents a slot into which an slot_child can be rendered. Slot relies on slot_children being present on the [Runtime] stack and will not render any content if there are no slot_children found.

Consider a Stacker: the owner of a Stacker passes the Stacker some nodes to render inside the cells of the Stacker. To the owner of the Stacker, those nodes might seem like “children,” but to the Stacker they are “slot_children” — children provided from the outside. Inside Stacker’s template, there are a number of Slots — this primitive — that become the final rendered home of those slot_children. This same technique is portable and applicable elsewhere via Slot.

Trait Implementations

impl InstanceNode for SlotInstance

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

where Self: Sized,

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 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 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 crate::api::CommonProperties and crate::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_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 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