Struct dioxus_core::prelude::EventHandler

pub struct EventHandler<T = ()> { /* private fields */ }

The callback type generated by the rsx! macro when an on field is specified for components.

This makes it possible to pass move |evt| {} style closures into components as property fields.

Example

rsx!{
    MyComponent { onclick: move |evt| tracing::debug!("clicked") }
}

#[derive(Props)]
struct MyProps {
    onclick: EventHandler<MouseEvent>,
}

fn MyComponent(cx: MyProps) -> Element {
    rsx!{
        button {
            onclick: move |evt| cx.onclick.call(evt),
        }
    }
}

Implementations

impl<T: 'static> EventHandler<T>

pub fn new(f: impl FnMut(T) + 'static) -> EventHandler<T>

Create a new EventHandler from an FnMut. The callback is owned by the current scope and will be dropped when the scope is dropped. This should not be called directly in the body of a component because it will not be dropped until the component is dropped.

pub fn leak(f: impl FnMut(T) + 'static) -> EventHandler<T>

Leak a new EventHandler that will not be dropped unless it is manually dropped.

pub fn call(&self, event: T)

Call this event handler with the appropriate event type

This borrows the event using a RefCell. Recursively calling a listener will cause a panic.

pub fn release(&self)

Forcibly drop the internal handler callback, releasing memory

This will force any future calls to “call” to not doing anything

Trait Implementations

impl<T> Clone for EventHandler<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for EventHandler<T>

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

Formats the value using the given formatter.

impl<T: 'static> Default for EventHandler<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: 'static> Deref for EventHandler<T>

type Target = dyn Fn(T)

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F: FnMut(T) + 'static, T: 'static> From<F> for EventHandler<T>

fn from(f: F) -> Self

Converts to this type from the input type.

impl<T: 'static> PartialEq for EventHandler<T>

fn eq(&self, _: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Copy for EventHandler<T>