layer-shell: drop hard-dep on shortcut-inhibit

soften dependency off layer-shell backend to make
https://wayland.app/protocols/keyboard-shortcuts-inhibit-unstable-v1
optional.

This allows partial functionality on compositors that don't support
the protocol, e.g. labwc.

build.rs

@@ -1,4 +1,18 @@
+use std::process::Command;
+
 fn main() {
+    // commit hash
+    let git_describe = Command::new("git")
+        .arg("describe")
+        .arg("--always")
+        .arg("--dirty")
+        .arg("--tags")
+        .output()
+        .unwrap();
+
+    let git_describe = String::from_utf8(git_describe.stdout).unwrap();
+    println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
+
     // composite_templates
     #[cfg(feature = "gtk")]
     glib_build_tools::compile_resources(

input-capture/src/dummy.rs

@@ -1,16 +1,28 @@
+use std::f64::consts::PI;
 use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::task::{ready, 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),
+        }
     }
 }
 
@@ -39,10 +51,36 @@ 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(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
+        let current = ready!(self.interval.poll_tick(cx));
+        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: ZwpKeyboardShortcutsInhibitManagerV1,
+    shortcut_inhibit_manager: Option<ZwpKeyboardShortcutsInhibitManagerV1>,
     seat: wl_seat::WlSeat,
     shm: wl_shm::WlShm,
     layer_shell: ZwlrLayerShellV1,
@@ -285,9 +285,18 @@ 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: ZwpKeyboardShortcutsInhibitManagerV1 = g
+        let shortcut_inhibit_manager: Result<
+            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 {
@@ -424,13 +433,11 @@ impl State {
         }
 
         // capture modifier keys
+        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
             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,
-                (),
-            ));
         }
     }
 

nix/default.nix

@@ -12,6 +12,7 @@ rustPlatform.buildRustPackage {
   version = version;
 
   nativeBuildInputs = with pkgs; [
+    git
     pkg-config
     cmake
     makeWrapper

src/config.rs

@@ -50,7 +50,7 @@ impl ConfigToml {
 }
 
 #[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
+#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
 struct CliArgs {
     /// the listen port for lan-mouse
     #[arg(short, long)]