Trait leptos_dom::EventHandler

pub trait EventHandler {
    // Required method
    fn attach<T: DOMEventResponder>(self, target: T) -> T;
}

Type that can be used to handle DOM events

Required Methods

fn attach<T: DOMEventResponder>(self, target: T) -> T

Attaches event listener to any target that can respond to DOM events

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<A> EventHandler for (A,)

where A: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B> EventHandler for (A, B)

where A: EventHandler, B: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C> EventHandler for (A, B, C)

where A: EventHandler, B: EventHandler, C: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D> EventHandler for (A, B, C, D)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E> EventHandler for (A, B, C, D, E)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F> EventHandler for (A, B, C, D, E, F)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G> EventHandler for (A, B, C, D, E, F, G)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H> EventHandler for (A, B, C, D, E, F, G, H)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I> EventHandler for (A, B, C, D, E, F, G, H, I)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J> EventHandler for (A, B, C, D, E, F, G, H, I, J)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K> EventHandler for (A, B, C, D, E, F, G, H, I, J, K)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler, V: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler, V: EventHandler, W: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler, V: EventHandler, W: EventHandler, X: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler, V: EventHandler, W: EventHandler, X: EventHandler, Y: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> EventHandler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: EventHandler, B: EventHandler, C: EventHandler, D: EventHandler, E: EventHandler, F: EventHandler, G: EventHandler, H: EventHandler, I: EventHandler, J: EventHandler, K: EventHandler, L: EventHandler, M: EventHandler, N: EventHandler, O: EventHandler, P: EventHandler, Q: EventHandler, R: EventHandler, S: EventHandler, T: EventHandler, U: EventHandler, V: EventHandler, W: EventHandler, X: EventHandler, Y: EventHandler, Z: EventHandler,

fn attach<RES: DOMEventResponder>(self, target: RES) -> RES

impl<F> EventHandler for (DOMContentLoaded, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (abort, F)

where F: FnMut(UiEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (afterprint, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (animationcancel, F)

where F: FnMut(AnimationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (animationend, F)

where F: FnMut(AnimationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (animationiteration, F)

where F: FnMut(AnimationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (animationstart, F)

where F: FnMut(AnimationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (auxclick, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (beforeinput, F)

where F: FnMut(InputEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (beforeprint, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (beforeunload, F)

where F: FnMut(BeforeUnloadEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (blur, F)

where F: FnMut(FocusEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (canplay, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (canplaythrough, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (change, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (click, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (close, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (compositionend, F)

where F: FnMut(CompositionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (compositionstart, F)

where F: FnMut(CompositionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (compositionupdate, F)

where F: FnMut(CompositionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (contextmenu, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (copy, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (cuechange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (cut, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dblclick, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (devicemotion, F)

where F: FnMut(DeviceMotionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (deviceorientation, F)

where F: FnMut(DeviceOrientationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (drag, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dragend, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dragenter, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dragleave, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dragover, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (dragstart, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (drop, F)

where F: FnMut(DragEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (durationchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (emptied, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (ended, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (error, F)

where F: FnMut(ErrorEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (focus, F)

where F: FnMut(FocusEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (focusin, F)

where F: FnMut(FocusEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (focusout, F)

where F: FnMut(FocusEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (formdata, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (fullscreenchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (fullscreenerror, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (gamepadconnected, F)

where F: FnMut(GamepadEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (gamepaddisconnected, F)

where F: FnMut(GamepadEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (gotpointercapture, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (hashchange, F)

where F: FnMut(HashChangeEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (input, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (invalid, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (keydown, F)

where F: FnMut(KeyboardEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (keypress, F)

where F: FnMut(KeyboardEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (keyup, F)

where F: FnMut(KeyboardEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (languagechange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (load, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (loadeddata, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (loadedmetadata, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (loadstart, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (lostpointercapture, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (message, F)

where F: FnMut(MessageEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (messageerror, F)

where F: FnMut(MessageEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mousedown, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mouseenter, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mouseleave, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mousemove, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mouseout, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mouseover, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (mouseup, F)

where F: FnMut(MouseEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (offline, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (online, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (orientationchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pagehide, F)

where F: FnMut(PageTransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pageshow, F)

where F: FnMut(PageTransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (paste, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pause, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (play, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (playing, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointercancel, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerdown, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerenter, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerleave, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerlockchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerlockerror, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointermove, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerout, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerover, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (pointerup, F)

where F: FnMut(PointerEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (popstate, F)

where F: FnMut(PopStateEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (progress, F)

where F: FnMut(ProgressEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (ratechange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (readystatechange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (rejectionhandled, F)

where F: FnMut(PromiseRejectionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (reset, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (resize, F)

where F: FnMut(UiEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (scroll, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (scrollend, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (securitypolicyviolation, F)

where F: FnMut(SecurityPolicyViolationEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (seeked, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (seeking, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (select, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (selectionchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (selectstart, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (slotchange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (stalled, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (storage, F)

where F: FnMut(StorageEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (submit, F)

where F: FnMut(SubmitEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (suspend, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (timeupdate, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (toggle, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (touchcancel, F)

where F: FnMut(TouchEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (touchend, F)

where F: FnMut(TouchEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (touchmove, F)

where F: FnMut(TouchEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (touchstart, F)

where F: FnMut(TouchEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (transitioncancel, F)

where F: FnMut(TransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (transitionend, F)

where F: FnMut(TransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (transitionrun, F)

where F: FnMut(TransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (transitionstart, F)

where F: FnMut(TransitionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (unhandledrejection, F)

where F: FnMut(PromiseRejectionEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (unload, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (visibilitychange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (volumechange, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (waiting, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (webkitanimationend, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (webkitanimationiteration, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (webkitanimationstart, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (webkittransitionend, F)

where F: FnMut(Event) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<F> EventHandler for (wheel, F)

where F: FnMut(WheelEvent) + 'static,

fn attach<L: DOMEventResponder>(self, target: L) -> L

impl<T> EventHandler for Option<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for BinaryHeap<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for BTreeSet<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for LinkedList<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for VecDeque<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for Vec<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T> EventHandler for HashSet<T>

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

impl<T, const N: usize> EventHandler for [T; N]

where T: EventHandler,

fn attach<R: DOMEventResponder>(self, target: R) -> R

Implementors

impl EventHandler for GenericEventHandler