From a9c75656a292043fbe2bb6287392dd955dd3109e Mon Sep 17 00:00:00 2001 From: Drakulix Date: Fri, 12 Jan 2018 15:49:55 +0100 Subject: [PATCH] Add event_loop to `InputBackend` and `InputHandler` traits --- examples/udev.rs | 72 ++++++++++++++++++++----------- examples/winit.rs | 64 +++++++++++++++++---------- src/backend/input.rs | 95 ++++++++++++++++++++++------------------- src/backend/libinput.rs | 48 +++++++++++---------- src/backend/winit.rs | 30 ++++++++----- 5 files changed, 184 insertions(+), 125 deletions(-) diff --git a/examples/udev.rs b/examples/udev.rs index 7c423c9..37c3796 100644 --- a/examples/udev.rs +++ b/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 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 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 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 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 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,16 +323,19 @@ 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 { - log: log.clone(), - pointer, - keyboard, - window_map: window_map.clone(), - pointer_location, - screen_size: (w, h), - serial: 0, - running: running.clone(), - }); + libinput_backend.set_handler( + &mut event_loop, + LibinputInputHandler { + log: log.clone(), + pointer, + keyboard, + window_map: window_map.clone(), + pointer_location, + 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(); diff --git a/examples/winit.rs b/examples/winit.rs index 4aa1eef..c43c4e2 100644 --- a/examples/winit.rs +++ b/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 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 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 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 { - log: log.clone(), - pointer, - keyboard, - window_map: window_map.clone(), - pointer_location: (0.0, 0.0), - serial: 0, - }); + 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); diff --git a/src/backend/input.rs b/src/backend/input.rs index e08b439..d843e92 100644 --- a/src/backend/input.rs +++ b/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 + 'static>(&mut self, handler: H); + fn set_handler + '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>; /// 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 { /// 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 { /// - `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 { /// /// - `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 { /// /// - `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 InputHandler for Box> { - fn on_seat_created(&mut self, seat: &Seat) { - (**self).on_seat_created(seat) + fn on_seat_created(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) { + (**self).on_seat_created(evlh, seat) } - fn on_seat_destroyed(&mut self, seat: &Seat) { - (**self).on_seat_destroyed(seat) + fn on_seat_destroyed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) { + (**self).on_seat_destroyed(evlh, seat) } - fn on_seat_changed(&mut self, seat: &Seat) { - (**self).on_seat_changed(seat) + fn on_seat_changed(&mut self, evlh: &mut EventLoopHandle, seat: &Seat) { + (**self).on_seat_changed(evlh, seat) } - fn on_keyboard_key(&mut self, seat: &Seat, event: B::KeyboardKeyEvent) { - (**self).on_keyboard_key(seat, event) + fn on_keyboard_key(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::KeyboardKeyEvent) { + (**self).on_keyboard_key(evlh, seat, event) } - fn on_pointer_move(&mut self, seat: &Seat, event: B::PointerMotionEvent) { - (**self).on_pointer_move(seat, event) + fn on_pointer_move(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerMotionEvent) { + (**self).on_pointer_move(evlh, seat, event) } - fn on_pointer_move_absolute(&mut self, seat: &Seat, event: B::PointerMotionAbsoluteEvent) { - (**self).on_pointer_move_absolute(seat, event) + fn on_pointer_move_absolute( + &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) { - (**self).on_pointer_button(seat, event) + fn on_pointer_button(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerButtonEvent) { + (**self).on_pointer_button(evlh, seat, event) } - fn on_pointer_axis(&mut self, seat: &Seat, event: B::PointerAxisEvent) { - (**self).on_pointer_axis(seat, event) + fn on_pointer_axis(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::PointerAxisEvent) { + (**self).on_pointer_axis(evlh, seat, event) } - fn on_touch_down(&mut self, seat: &Seat, event: B::TouchDownEvent) { - (**self).on_touch_down(seat, event) + fn on_touch_down(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchDownEvent) { + (**self).on_touch_down(evlh, seat, event) } - fn on_touch_motion(&mut self, seat: &Seat, event: B::TouchMotionEvent) { - (**self).on_touch_motion(seat, event) + fn on_touch_motion(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchMotionEvent) { + (**self).on_touch_motion(evlh, seat, event) } - fn on_touch_up(&mut self, seat: &Seat, event: B::TouchUpEvent) { - (**self).on_touch_up(seat, event) + fn on_touch_up(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchUpEvent) { + (**self).on_touch_up(evlh, seat, event) } - fn on_touch_cancel(&mut self, seat: &Seat, event: B::TouchCancelEvent) { - (**self).on_touch_cancel(seat, event) + fn on_touch_cancel(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchCancelEvent) { + (**self).on_touch_cancel(evlh, seat, event) } - fn on_touch_frame(&mut self, seat: &Seat, event: B::TouchFrameEvent) { - (**self).on_touch_frame(seat, event) + fn on_touch_frame(&mut self, evlh: &mut EventLoopHandle, seat: &Seat, event: B::TouchFrameEvent) { + (**self).on_touch_frame(evlh, seat, event) } - fn on_input_config_changed(&mut self, config: &mut B::InputConfig) { - (**self).on_input_config_changed(config) + fn on_input_config_changed(&mut self, evlh: &mut EventLoopHandle, config: &mut B::InputConfig) { + (**self).on_input_config_changed(evlh, config) } } diff --git a/src/backend/libinput.rs b/src/backend/libinput.rs index 7c5475b..bdbb655 100644 --- a/src/backend/libinput.rs +++ b/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 + 'static>(&mut self, mut handler: H) { + fn set_handler + '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) } - 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 { 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); } }, diff --git a/src/backend/winit.rs b/src/backend/winit.rs index 28fd6b4..e5f8bea 100644 --- a/src/backend/winit.rs +++ b/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 + 'static>(&mut self, mut handler: H) { + fn set_handler + '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) } - 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,