Merge pull request #61 from Smithay/feature/input_eventloop

Add EventLoopHandle to `InputBackend` and `InputHandler` traits

examples/udev.rs

@@ -55,7 +55,7 @@ use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
-use wayland_server::{Display, StateProxy, StateToken};
+use wayland_server::{Display, EventLoopHandle, StateProxy, StateToken};
 use wayland_server::protocol::{wl_output, wl_pointer};
 use xkbcommon::xkb::keysyms as xkb;
 
@@ -78,16 +78,18 @@ impl LibinputInputHandler {
 }
 
 impl InputHandler<LibinputInputBackend> for LibinputInputHandler {
-    fn on_seat_created(&mut self, _: &input::Seat) {
+    fn on_seat_created(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* we just create a single static one */
     }
-    fn on_seat_destroyed(&mut self, _: &input::Seat) {
+    fn on_seat_destroyed(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* we just create a single static one */
     }
-    fn on_seat_changed(&mut self, _: &input::Seat) {
+    fn on_seat_changed(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* we just create a single static one */
     }
-    fn on_keyboard_key(&mut self, _: &input::Seat, evt: event::keyboard::KeyboardKeyEvent) {
+    fn on_keyboard_key(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: event::keyboard::KeyboardKeyEvent
+    ) {
         let keycode = evt.key();
         let state = evt.state();
         debug!(self.log, "key"; "keycode" => keycode, "state" => format!("{:?}", state));
@@ -106,7 +108,9 @@ impl InputHandler<LibinputInputBackend> for LibinputInputHandler {
                 }
             });
     }
-    fn on_pointer_move(&mut self, _: &input::Seat, evt: event::pointer::PointerMotionEvent) {
+    fn on_pointer_move(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: event::pointer::PointerMotionEvent
+    ) {
         let (x, y) = (evt.dx(), evt.dy());
         let serial = self.next_serial();
         let mut location = self.pointer_location.borrow_mut();
@@ -121,7 +125,10 @@ impl InputHandler<LibinputInputBackend> for LibinputInputHandler {
             evt.time(),
         );
     }
-    fn on_pointer_move_absolute(&mut self, _: &input::Seat, evt: event::pointer::PointerMotionAbsoluteEvent) {
+    fn on_pointer_move_absolute(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat,
+        evt: event::pointer::PointerMotionAbsoluteEvent,
+    ) {
         let (x, y) = (
             evt.absolute_x_transformed(self.screen_size.0),
             evt.absolute_y_transformed(self.screen_size.1),
@@ -135,7 +142,9 @@ impl InputHandler<LibinputInputBackend> for LibinputInputHandler {
             evt.time(),
         );
     }
-    fn on_pointer_button(&mut self, _: &input::Seat, evt: event::pointer::PointerButtonEvent) {
+    fn on_pointer_button(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: event::pointer::PointerButtonEvent
+    ) {
         let serial = self.next_serial();
         let button = evt.button();
         let state = match evt.state() {
@@ -152,29 +161,39 @@ impl InputHandler<LibinputInputBackend> for LibinputInputHandler {
         };
         self.pointer.button(button, state, serial, evt.time());
     }
-    fn on_pointer_axis(&mut self, _: &input::Seat, evt: LibinputPointerAxisEvent) {
+    fn on_pointer_axis(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: LibinputPointerAxisEvent
+    ) {
         let axis = match evt.axis() {
             input::Axis::Vertical => wayland_server::protocol::wl_pointer::Axis::VerticalScroll,
             input::Axis::Horizontal => wayland_server::protocol::wl_pointer::Axis::HorizontalScroll,
         };
         self.pointer.axis(axis, evt.amount(), evt.time());
     }
-    fn on_touch_down(&mut self, _: &input::Seat, _: event::touch::TouchDownEvent) {
+    fn on_touch_down(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: event::touch::TouchDownEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_motion(&mut self, _: &input::Seat, _: event::touch::TouchMotionEvent) {
+    fn on_touch_motion(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: event::touch::TouchMotionEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_up(&mut self, _: &input::Seat, _: event::touch::TouchUpEvent) {
+    fn on_touch_up(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: event::touch::TouchUpEvent) {
         /* not done in this example */
     }
-    fn on_touch_cancel(&mut self, _: &input::Seat, _: event::touch::TouchCancelEvent) {
+    fn on_touch_cancel(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: event::touch::TouchCancelEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_frame(&mut self, _: &input::Seat, _: event::touch::TouchFrameEvent) {
+    fn on_touch_frame(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: event::touch::TouchFrameEvent
+    ) {
         /* not done in this example */
     }
-    fn on_input_config_changed(&mut self, _: &mut [LibinputDevice]) {
+    fn on_input_config_changed(&mut self, _evlh: &mut EventLoopHandle, _: &mut [LibinputDevice]) {
         /* not done in this example */
     }
 }
@@ -304,7 +323,9 @@ fn main() {
     let libinput_session_id = notifier.register(libinput_context.clone());
     libinput_context.udev_assign_seat(&seat).unwrap();
     let mut libinput_backend = LibinputInputBackend::new(libinput_context, log.clone());
-    libinput_backend.set_handler(LibinputInputHandler {
+    libinput_backend.set_handler(
+        &mut event_loop,
+        LibinputInputHandler {
             log: log.clone(),
             pointer,
             keyboard,
@@ -313,7 +334,8 @@ fn main() {
             screen_size: (w, h),
             serial: 0,
             running: running.clone(),
-    });
+        },
+    );
     let libinput_event_source = libinput_bind(libinput_backend, &mut event_loop).unwrap();
 
     let session_event_source = direct_session_bind(notifier, &mut event_loop, log.clone()).unwrap();

examples/winit.rs

@@ -26,6 +26,7 @@ use smithay::wayland::seat::{KeyboardHandle, PointerHandle, Seat};
 use smithay::wayland::shm::init_shm_global;
 use std::cell::RefCell;
 use std::rc::Rc;
+use wayland_server::EventLoopHandle;
 use wayland_server::protocol::{wl_output, wl_pointer};
 
 struct WinitInputHandler {
@@ -45,26 +46,30 @@ impl WinitInputHandler {
 }
 
 impl InputHandler<winit::WinitInputBackend> for WinitInputHandler {
-    fn on_seat_created(&mut self, _: &input::Seat) {
+    fn on_seat_created(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* never happens with winit */
     }
-    fn on_seat_destroyed(&mut self, _: &input::Seat) {
+    fn on_seat_destroyed(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* never happens with winit */
     }
-    fn on_seat_changed(&mut self, _: &input::Seat) {
+    fn on_seat_changed(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat) {
         /* never happens with winit */
     }
-    fn on_keyboard_key(&mut self, _: &input::Seat, evt: winit::WinitKeyboardInputEvent) {
+    fn on_keyboard_key(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: winit::WinitKeyboardInputEvent
+    ) {
         let keycode = evt.key_code();
         let state = evt.state();
         debug!(self.log, "key"; "keycode" => keycode, "state" => format!("{:?}", state));
         let serial = self.next_serial();
         self.keyboard.input(keycode, state, serial, |_, _| true);
     }
-    fn on_pointer_move(&mut self, _: &input::Seat, _: input::UnusedEvent) {
+    fn on_pointer_move(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: input::UnusedEvent) {
         /* never happens with winit */
     }
-    fn on_pointer_move_absolute(&mut self, _: &input::Seat, evt: winit::WinitMouseMovedEvent) {
+    fn on_pointer_move_absolute(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: winit::WinitMouseMovedEvent
+    ) {
         // on winit, mouse events are already in pixel coordinates
         let (x, y) = evt.position();
         self.pointer_location = (x, y);
@@ -76,7 +81,9 @@ impl InputHandler<winit::WinitInputBackend> for WinitInputHandler {
             evt.time(),
         );
     }
-    fn on_pointer_button(&mut self, _: &input::Seat, evt: winit::WinitMouseInputEvent) {
+    fn on_pointer_button(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: winit::WinitMouseInputEvent
+    ) {
         let serial = self.next_serial();
         let button = match evt.button() {
             input::MouseButton::Left => 0x110,
@@ -98,29 +105,37 @@ impl InputHandler<winit::WinitInputBackend> for WinitInputHandler {
         };
         self.pointer.button(button, state, serial, evt.time());
     }
-    fn on_pointer_axis(&mut self, _: &input::Seat, evt: winit::WinitMouseWheelEvent) {
+    fn on_pointer_axis(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, evt: winit::WinitMouseWheelEvent
+    ) {
         let axis = match evt.axis() {
             input::Axis::Vertical => wayland_server::protocol::wl_pointer::Axis::VerticalScroll,
             input::Axis::Horizontal => wayland_server::protocol::wl_pointer::Axis::HorizontalScroll,
         };
         self.pointer.axis(axis, evt.amount(), evt.time());
     }
-    fn on_touch_down(&mut self, _: &input::Seat, _: winit::WinitTouchStartedEvent) {
+    fn on_touch_down(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: winit::WinitTouchStartedEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_motion(&mut self, _: &input::Seat, _: winit::WinitTouchMovedEvent) {
+    fn on_touch_motion(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: winit::WinitTouchMovedEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_up(&mut self, _: &input::Seat, _: winit::WinitTouchEndedEvent) {
+    fn on_touch_up(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: winit::WinitTouchEndedEvent) {
         /* not done in this example */
     }
-    fn on_touch_cancel(&mut self, _: &input::Seat, _: winit::WinitTouchCancelledEvent) {
+    fn on_touch_cancel(
+        &mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: winit::WinitTouchCancelledEvent
+    ) {
         /* not done in this example */
     }
-    fn on_touch_frame(&mut self, _: &input::Seat, _: input::UnusedEvent) {
+    fn on_touch_frame(&mut self, _evlh: &mut EventLoopHandle, _: &input::Seat, _: input::UnusedEvent) {
         /* never happens with winit */
     }
-    fn on_input_config_changed(&mut self, _: &mut ()) {
+    fn on_input_config_changed(&mut self, _evlh: &mut EventLoopHandle, _: &mut ()) {
         /* never happens with winit */
     }
 }
@@ -201,14 +216,17 @@ fn main() {
             refresh: 60_000,
         });
 
-    input.set_handler(WinitInputHandler {
+    input.set_handler(
+        &mut event_loop,
+        WinitInputHandler {
             log: log.clone(),
             pointer,
             keyboard,
             window_map: window_map.clone(),
             pointer_location: (0.0, 0.0),
             serial: 0,
-    });
+        },
+    );
 
     /*
      * Add a listening socket:
@@ -217,7 +235,7 @@ fn main() {
     println!("Listening on socket: {}", name);
 
     loop {
-        input.dispatch_new_events().unwrap();
+        input.dispatch_new_events(&mut event_loop).unwrap();
 
         let mut frame = drawer.draw();
         frame.clear(None, Some((0.8, 0.8, 0.9, 1.0)), false, Some(1.0), None);

src/backend/input.rs

@@ -1,6 +1,7 @@
 //! Common traits for input backends to receive input from.
 
 use std::error::Error;
+use wayland_server::EventLoopHandle;
 
 /// A seat describes a group of input devices and at least one
 /// graphics device belonging together.
@@ -506,31 +507,31 @@ pub trait InputBackend: Sized {
     type TouchFrameEvent: TouchFrameEvent;
 
     /// Sets a new handler for this `InputBackend`
-    fn set_handler<H: InputHandler<Self> + 'static>(&mut self, handler: H);
+    fn set_handler<H: InputHandler<Self> + 'static>(&mut self, evlh: &mut EventLoopHandle, handler: H);
     /// Get a reference to the currently set handler, if any
     fn get_handler(&mut self) -> Option<&mut InputHandler<Self>>;
     /// Clears the currently handler, if one is set
-    fn clear_handler(&mut self);
+    fn clear_handler(&mut self, evlh: &mut EventLoopHandle);
 
     /// Get current `InputConfig`
     fn input_config(&mut self) -> &mut Self::InputConfig;
 
     /// Processes new events of the underlying backend and drives the `InputHandler`.
-    fn dispatch_new_events(&mut self) -> Result<(), Self::EventError>;
+    fn dispatch_new_events(&mut self, evlh: &mut EventLoopHandle) -> Result<(), Self::EventError>;
 }
 
 /// Implement to receive input events from any `InputBackend`.
 pub trait InputHandler<B: InputBackend> {
     /// Called when a new `Seat` has been created
-    fn on_seat_created(&mut self, seat: &Seat);
+    fn on_seat_created(&mut self, evlh: &mut EventLoopHandle, seat: &Seat);
     /// Called when an existing `Seat` has been destroyed.
-    fn on_seat_destroyed(&mut self, seat: &Seat);
+    fn on_seat_destroyed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat);
     /// Called when a `Seat`'s properties have changed.
     ///
     /// ## Note:
     ///
     /// It is not guaranteed that any change has actually happened.
-    fn on_seat_changed(&mut self, seat: &Seat);
+    fn on_seat_changed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat);
 
     /// Called when a new keyboard event was received.
     ///
@@ -539,7 +540,7 @@ pub trait InputHandler<B: InputBackend> {
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The keyboard event
     ///
-    fn on_keyboard_key(&mut self, seat: &Seat, event: B::KeyboardKeyEvent);
+    fn on_keyboard_key(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::KeyboardKeyEvent);
 
     /// Called when a new pointer movement event was received.
     ///
@@ -547,28 +548,30 @@ pub trait InputHandler<B: InputBackend> {
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The pointer movement event
-    fn on_pointer_move(&mut self, seat: &Seat, event: B::PointerMotionEvent);
+    fn on_pointer_move(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerMotionEvent);
     /// Called when a new pointer absolute movement event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The pointer absolute movement event
-    fn on_pointer_move_absolute(&mut self, seat: &Seat, event: B::PointerMotionAbsoluteEvent);
+    fn on_pointer_move_absolute(
+        &mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerMotionAbsoluteEvent
+    );
     /// Called when a new pointer button event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The pointer button event
-    fn on_pointer_button(&mut self, seat: &Seat, event: B::PointerButtonEvent);
+    fn on_pointer_button(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerButtonEvent);
     /// Called when a new pointer scroll event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - A upward counting variable useful for event ordering. Makes no gurantees about actual time passed between events.
-    fn on_pointer_axis(&mut self, seat: &Seat, event: B::PointerAxisEvent);
+    fn on_pointer_axis(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerAxisEvent);
 
     /// Called when a new touch down event was received.
     ///
@@ -576,97 +579,99 @@ pub trait InputHandler<B: InputBackend> {
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The touch down event
-    fn on_touch_down(&mut self, seat: &Seat, event: B::TouchDownEvent);
+    fn on_touch_down(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchDownEvent);
     /// Called when a new touch motion event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The touch motion event.
-    fn on_touch_motion(&mut self, seat: &Seat, event: B::TouchMotionEvent);
+    fn on_touch_motion(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchMotionEvent);
     /// Called when a new touch up event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The touch up event.
-    fn on_touch_up(&mut self, seat: &Seat, event: B::TouchUpEvent);
+    fn on_touch_up(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchUpEvent);
     /// Called when a new touch cancel event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The touch cancel event.
-    fn on_touch_cancel(&mut self, seat: &Seat, event: B::TouchCancelEvent);
+    fn on_touch_cancel(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchCancelEvent);
     /// Called when a new touch frame event was received.
     ///
     /// # Arguments
     ///
     /// - `seat` - The `Seat` the event belongs to
     /// - `event` - The touch frame event.
-    fn on_touch_frame(&mut self, seat: &Seat, event: B::TouchFrameEvent);
+    fn on_touch_frame(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchFrameEvent);
 
     /// Called when the `InputConfig` was changed through an external event.
     ///
     /// What kind of events can trigger this call is completely backend dependent.
     /// E.g. an input devices was attached/detached or changed it's own configuration.
-    fn on_input_config_changed(&mut self, config: &mut B::InputConfig);
+    fn on_input_config_changed(&mut self, evlh: &mut EventLoopHandle, config: &mut B::InputConfig);
 }
 
 impl<B: InputBackend> InputHandler<B> for Box<InputHandler<B>> {
-    fn on_seat_created(&mut self, seat: &Seat) {
+    fn on_seat_created(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) {
-        (**self).on_seat_created(seat)
+        (**self).on_seat_created(evlh, seat)
     }
 
-    fn on_seat_destroyed(&mut self, seat: &Seat) {
+    fn on_seat_destroyed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) {
-        (**self).on_seat_destroyed(seat)
+        (**self).on_seat_destroyed(evlh, seat)
     }
 
-    fn on_seat_changed(&mut self, seat: &Seat) {
+    fn on_seat_changed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) {
-        (**self).on_seat_changed(seat)
+        (**self).on_seat_changed(evlh, seat)
     }
 
-    fn on_keyboard_key(&mut self, seat: &Seat, event: B::KeyboardKeyEvent) {
+    fn on_keyboard_key(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::KeyboardKeyEvent) {
-        (**self).on_keyboard_key(seat, event)
+        (**self).on_keyboard_key(evlh, seat, event)
     }
 
-    fn on_pointer_move(&mut self, seat: &Seat, event: B::PointerMotionEvent) {
+    fn on_pointer_move(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerMotionEvent) {
-        (**self).on_pointer_move(seat, event)
+        (**self).on_pointer_move(evlh, seat, event)
     }
 
-    fn on_pointer_move_absolute(&mut self, seat: &Seat, event: B::PointerMotionAbsoluteEvent) {
+    fn on_pointer_move_absolute(
-        (**self).on_pointer_move_absolute(seat, event)
+        &mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerMotionAbsoluteEvent
+    ) {
+        (**self).on_pointer_move_absolute(evlh, seat, event)
     }
 
-    fn on_pointer_button(&mut self, seat: &Seat, event: B::PointerButtonEvent) {
+    fn on_pointer_button(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerButtonEvent) {
-        (**self).on_pointer_button(seat, event)
+        (**self).on_pointer_button(evlh, seat, event)
     }
 
-    fn on_pointer_axis(&mut self, seat: &Seat, event: B::PointerAxisEvent) {
+    fn on_pointer_axis(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerAxisEvent) {
-        (**self).on_pointer_axis(seat, event)
+        (**self).on_pointer_axis(evlh, seat, event)
     }
 
-    fn on_touch_down(&mut self, seat: &Seat, event: B::TouchDownEvent) {
+    fn on_touch_down(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchDownEvent) {
-        (**self).on_touch_down(seat, event)
+        (**self).on_touch_down(evlh, seat, event)
     }
 
-    fn on_touch_motion(&mut self, seat: &Seat, event: B::TouchMotionEvent) {
+    fn on_touch_motion(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchMotionEvent) {
-        (**self).on_touch_motion(seat, event)
+        (**self).on_touch_motion(evlh, seat, event)
     }
 
-    fn on_touch_up(&mut self, seat: &Seat, event: B::TouchUpEvent) {
+    fn on_touch_up(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchUpEvent) {
-        (**self).on_touch_up(seat, event)
+        (**self).on_touch_up(evlh, seat, event)
     }
 
-    fn on_touch_cancel(&mut self, seat: &Seat, event: B::TouchCancelEvent) {
+    fn on_touch_cancel(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchCancelEvent) {
-        (**self).on_touch_cancel(seat, event)
+        (**self).on_touch_cancel(evlh, seat, event)
     }
 
-    fn on_touch_frame(&mut self, seat: &Seat, event: B::TouchFrameEvent) {
+    fn on_touch_frame(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchFrameEvent) {
-        (**self).on_touch_frame(seat, event)
+        (**self).on_touch_frame(evlh, seat, event)
     }
 
-    fn on_input_config_changed(&mut self, config: &mut B::InputConfig) {
+    fn on_input_config_changed(&mut self, evlh: &mut EventLoopHandle, config: &mut B::InputConfig) {
-        (**self).on_input_config_changed(config)
+        (**self).on_input_config_changed(evlh, config)
     }
 }

src/backend/libinput.rs

@@ -262,14 +262,16 @@ impl backend::InputBackend for LibinputInputBackend {
     type TouchCancelEvent = event::touch::TouchCancelEvent;
     type TouchFrameEvent = event::touch::TouchFrameEvent;
 
-    fn set_handler<H: backend::InputHandler<Self> + 'static>(&mut self, mut handler: H) {
+    fn set_handler<H: backend::InputHandler<Self> + 'static>(
+        &mut self, evlh: &mut EventLoopHandle, mut handler: H
+    ) {
         if self.handler.is_some() {
-            self.clear_handler();
+            self.clear_handler(evlh);
         }
         info!(self.logger, "New input handler set");
         for seat in self.seats.values() {
             trace!(self.logger, "Calling on_seat_created with {:?}", seat);
-            handler.on_seat_created(seat);
+            handler.on_seat_created(evlh, seat);
         }
         self.handler = Some(Box::new(handler));
     }
@@ -280,11 +282,11 @@ impl backend::InputBackend for LibinputInputBackend {
             .map(|handler| handler as &mut backend::InputHandler<Self>)
     }
 
-    fn clear_handler(&mut self) {
+    fn clear_handler(&mut self, evlh: &mut EventLoopHandle) {
         if let Some(mut handler) = self.handler.take() {
             for seat in self.seats.values() {
                 trace!(self.logger, "Calling on_seat_destroyed with {:?}", seat);
-                handler.on_seat_destroyed(seat);
+                handler.on_seat_destroyed(evlh, seat);
             }
             info!(self.logger, "Removing input handler");
         }
@@ -294,7 +296,7 @@ impl backend::InputBackend for LibinputInputBackend {
         &mut self.devices
     }
 
-    fn dispatch_new_events(&mut self) -> Result<(), IoError> {
+    fn dispatch_new_events(&mut self, evlh: &mut EventLoopHandle) -> Result<(), IoError> {
         use input::event::EventTrait;
 
         self.context.dispatch()?;
@@ -327,7 +329,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                     }
                                     if let Some(ref mut handler) = self.handler {
                                         trace!(self.logger, "Calling on_seat_changed with {:?}", old_seat);
-                                        handler.on_seat_changed(old_seat);
+                                        handler.on_seat_changed(evlh, old_seat);
                                     }
                                 }
                                 Entry::Vacant(seat_entry) => {
@@ -337,7 +339,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                         seat_entry.insert(backend::Seat::new(hasher.finish(), new_caps));
                                     if let Some(ref mut handler) = self.handler {
                                         trace!(self.logger, "Calling on_seat_created with {:?}", seat);
-                                        handler.on_seat_created(seat);
+                                        handler.on_seat_created(evlh, seat);
                                     }
                                 }
                             }
@@ -375,7 +377,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                 if let Some(seat) = self.seats.remove(&device_seat) {
                                     if let Some(ref mut handler) = self.handler {
                                         trace!(self.logger, "Calling on_seat_destroyed with {:?}", seat);
-                                        handler.on_seat_destroyed(&seat);
+                                        handler.on_seat_destroyed(evlh, &seat);
                                     }
                                 } else {
                                     panic!("Seat destroyed that was never created");
@@ -384,12 +386,12 @@ impl backend::InputBackend for LibinputInputBackend {
                             } else if let Some(ref mut handler) = self.handler {
                                 let seat = self.seats[&device_seat];
                                 trace!(self.logger, "Calling on_seat_changed with {:?}", seat);
-                                handler.on_seat_changed(&seat);
+                                handler.on_seat_changed(evlh, &seat);
                             }
                         }
                     }
                     if let Some(ref mut handler) = self.handler {
-                        handler.on_input_config_changed(&mut self.devices);
+                        handler.on_input_config_changed(evlh, &mut self.devices);
                     }
                 }
                 libinput::Event::Touch(touch_event) => {
@@ -402,7 +404,7 @@ impl backend::InputBackend for LibinputInputBackend {
                         match touch_event {
                             TouchEvent::Down(down_event) => {
                                 trace!(self.logger, "Calling on_touch_down with {:?}", down_event);
-                                handler.on_touch_down(seat, down_event)
+                                handler.on_touch_down(evlh, seat, down_event)
                             }
                             TouchEvent::Motion(motion_event) => {
                                 trace!(
@@ -410,11 +412,11 @@ impl backend::InputBackend for LibinputInputBackend {
                                     "Calling on_touch_motion with {:?}",
                                     motion_event
                                 );
-                                handler.on_touch_motion(seat, motion_event)
+                                handler.on_touch_motion(evlh, seat, motion_event)
                             }
                             TouchEvent::Up(up_event) => {
                                 trace!(self.logger, "Calling on_touch_up with {:?}", up_event);
-                                handler.on_touch_up(seat, up_event)
+                                handler.on_touch_up(evlh, seat, up_event)
                             }
                             TouchEvent::Cancel(cancel_event) => {
                                 trace!(
@@ -422,11 +424,11 @@ impl backend::InputBackend for LibinputInputBackend {
                                     "Calling on_touch_cancel with {:?}",
                                     cancel_event
                                 );
-                                handler.on_touch_cancel(seat, cancel_event)
+                                handler.on_touch_cancel(evlh, seat, cancel_event)
                             }
                             TouchEvent::Frame(frame_event) => {
                                 trace!(self.logger, "Calling on_touch_frame with {:?}", frame_event);
-                                handler.on_touch_frame(seat, frame_event)
+                                handler.on_touch_frame(evlh, seat, frame_event)
                             }
                         }
                     }
@@ -440,7 +442,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                 .get(&device_seat)
                                 .expect("Recieved key event of non existing Seat");
                             trace!(self.logger, "Calling on_keyboard_key with {:?}", key_event);
-                            handler.on_keyboard_key(seat, key_event);
+                            handler.on_keyboard_key(evlh, seat, key_event);
                         },
                     }
                 }
@@ -458,7 +460,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                     "Calling on_pointer_move with {:?}",
                                     motion_event
                                 );
-                                handler.on_pointer_move(seat, motion_event);
+                                handler.on_pointer_move(evlh, seat, motion_event);
                             }
                             PointerEvent::MotionAbsolute(motion_abs_event) => {
                                 trace!(
@@ -466,7 +468,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                     "Calling on_pointer_move_absolute with {:?}",
                                     motion_abs_event
                                 );
-                                handler.on_pointer_move_absolute(seat, motion_abs_event);
+                                handler.on_pointer_move_absolute(evlh, seat, motion_abs_event);
                             }
                             PointerEvent::Axis(axis_event) => {
                                 let rc_axis_event = Rc::new(axis_event);
@@ -477,6 +479,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                         *rc_axis_event
                                     );
                                     handler.on_pointer_axis(
+                                        evlh,
                                         seat,
                                         self::PointerAxisEvent {
                                             axis: Axis::Vertical,
@@ -491,6 +494,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                         *rc_axis_event
                                     );
                                     handler.on_pointer_axis(
+                                        evlh,
                                         seat,
                                         self::PointerAxisEvent {
                                             axis: Axis::Horizontal,
@@ -505,7 +509,7 @@ impl backend::InputBackend for LibinputInputBackend {
                                     "Calling on_pointer_button with {:?}",
                                     button_event
                                 );
-                                handler.on_pointer_button(seat, button_event);
+                                handler.on_pointer_button(evlh, seat, button_event);
                             }
                         }
                     }
@@ -611,9 +615,9 @@ pub fn libinput_bind(
 
 fn fd_event_source_implementation() -> FdEventSourceImpl<LibinputInputBackend> {
     FdEventSourceImpl {
-        ready: |_evlh, ref mut backend, _, _| {
+        ready: |evlh, ref mut backend, _, _| {
             use backend::input::InputBackend;
-            if let Err(error) = backend.dispatch_new_events() {
+            if let Err(error) = backend.dispatch_new_events(evlh) {
                 warn!(backend.logger, "Libinput errored: {}", error);
             }
         },

src/backend/winit.rs

@@ -17,7 +17,7 @@ use std::error;
 use std::fmt;
 use std::rc::Rc;
 use wayland_client::egl as wegl;
-use wayland_server::Display;
+use wayland_server::{Display, EventLoopHandle};
 use winit::{ElementState, Event, EventsLoop, KeyboardInput, MouseButton as WinitMouseButton, MouseCursor,
             MouseScrollDelta, Touch, TouchPhase, Window as WinitWindow, WindowBuilder, WindowEvent};
 
@@ -573,13 +573,13 @@ impl InputBackend for WinitInputBackend {
     type TouchCancelEvent = WinitTouchCancelledEvent;
     type TouchFrameEvent = UnusedEvent;
 
-    fn set_handler<H: InputHandler<Self> + 'static>(&mut self, mut handler: H) {
+    fn set_handler<H: InputHandler<Self> + 'static>(&mut self, evlh: &mut EventLoopHandle, mut handler: H) {
         if self.handler.is_some() {
-            self.clear_handler();
+            self.clear_handler(evlh);
         }
         info!(self.logger, "New input handler set.");
         trace!(self.logger, "Calling on_seat_created with {:?}", self.seat);
-        handler.on_seat_created(&self.seat);
+        handler.on_seat_created(evlh, &self.seat);
         self.handler = Some(Box::new(handler));
     }
 
@@ -589,14 +589,14 @@ impl InputBackend for WinitInputBackend {
             .map(|handler| handler as &mut InputHandler<Self>)
     }
 
-    fn clear_handler(&mut self) {
+    fn clear_handler(&mut self, evlh: &mut EventLoopHandle) {
         if let Some(mut handler) = self.handler.take() {
             trace!(
                 self.logger,
                 "Calling on_seat_destroyed with {:?}",
                 self.seat
             );
-            handler.on_seat_destroyed(&self.seat);
+            handler.on_seat_destroyed(evlh, &self.seat);
         }
         info!(self.logger, "Removing input handler");
     }
@@ -617,11 +617,13 @@ impl InputBackend for WinitInputBackend {
     ///
     /// The linked `WinitGraphicsBackend` will error with a lost Context and should
     /// not be used anymore as well.
-    fn dispatch_new_events(&mut self) -> ::std::result::Result<(), WinitInputError> {
+    fn dispatch_new_events(
+        &mut self, evlh: &mut EventLoopHandle
+    ) -> ::std::result::Result<(), WinitInputError> {
         let mut closed = false;
 
         {
-            // NOTE: This ugly pile of references is here, because rustc could
+            // NOTE: This ugly pile of references is here, because rustc could not
             // figure out how to reference all these objects correctly into the
             // upcoming closure, which is why all are borrowed manually and the
             // assignments are then moved into the closure to avoid rustc's
@@ -669,6 +671,7 @@ impl InputBackend for WinitInputBackend {
                                 (scancode, state)
                             );
                             handler.on_keyboard_key(
+                                evlh,
                                 seat,
                                 WinitKeyboardInputEvent {
                                     time: *time_counter,
@@ -686,6 +689,7 @@ impl InputBackend for WinitInputBackend {
                         ) => {
                             trace!(logger, "Calling on_pointer_move_absolute with {:?}", (x, y));
                             handler.on_pointer_move_absolute(
+                                evlh,
                                 seat,
                                 WinitMouseMovedEvent {
                                     window: window.clone(),
@@ -708,7 +712,7 @@ impl InputBackend for WinitInputBackend {
                                         "Calling on_pointer_axis for Axis::Horizontal with {:?}",
                                         x
                                     );
-                                    handler.on_pointer_axis(seat, event);
+                                    handler.on_pointer_axis(evlh, seat, event);
                                 }
                                 if y != 0.0 {
                                     let event = WinitMouseWheelEvent {
@@ -721,7 +725,7 @@ impl InputBackend for WinitInputBackend {
                                         "Calling on_pointer_axis for Axis::Vertical with {:?}",
                                         y
                                     );
-                                    handler.on_pointer_axis(seat, event);
+                                    handler.on_pointer_axis(evlh, seat, event);
                                 }
                             }
                         },
@@ -732,6 +736,7 @@ impl InputBackend for WinitInputBackend {
                                 (button, state)
                             );
                             handler.on_pointer_button(
+                                evlh,
                                 seat,
                                 WinitMouseInputEvent {
                                     time: *time_counter,
@@ -751,6 +756,7 @@ impl InputBackend for WinitInputBackend {
                         ) => {
                             trace!(logger, "Calling on_touch_down at {:?}", (x, y));
                             handler.on_touch_down(
+                                evlh,
                                 seat,
                                 WinitTouchStartedEvent {
                                     window: window.clone(),
@@ -771,6 +777,7 @@ impl InputBackend for WinitInputBackend {
                         ) => {
                             trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
                             handler.on_touch_motion(
+                                evlh,
                                 seat,
                                 WinitTouchMovedEvent {
                                     window: window.clone(),
@@ -791,6 +798,7 @@ impl InputBackend for WinitInputBackend {
                         ) => {
                             trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
                             handler.on_touch_motion(
+                                evlh,
                                 seat,
                                 WinitTouchMovedEvent {
                                     window: window.clone(),
@@ -801,6 +809,7 @@ impl InputBackend for WinitInputBackend {
                             );
                             trace!(logger, "Calling on_touch_up");
                             handler.on_touch_up(
+                                evlh,
                                 seat,
                                 WinitTouchEndedEvent {
                                     time: *time_counter,
@@ -818,6 +827,7 @@ impl InputBackend for WinitInputBackend {
                         ) => {
                             trace!(logger, "Calling on_touch_cancel");
                             handler.on_touch_cancel(
+                                evlh,
                                 seat,
                                 WinitTouchCancelledEvent {
                                     time: *time_counter,