Struct freya::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> EventHandler<T>

where T: 'static,

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

Create a new EventHandler from an FnMut

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) -> EventHandler<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for EventHandler<T>

where T: 'static,

fn default() -> EventHandler<T>

Returns the “default value” for a type.

impl<T> Deref for EventHandler<T>

where T: 'static,

type Target = dyn Fn(T)

The resulting type after dereferencing.

fn deref(&self) -> &<EventHandler<T> as Deref>::Target

Dereferences the value.

impl<F, T> From<F> for EventHandler<T>

where F: FnMut(T) + 'static, T: 'static,

fn from(f: F) -> EventHandler<T>

Converts to this type from the input type.

impl<T> PartialEq for EventHandler<T>

where T: 'static,

fn eq(&self, _: &EventHandler<T>) -> 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>