Struct patternfly_dioxus::NodeFactory

pub struct NodeFactory<'a> { /* private fields */ }

This struct provides an ergonomic API to quickly build VNodes.

NodeFactory is used to build VNodes in the component’s memory space. This struct adds metadata to the final VNode about listeners, attributes, and children

Implementations

impl<'a> NodeFactory<'a>

pub fn new(scope: &'a ScopeState) -> NodeFactory<'a>

Create a new NodeFactory from a Scope or ScopeState

pub fn bump(&self) -> &'a Bump

Get the custom allocator for this component

pub fn static_text(&self, text: &'static str) -> VNode<'a>

Directly pass in text blocks without the need to use the format_args macro.

pub fn raw_text(&self, args: Arguments<'_>) -> (&'a str, bool)

Parses a lazy text Arguments and returns a string and a flag indicating if the text is ’static

Text that’s static may be pointer compared, making it cheaper to diff

pub fn text(&self, args: Arguments<'_>) -> VNode<'a>

Create some text that’s allocated along with the other vnodes

pub fn element(
    &self,
    el: impl DioxusElement,
    listeners: &'a [Listener<'a>],
    attributes: &'a [Attribute<'a>],
    children: &'a [VNode<'a>],
    key: Option<Arguments<'_>>
) -> VNode<'a>

Create a new [VNode::VElement]

pub fn raw_element(
    &self,
    tag_name: &'static str,
    namespace: Option<&'static str>,
    listeners: &'a [Listener<'a>],
    attributes: &'a [Attribute<'a>],
    children: &'a [VNode<'a>],
    key: Option<Arguments<'_>>
) -> VNode<'a>

Create a new [VNode::VElement] without the trait bound

IE pass in “div” instead of div

pub fn attr(
    &self,
    name: &'static str,
    val: Arguments<'_>,
    namespace: Option<&'static str>,
    is_volatile: bool
) -> Attribute<'a>

Create a new [Attribute]

pub fn component<P>(
    &self,
    component: fn(Scope<'a, P>) -> Option<VNode<'a>>,
    props: P,
    key: Option<Arguments<'_>>,
    fn_name: &'static str
) -> VNode<'a>where
    P: 'a + Properties,

Create a new [VNode::VComponent]

pub fn listener(
    self,
    event: &'static str,
    callback: &'a RefCell<Option<Box<'a, dyn FnMut(AnyEvent) + 'a>>>
) -> Listener<'a>

Create a new [Listener]

pub fn fragment_root<'b, 'c>(
    self,
    node_iter: impl IntoIterator<Item = impl IntoVNode<'a> + 'c> + 'b
) -> VNode<'a>

Create a new [VNode::VFragment] from a root of the rsx! call

pub fn fragment_from_iter<'b, 'c>(
    self,
    node_iter: impl IntoIterator<Item = impl IntoVNode<'a> + 'c> + 'b
) -> VNode<'a>

Create a new [VNode::VFragment] from any iterator

pub fn create_children(
    self,
    node_iter: impl IntoIterator<Item = impl IntoVNode<'a>>
) -> Option<VNode<'a>>

Create a new VNode from any iterator of children

pub fn event_handler<T>(self, f: impl FnMut(T) + 'a) -> EventHandler<'a, T>

Create a new EventHandler from an FnMut

Trait Implementations

impl<'a> Clone for NodeFactory<'a>

fn clone(&self) -> NodeFactory<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeFactory<'_>

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

Formats the value using the given formatter.

impl<'a> Copy for NodeFactory<'a>