include commit-hash in version

input-capture/src/dummy.rs

@@ -1,28 +1,16 @@
-use std::f64::consts::PI;
 use std::pin::Pin;
-use std::task::{ready, Context, Poll};
+use std::task::{Context, Poll};
-use std::time::Duration;
 
 use async_trait::async_trait;
 use futures_core::Stream;
-use input_event::PointerEvent;
-use tokio::time::{self, Instant, Interval};
 
 use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
 
-pub struct DummyInputCapture {
+pub struct DummyInputCapture {}
-    start: Option<Instant>,
-    interval: Interval,
-    offset: (i32, i32),
-}
 
 impl DummyInputCapture {
     pub fn new() -> Self {
-        Self {
+        Self {}
-            start: None,
-            interval: time::interval(Duration::from_millis(1)),
-            offset: (0, 0),
-        }
     }
 }
 
@@ -51,36 +39,10 @@ impl Capture for DummyInputCapture {
     }
 }
 
-const FREQUENCY_HZ: f64 = 1.0;
-const RADIUS: f64 = 100.0;
-
 impl Stream for DummyInputCapture {
     type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let current = ready!(self.interval.poll_tick(cx));
+        Poll::Pending
-        let event = match self.start {
-            None => {
-                self.start.replace(current);
-                CaptureEvent::Begin
-            }
-            Some(start) => {
-                let elapsed = start.elapsed();
-                let elapsed_sec_f64 = elapsed.as_secs_f64();
-                let second_fraction = elapsed_sec_f64 - elapsed_sec_f64 as u64 as f64;
-                let radians = second_fraction * 2. * PI * FREQUENCY_HZ;
-                let offset = (radians.cos() * RADIUS * 2., (radians * 2.).sin() * RADIUS);
-                let offset = (offset.0 as i32, offset.1 as i32);
-                let relative_motion = (offset.0 - self.offset.0, offset.1 - self.offset.1);
-                self.offset = offset;
-                let (dx, dy) = (relative_motion.0 as f64, relative_motion.1 as f64);
-                CaptureEvent::Input(input_event::Event::Pointer(PointerEvent::Motion {
-                    time: 0,
-                    dx,
-                    dy,
-                }))
-            }
-        };
-        Poll::Ready(Some(Ok((0, event))))
     }
 }

input-capture/src/wayland.rs

@@ -71,7 +71,7 @@ struct Globals {
     compositor: wl_compositor::WlCompositor,
     pointer_constraints: ZwpPointerConstraintsV1,
     relative_pointer_manager: ZwpRelativePointerManagerV1,
-    shortcut_inhibit_manager: Option<ZwpKeyboardShortcutsInhibitManagerV1>,
+    shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1,
     seat: wl_seat::WlSeat,
     shm: wl_shm::WlShm,
     layer_shell: ZwlrLayerShellV1,
@@ -285,18 +285,9 @@ impl WaylandInputCapture {
         let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
-        let shortcut_inhibit_manager: Result<
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
-            ZwpKeyboardShortcutsInhibitManagerV1,
-            WaylandBindError,
-        > = g
             .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"));
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
-        // layer-shell backend still works without this protocol so we make it an optional dependency
-        if let Err(e) = &shortcut_inhibit_manager {
-            log::warn!("shortcut_inhibit_manager not supported: {e}\nkeybinds handled by the compositor will not be passed
-                to the client");
-        }
-        let shortcut_inhibit_manager = shortcut_inhibit_manager.ok();
         let outputs = vec![];
 
         let g = Globals {
@@ -433,11 +424,13 @@ impl State {
         }
 
         // capture modifier keys
-        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
+        if self.shortcut_inhibitor.is_none() {
-            if self.shortcut_inhibitor.is_none() {
+            self.shortcut_inhibitor = Some(self.g.shortcut_inhibit_manager.inhibit_shortcuts(
-                self.shortcut_inhibitor =
+                surface,
-                    Some(shortcut_inhibit_manager.inhibit_shortcuts(surface, &self.g.seat, qh, ()));
+                &self.g.seat,
-            }
+                qh,
+                (),
+            ));
         }
     }