Struct ExpandedNode 

pub struct ExpandedNode {

    pub id: ExpandedNodeIdentifier,
    pub instance_node: RefCell<InstanceNodePtr>,
    pub render_parent: RefCell<Weak<ExpandedNode>>,
    pub template_parent: Weak<ExpandedNode>,
    pub parent_frame: LocalProperty<Option<ExpandedNodeIdentifier>>,
    pub liquid_glass_scope: LocalProperty<Option<NativeLiquidGlassScope>>,
    pub containing_component: Weak<ExpandedNode>,
    pub stack: Rc<RuntimePropertiesStackFrame>,
    pub children: LocalProperty<Vec<Rc<ExpandedNode>>>,
    pub mounted_children: RefCell<Vec<Rc<ExpandedNode>>>,
    pub active_children: RefCell<Vec<Rc<ExpandedNode>>>,
    pub active_children_view: LocalProperty<Vec<Rc<ExpandedNode>>>,
    pub exiting_children: RefCell<Vec<Rc<ExpandedNode>>>,
    pub exiting_children_view: LocalProperty<Vec<Rc<ExpandedNode>>>,
    pub sidecar_children: RefCell<Vec<Rc<ExpandedNode>>>,
    pub properties: RefCell<Rc<RefCell<PaxAny>>>,
    pub common_properties: RefCell<Rc<RefCell<CommonProperties>>>,
    pub measured_size: LocalProperty<Option<(f64, f64)>>,
    pub selector_metadata: RefCell<RuntimeSelectorMetadata>,
    pub transform_and_bounds: LocalProperty<TransformAndBounds<NodeLocal, Window>>,
    pub subtree_layout_hull: LocalProperty<LayoutHull>,
    pub container_frame: LocalProperty<Option<ContainerFrame>>,
    pub computed_opacity: LocalProperty<f64>,
    pub computed_opacity_scopes: LocalProperty<Vec<OpacityScope>>,
    pub expanded_projected_children: RefCell<Option<Vec<Rc<ExpandedNode>>>>,
    pub expanded_and_flattened_projected_children: LocalProperty<Vec<Rc<ExpandedNode>>>,
    pub flattened_projected_children_count: LocalProperty<usize>,
    pub attached: Cell<u32>,
    pub occlusion: LocalProperty<Occlusion>,
    pub native_mask_hash: Cell<u64>,
    pub browser_content_layer_id: Cell<Option<u32>>,
    pub presentation_cache_hash: Cell<u64>,
    pub properties_scope: RefCell<HashMap<String, Variable>>,
    pub slot_index: LocalProperty<Option<usize>>,
    pub suspended: LocalProperty<bool>,
    pub changed_listener: LocalProperty<()>,
    pub occlusion_listener: LocalProperty<()>,
    pub children_listener: LocalProperty<()>,
    pub subtree_layout_hull_listener: LocalProperty<()>,
    pub content_measurement_listener: LocalProperty<()>,
    pub content_measurement_rebind_listener: LocalProperty<()>,
    pub content_measurement_bound: Cell<bool>,
    pub projected_children_changed: LocalProperty<()>,
    pub slot_projection_changed: LocalProperty<()>,
    pub subscriptions: RefCell<Vec<LocalProperty<()>>>,
    pub transition_phase: LocalProperty<u64>,
    pub transition_generation: LocalProperty<u64>,
    pub transition_takeover: LocalProperty<bool>,
    pub transition_selector_classes: RefCell<Option<Vec<String>>>,
    pub transition_origin_frame: LocalProperty<u64>,
    pub transition_origin_millis: LocalProperty<u64>,
    pub transition_playhead: LocalProperty<f64>,
    pub transition_playhead_millis: LocalProperty<f64>,
    pub enter_cleanup_listener: LocalProperty<()>,
    pub enter_cleanup_active: Cell<bool>,
    pub exit_started_millis: Cell<Option<u128>>,
    pub exit_cleanup_listener: LocalProperty<()>,
    pub exit_cleanup_active: Cell<bool>,
    pub imported_settings_layers: RefCell<Vec<RuntimeSettingsLayer>>,
    pub import_settings_transition: RefCell<Option<LocalProperty<Option<SettingsTransitionConfig>>>>,
    pub imported_settings_signature: RefCell<Vec<RuntimeSettingsSignatureEntry>>,
    pub resolved_property_columns: RefCell<RuntimeResolvedPropertyColumns>,
    pub resolved_property_provenance: RefCell<BTreeMap<String, RuntimeResolvedPropertyEntry>>,
    pub reset_removed_runtime_properties: Cell<bool>,
    /* private fields */
}

This runtime owner stays on the UI thread. Transfer properties or delivery handles to workers instead.

fn requires_send<T: Send>() {}
requires_send::<pax_runtime::ExpandedNode>();

Fields

id: ExpandedNodeIdentifier

Unique ID of this expanded node, roughly encoding an address in the tree, where the first u32 is the instance ID and the subsequent u32s represent addresses within an expanded tree via Repeat.

instance_node: RefCell<InstanceNodePtr>

Pointer to the unexpanded instance_node underlying this ExpandedNode

render_parent: RefCell<Weak<ExpandedNode>>

Pointer (Weak to avoid Rc cycle memory leaks) to the ExpandedNode rendered directly above this one.

template_parent: Weak<ExpandedNode>

Pointer (Weak to avoid Rc cycle memory leaks) to the ExpandedNode in the template directly above this one.

parent_frame: LocalProperty<Option<ExpandedNodeIdentifier>>

Id of closest frame present in the node tree. included as a parameter on AnyCreatePatch when creating a native element to know what clipping context to attach to

liquid_glass_scope: LocalProperty<Option<NativeLiquidGlassScope>>

Nearest active native liquid-glass scope inherited by descendants.

containing_component: Weak<ExpandedNode>

Reference to the component for which this ExpandedNode is a template member. Used at least for resolving projected children for slot. Optional because the very root instance node (root component, root instance node) has a corollary “root component expanded node.” That very root expanded node does not have a containing ExpandedNode component, thus containing_component is Optional.

stack: Rc<RuntimePropertiesStackFrame>

Persistent clone of the state of the PropertiesTreeShared#runtime_properties_stack at the time that this node was expanded (this is expected to remain immutable through the lifetime of the program after the initial expansion; however, if that constraint changes, this should be explicitly updated to accommodate.)

children: LocalProperty<Vec<Rc<ExpandedNode>>>

Pointers to the ExpandedNode beneath this one. Used for rendering recursion and other render-tree traversals.

mounted_children: RefCell<Vec<Rc<ExpandedNode>>>

The concrete render-tree children currently attached beneath this node.

This may temporarily include children retained for exit transitions, so it should not be confused with the semantic payload exposed through NodeContext::received_children.

active_children: RefCell<Vec<Rc<ExpandedNode>>>

Children that represent the currently selected control-flow/template output.

When this node’s received-child source is Owned, this is the internal source for NodeContext::received_children.

active_children_view: LocalProperty<Vec<Rc<ExpandedNode>>>

Reactive mirror of active_children for consumers that need the active semantic set.

exiting_children: RefCell<Vec<Rc<ExpandedNode>>>

Children retained only so exit transitions can finish before unmount.

When this node’s received-child source is Owned, this is the internal source for NodeContext::retained_received_children.

exiting_children_view: LocalProperty<Vec<Rc<ExpandedNode>>>

Reactive mirror of exiting_children for consumers that need retained exits.

sidecar_children: RefCell<Vec<Rc<ExpandedNode>>>

Auxiliary children are not presented directly. Mask sources have a normal logical mount lifetime; other sidecar consumers choose their own lifetime.

properties: RefCell<Rc<RefCell<PaxAny>>>

Each ExpandedNode has a unique “stamp” of computed properties

common_properties: RefCell<Rc<RefCell<CommonProperties>>>

Each ExpandedNode has unique, computed CommonProperties

measured_size: LocalProperty<Option<(f64, f64)>>

Measured bounds reported by chassis/native layout or by container-owned bottom-up layout. When width/height are omitted, these values are used as the fallback concrete size.

selector_metadata: RefCell<RuntimeSelectorMetadata>

Selector-facing metadata used by runtime and designtime queries.

transform_and_bounds: LocalProperty<TransformAndBounds<NodeLocal, Window>>

The layout information (width, height, transform) used to render this node. computed property based on parent bounds + common properties

subtree_layout_hull: LocalProperty<LayoutHull>

Engine-owned subtree hull used by container measurement.

container_frame: LocalProperty<Option<ContainerFrame>>

Optional container-assigned virtual wrapper frame applied before this node’s own layout.

computed_opacity: LocalProperty<f64>

The accumulated opacity inherited from render ancestors and this node’s own common opacity value.

computed_opacity_scopes: LocalProperty<Vec<OpacityScope>>

Authored opacity scopes retained independently of their multiplied world opacity. Keeping the factors avoids division by zero and detects changes under a hidden ancestor.

expanded_projected_children: RefCell<Option<Vec<Rc<ExpandedNode>>>>

For nodes that own projection, tracks projected children in their expanded, non-collapsed form.

Projection is a transport detail used to deliver received payload into a node’s encapsulated implementation, typically for slot(...). Repeat/conditional descendants are still present here.

expanded_and_flattened_projected_children: LocalProperty<Vec<Rc<ExpandedNode>>>

Flattened version of the projected children above, where repeat and conditionals are recursively replaced by their current outputs.

This is the raw projected family, not necessarily the same thing as the semantic received_children view seen by all consumers.

flattened_projected_children_count: LocalProperty<usize>

Number of expanded and flattened projected children.

attached: Cell<u32>

Flag that is > 0 if this node is part of the root tree. If it is, updates to this nodes children also marks them as attached (+1), triggering mount and dismount on addition/removal. This is needed mainly for slot, since an entire “shadow tree” needs to be expanded and updated for each slot child, but only the ones that have a “connected” slot should trigger mount/dismount updates

occlusion: LocalProperty<Occlusion>

Logical render-layer assignment plus z-order for the current render tree pass.

Layer 0 is the root surface stack, and non-root layers are reserved for scroller-owned vector islands.

native_mask_hash: Cell<u64>

Hash of the last native occlusion mask emitted for this node.

browser_content_layer_id: Cell<Option<u32>>

Last browser-owned descendant content layer published for scroller-style native hosts.

presentation_cache_hash: Cell<u64>

Hash of the last presentation metadata emitted for clipping/scrolling chassis consumers.

properties_scope: RefCell<HashMap<String, Variable>>

A map of all properties available on this expanded node. Used by the RuntimePropertiesStackFrame to resolve symbols.

slot_index: LocalProperty<Option<usize>>

The flattened index of this node in its container (if this container cares about slot children, ex: component, path).

suspended: LocalProperty<bool>

property used to “freeze” (stop firing tick) on a node and all it’s children

changed_listener: LocalProperty<()>

used by native elements to trigger sending of native messages used by canvas elements to dirtify their canvas

occlusion_listener: LocalProperty<()>

Tracks whether this node’s occlusion-affecting inputs changed.

children_listener: LocalProperty<()>

Pulls the node’s children property only when its upstream dependencies changed.

subtree_layout_hull_listener: LocalProperty<()>

Rebinds subtree_layout_hull when the child list changes.

content_measurement_listener: LocalProperty<()>

Reactive content-measurement effect used by autosize-style container features.

content_measurement_rebind_listener: LocalProperty<()>

Rebinds content_measurement_listener when the content child list changes.

content_measurement_bound: Cell<bool>

Guards one-time setup of the reactive content-measurement listener pair.

projected_children_changed: LocalProperty<()>

Dirty signal emitted when the projected child set changes structurally.

slot_projection_changed: LocalProperty<()>

Dirty signal emitted when active slot sites or slot-index expressions may change the component-local projection resolution.

subscriptions: RefCell<Vec<LocalProperty<()>>>

subscription properties: added to this expanded node by calling ctx.subscribe in a node event handler

transition_phase: LocalProperty<u64>

Current lifecycle transition phase for this node.

transition_generation: LocalProperty<u64>

Monotonic identity for each lifecycle transition run.

transition_takeover: LocalProperty<bool>

Whether the current run directly reversed the opposite lifecycle phase.

transition_selector_classes: RefCell<Option<Vec<String>>>

Class membership captured at lifecycle-transition start. Ordinary settings continue to follow live classes, while transition tracks keep the selector membership that launched the current run.

transition_origin_frame: LocalProperty<u64>

Frame at which the active lifecycle transition began.

transition_origin_millis: LocalProperty<u64>

Millisecond clock value at which the active lifecycle transition began.

transition_playhead: LocalProperty<f64>

Local playhead, in frames, for the active lifecycle transition.

transition_playhead_millis: LocalProperty<f64>

Local playhead, in milliseconds, for the active lifecycle transition.

enter_cleanup_listener: LocalProperty<()>

Effect property used to stop enter-transition clock dependencies.

enter_cleanup_active: Cell<bool>

Whether enter cleanup should do work on frame ticks.

exit_started_millis: Cell<Option<u128>>

Wall-clock start for exit timeout enforcement.

exit_cleanup_listener: LocalProperty<()>

Effect property used to release deferred exit children.

exit_cleanup_active: Cell<bool>

Whether exit cleanup should do work on frame ticks.

imported_settings_layers: RefCell<Vec<RuntimeSettingsLayer>>

Imported provider layers currently active for this component instance.

import_settings_transition: RefCell<Option<LocalProperty<Option<SettingsTransitionConfig>>>>

imported_settings_signature: RefCell<Vec<RuntimeSettingsSignatureEntry>>

Ordered provider-node ids used to detect when the imported layer stack changed.

resolved_property_columns: RefCell<RuntimeResolvedPropertyColumns>

Layered property entries ordered from lowest to highest precedence.

resolved_property_provenance: RefCell<BTreeMap<String, RuntimeResolvedPropertyEntry>>

Winning property entry per key after layering and inline override.

reset_removed_runtime_properties: Cell<bool>

Requests a materialization pass that resets properties removed from the prior columns.

Implementations

impl ExpandedNode

pub fn is_render_source(&self) -> bool

Whether this live node supplies a mask rather than visible scene content.

pub fn mount_as_render_source( self: &Rc<Self>, owner: &Rc<Self>, context: &Rc<RuntimeContext>, )

Initialize a detached source using ordinary component lifetime machinery. Presentation and native-resource allocation remain disabled for this tree.

pub fn initialize_root( template: Rc<ComponentInstance>, ctx: &Rc<RuntimeContext>, ) -> Rc<Self>

pub fn recreate_with_new_data( self: &Rc<Self>, template: Rc<dyn InstanceNode>, context: &Rc<RuntimeContext>, )

pub fn fully_recreate_with_new_data( self: &Rc<Self>, template: Rc<dyn InstanceNode>, context: &Rc<RuntimeContext>, )

pub fn is_descendant_of( &self, other_expanded_node_id: &ExpandedNodeIdentifier, ) -> bool

Returns whether this node is a descendant of the ExpandedNode described by other_expanded_node_id (id) Currently requires traversing linked list of ancestry, incurring a O(log(n)) cost for a tree of n elements. This could be mitigated with caching/memoization, perhaps by storing a HashSet on each ExpandedNode describing its ancestry chain.

pub fn create_children_detached( self: &Rc<Self>, templates: impl IntoIterator<Item = (Rc<dyn InstanceNode>, Rc<RuntimePropertiesStackFrame>)>, context: &Rc<RuntimeContext>, template_parent: &Weak<ExpandedNode>, ) -> Vec<Rc<ExpandedNode>>

pub fn attach_children( self: &Rc<Self>, new_children: Vec<Rc<ExpandedNode>>, context: &Rc<RuntimeContext>, parent_frame: &LocalProperty<Option<ExpandedNodeIdentifier>>, ) -> Vec<Rc<ExpandedNode>>

pub fn attach_children_with_liquid_glass_scope( self: &Rc<Self>, new_children: Vec<Rc<ExpandedNode>>, context: &Rc<RuntimeContext>, parent_frame: &LocalProperty<Option<ExpandedNodeIdentifier>>, liquid_glass_scope: &LocalProperty<Option<NativeLiquidGlassScope>>, ) -> Vec<Rc<ExpandedNode>>

pub fn attach_sidecar_children( self: &Rc<Self>, new_children: Vec<Rc<ExpandedNode>>, context: &Rc<RuntimeContext>, parent_frame: &LocalProperty<Option<ExpandedNodeIdentifier>>, ) -> Vec<Rc<ExpandedNode>>

pub fn inherit_suspend(self: &Rc<Self>, node: &Rc<Self>)

pub fn generate_children( self: &Rc<Self>, templates: impl IntoIterator<Item = (Rc<dyn InstanceNode>, Rc<RuntimePropertiesStackFrame>)>, context: &Rc<RuntimeContext>, parent_frame: &LocalProperty<Option<ExpandedNodeIdentifier>>, is_mount: bool, ) -> Vec<Rc<ExpandedNode>>

pub fn generate_children_with_liquid_glass_scope( self: &Rc<Self>, templates: impl IntoIterator<Item = (Rc<dyn InstanceNode>, Rc<RuntimePropertiesStackFrame>)>, context: &Rc<RuntimeContext>, parent_frame: &LocalProperty<Option<ExpandedNodeIdentifier>>, liquid_glass_scope: &LocalProperty<Option<NativeLiquidGlassScope>>, is_mount: bool, ) -> Vec<Rc<ExpandedNode>>

pub fn run_lifecycle_handlers( self: &Rc<Self>, handler_key: &str, context: &Rc<RuntimeContext>, )

Run tick or pre-render handlers on this node unless it is detached or suspended. Inline handlers receive their authored component’s state and this node’s context.

pub fn recurse_update(self: &Rc<Self>, context: &Rc<RuntimeContext>)

pub fn recurse_sync_import_settings( self: &Rc<Self>, context: &Rc<RuntimeContext>, )

pub fn recurse_control_flow_expansion( self: &Rc<Self>, context: &Rc<RuntimeContext>, )

pub fn recurse_mount(self: &Rc<Self>, context: &Rc<RuntimeContext>)

pub fn async_scope( &self, context: &Rc<RuntimeContext>, ) -> Result<AsyncScope, AsyncError>

pub fn recurse_unmount(self: Rc<Self>, context: &Rc<RuntimeContext>)

pub fn is_import_settings_node(&self) -> bool

pub fn is_in_import_settings_subtree(&self) -> bool

pub fn sync_imported_settings(self: &Rc<Self>, context: &Rc<RuntimeContext>)

pub fn recurse_render_queue( self: &Rc<Self>, ctx: &Rc<RuntimeContext>, rcs: &mut dyn RenderContext, )

pub fn recurse_render( self: &Rc<Self>, ctx: &Rc<RuntimeContext>, rcs: &mut dyn RenderContext, )

pub fn recurse_render_alpha_source( self: &Rc<Self>, ctx: &Rc<RuntimeContext>, rcs: &mut dyn RenderContext, )

Records a detached source using ordinary vector hooks without presenting it or allocating native surfaces. Structural components retain their normal back-to-front child order.

pub fn with_properties_unwrapped<T: ToFromPaxAny, R>( &self, callback: impl FnOnce(&mut T) -> R, ) -> R

Manages unpacking an Rc<RefCell<PaxValue>>, downcasting into the parameterized target_type, and executing a provided closure body in the context of that unwrapped variant (including support for mutable operations), the closure is executed. Used at least by calculating properties in expand_node and passing &mut self into event handlers (where the typed self is retrieved from an instance of PaxValue)

pub fn try_with_properties_unwrapped<T: ToFromPaxAny, R>( &self, callback: impl FnOnce(&mut T) -> R, ) -> Option<R>

pub fn recurse_visit_postorder( self: &Rc<Self>, func: &mut impl FnMut(&Rc<Self>), )

pub fn get_node_context( self: &Rc<Self>, ctx: &Rc<RuntimeContext>, ) -> NodeContext

pub fn get_common_properties(&self) -> Rc<RefCell<CommonProperties>>

pub fn is_layout_breakout(&self) -> bool

pub fn ray_cast_test(&self, ray: Point2<Window>) -> bool

Determines whether the provided ray, orthogonal to the view plane, intersects this ExpandedNode.

pub fn compute_flattened_projected_children(&self)

pub fn dispatch_scroll( self: &Rc<Self>, event: Event<Scroll>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_touch_start( self: &Rc<Self>, event: Event<TouchStart>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_touch_move( self: &Rc<Self>, event: Event<TouchMove>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_touch_end( self: &Rc<Self>, event: Event<TouchEnd>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_touch_cancel( self: &Rc<Self>, event: Event<TouchCancel>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_key_down( self: &Rc<Self>, event: Event<KeyDown>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_key_up( self: &Rc<Self>, event: Event<KeyUp>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_key_press( self: &Rc<Self>, event: Event<KeyPress>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_checkbox_change( self: &Rc<Self>, event: Event<CheckboxChange>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_slider_change( self: &Rc<Self>, event: Event<SliderChange>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_textbox_change( self: &Rc<Self>, event: Event<TextboxChange>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_text_input( self: &Rc<Self>, event: Event<TextInput>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_textbox_input( self: &Rc<Self>, event: Event<TextboxInput>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_button_click( self: &Rc<Self>, event: Event<ButtonClick>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_photo_picker_change( self: &Rc<Self>, event: Event<PhotoPickerChange>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_mouse_down( self: &Rc<Self>, event: Event<MouseDown>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_mouse_up( self: &Rc<Self>, event: Event<MouseUp>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_mouse_move( self: &Rc<Self>, event: Event<MouseMove>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_mouse_over( self: &Rc<Self>, event: Event<MouseOver>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_mouse_out( self: &Rc<Self>, event: Event<MouseOut>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_double_click( self: &Rc<Self>, event: Event<DoubleClick>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_context_menu( self: &Rc<Self>, event: Event<ContextMenu>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_click( self: &Rc<Self>, event: Event<Click>, _globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_tap( self: &Rc<Self>, event: Event<Click>, _globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_wheel( self: &Rc<Self>, event: Event<Wheel>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_drop( self: &Rc<Self>, event: Event<Drop>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_gyro( self: &Rc<Self>, event: Event<Gyro>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_accel( self: &Rc<Self>, event: Event<Accel>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_focus( self: &Rc<Self>, event: Event<Focus>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_select_start( self: &Rc<Self>, event: Event<SelectStart>, globals: &Globals, ctx: &Rc<RuntimeContext>, ) -> bool

pub fn dispatch_custom_event( self: &Rc<Self>, identifier: &str, ctx: &Rc<RuntimeContext>, ) -> Result<(), String>

pub fn set_measured_size(self: &Rc<ExpandedNode>, width: f64, height: f64)

pub fn chassis_resize_request(self: &Rc<ExpandedNode>, width: f64, height: f64)

pub fn layout_properties( self: &Rc<ExpandedNode>, ) -> LocalProperty<LayoutProperties>

Helper method that returns a collection of common properties related to layout (position, size, scale, anchor, etc),

Trait Implementations

impl Clone for ExpandedNode

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExpandedNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ImplToFromPaxAny for ExpandedNode

impl Interpolatable for ExpandedNode

fn interpolate(&self, _other: &Self, _t: f64) -> Self

Interpolates this value toward other at time t on the unit interval.