Trait ModifierNode

Source

pub trait ModifierNode: Any + DelegatableNode {
Show 15 methods    // Provided methods
    fn on_attach(&mut self, _context: &mut dyn ModifierNodeContext) { ... }
    fn on_detach(&mut self) { ... }
    fn on_reset(&mut self) { ... }
    fn as_draw_node(&self) -> Option<&dyn DrawModifierNode> { ... }
    fn as_draw_node_mut(&mut self) -> Option<&mut dyn DrawModifierNode> { ... }
    fn as_pointer_input_node(&self) -> Option<&dyn PointerInputNode> { ... }
    fn as_pointer_input_node_mut(&mut self) -> Option<&mut dyn PointerInputNode> { ... }
    fn as_semantics_node(&self) -> Option<&dyn SemanticsNode> { ... }
    fn as_semantics_node_mut(&mut self) -> Option<&mut dyn SemanticsNode> { ... }
    fn as_focus_node(&self) -> Option<&dyn FocusNode> { ... }
    fn as_focus_node_mut(&mut self) -> Option<&mut dyn FocusNode> { ... }
    fn as_layout_node(&self) -> Option<&dyn LayoutModifierNode> { ... }
    fn as_layout_node_mut(&mut self) -> Option<&mut dyn LayoutModifierNode> { ... }
    fn for_each_delegate<'b>(
        &'b self,
        _visitor: &mut dyn FnMut(&'b dyn ModifierNode),
    ) { ... }
    fn for_each_delegate_mut<'b>(
        &'b mut self,
        _visitor: &mut dyn FnMut(&'b mut dyn ModifierNode),
    ) { ... }
}

Expand description

Core trait implemented by modifier nodes.

§Capability-Driven Architecture

This trait follows Jetpack Compose’s Modifier.Node pattern where nodes declare their capabilities via NodeCapabilities and implement specialized traits (DrawModifierNode, PointerInputNode, SemanticsNode, FocusNode, etc.) to participate in specific pipeline stages.

§How to Implement a Modifier Node

Declare capabilities in your ModifierNodeElement::capabilities() implementation
Implement specialized traits for the capabilities you declared
Use helper macros to reduce boilerplate (recommended)

§Example: Draw Node

use cranpose_foundation::*;

struct MyDrawNode {
    state: NodeState,
    color: Color,
}

impl DelegatableNode for MyDrawNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for MyDrawNode {
    // Use the helper macro instead of manual as_* implementations
    impl_modifier_node!(draw);
}

impl DrawModifierNode for MyDrawNode {
    fn draw(&mut self, _context: &mut dyn ModifierNodeContext, draw_scope: &mut dyn DrawScope) {
        // Drawing logic here
    }
}

§Example: Multi-Capability Node

impl ModifierNode for MyComplexNode {
    // This node participates in draw, pointer input, and semantics
    impl_modifier_node!(draw, pointer_input, semantics);
}

§Lifecycle Callbacks

Nodes receive lifecycle callbacks when they attach to or detach from a composition and may optionally react to resets triggered by the runtime (for example, when reusing nodes across modifier list changes).