Struct freya::prelude::Event

pub struct Event<T>
where
    T: 'static + ?Sized,
{
    pub data: Rc<T>,
    /* private fields */
}

A wrapper around some generic data that handles the event’s state

Prevent this event from continuing to bubble up the tree to parent elements.

Example

rsx! {
    button {
        onclick: move |evt: Event<MouseData>| {
            evt.stop_propagation();
        }
    }
};

Fields

data: Rc<T>

The data associated with this event

Implementations

impl<T> Event<T>

pub fn map<U, F>(&self, f: F) -> Event<U>

where U: 'static, F: FnOnce(&T) -> U,

Map the event data to a new type

Example

rsx! {
   button {
      onclick: move |evt: MouseEvent| {
         let data = evt.map(|data| data.client_coordinates());
         println!("{:?}", data.data());
      }
   }
};

pub fn cancel_bubble(&self)

👎Deprecated: use stop_propagation instead

Prevent this event from continuing to bubble up the tree to parent elements.

Example

rsx! {
    button {
        onclick: move |evt: Event<MouseData>| {
            evt.cancel_bubble();
        }
    }
};

pub fn stop_propagation(&self)

Prevent this event from continuing to bubble up the tree to parent elements.

Example

rsx! {
    button {
        onclick: move |evt: Event<MouseData>| {
            evt.stop_propagation();
        }
    }
};

pub fn data(&self) -> Rc<T>

Get a reference to the inner data from this event

rsx! {
    button {
        onclick: move |evt: Event<MouseData>| {
            let data = evt.data();
            async move {
                println!("{:?}", data);
            }
        }
    }
};

Trait Implementations

impl<T> Clone for Event<T>

where T: ?Sized,

fn clone(&self) -> Event<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Event<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Event<T>

type Target = Rc<T>

The resulting type after dereferencing.

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

Dereferences the value.