split into input-{event,capture,emulation}

input-capture/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "input-capture"
+description = "cross-platform input-capture library used by lan-mouse"
+version = "0.1.0"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/ferdinandschober/lan-mouse"
+
+[dependencies]
+anyhow = "1.0.86"
+futures = "0.3.28"
+futures-core = "0.3.30"
+log = "0.4.22"
+input-event = { path = "../input-event" }
+memmap = "0.7"
+tempfile = "3.8"
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+once_cell = "1.19.0"
+
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.31.0", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.2.0", features=["client"], optional = true }
+wayland-protocols-misc = { version="0.2.0", features=["client"], optional = true }
+x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+reis = { version = "0.2", features = [ "tokio" ], optional = true }
+
+[target.'cfg(target_os="macos")'.dependencies]
+core-graphics = { version = "0.23", features = ["highsierra"] }
+
+[target.'cfg(windows)'.dependencies]
+windows = {  version = "0.54.0", features = [
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_Foundation",
+    "Win32_Graphics",
+    "Win32_Graphics_Gdi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_WindowsAndMessaging",
+] }
+
+[features]
+default = ["wayland", "x11", "libei"]
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
+x11 = ["dep:x11"]
+libei = ["dep:reis", "dep:ashpd"]

input-capture/src/dummy.rs

@@ -0,0 +1,45 @@
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures_core::Stream;
+
+use input_event::Event;
+
+use super::{CaptureHandle, InputCapture, Position};
+
+pub struct DummyInputCapture {}
+
+impl DummyInputCapture {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for DummyInputCapture {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl InputCapture for DummyInputCapture {
+    fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn destroy(&mut self, _handle: CaptureHandle) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Stream for DummyInputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}

input-capture/src/error.rs

@@ -0,0 +1,142 @@
+use std::fmt::Display;
+use thiserror::Error;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use std::io;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[derive(Debug, Error)]
+pub enum CaptureCreationError {
+    NoAvailableBackend,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei(#[from] LibeiCaptureCreationError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell(#[from] LayerShellCaptureCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11(#[from] X11InputCaptureCreationError),
+    #[cfg(target_os = "macos")]
+    Macos(#[from] MacOSInputCaptureCreationError),
+    #[cfg(windows)]
+    Windows,
+}
+
+impl Display for CaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureCreationError::Libei(reason) => {
+                format!("error creating portal backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureCreationError::LayerShell(reason) => {
+                format!("error creating layer-shell backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureCreationError::X11(e) => format!("{e}"),
+            #[cfg(target_os = "macos")]
+            CaptureCreationError::Macos(e) => format!("{e}"),
+            #[cfg(windows)]
+            CaptureCreationError::Windows => String::new(),
+            CaptureCreationError::NoAvailableBackend => "no available backend".to_string(),
+        };
+        write!(f, "could not create input capture: {reason}")
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiCaptureCreationError {
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiCaptureCreationError::Ashpd(portal_error) => write!(f, "{portal_error}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LayerShellCaptureCreationError {
+    Connect(#[from] ConnectError),
+    Global(#[from] GlobalError),
+    Wayland(#[from] WaylandError),
+    Bind(#[from] WaylandBindError),
+    Dispatch(#[from] DispatchError),
+    Io(#[from] io::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for LayerShellCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LayerShellCaptureCreationError::Bind(e) => write!(f, "{e}"),
+            LayerShellCaptureCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            LayerShellCaptureCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            LayerShellCaptureCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11InputCaptureCreationError {
+    NotImplemented,
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11InputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "X11 input capture is not yet implemented :(")
+    }
+}
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSInputCaptureCreationError {
+    NotImplemented,
+}
+
+#[cfg(target_os = "macos")]
+impl Display for MacOSInputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "macos input capture is not yet implemented :(")
+    }
+}

input-capture/src/lib.rs

@@ -0,0 +1,159 @@
+use std::{fmt::Display, io};
+
+use futures_core::Stream;
+
+use input_event::Event;
+
+use self::error::CaptureCreationError;
+
+pub mod error;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+pub mod libei;
+
+#[cfg(target_os = "macos")]
+pub mod macos;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+pub mod wayland;
+
+#[cfg(windows)]
+pub mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+pub mod x11;
+
+/// fallback input capture (does not produce events)
+pub mod dummy;
+
+pub type CaptureHandle = u64;
+
+#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
+pub enum Position {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl Position {
+    pub fn opposite(&self) -> Self {
+        match self {
+            Position::Left => Self::Right,
+            Position::Right => Self::Left,
+            Position::Top => Self::Bottom,
+            Position::Bottom => Self::Top,
+        }
+    }
+}
+
+impl Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let pos = match self {
+            Position::Left => "left",
+            Position::Right => "right",
+            Position::Top => "top",
+            Position::Bottom => "bottom",
+        };
+        write!(f, "{}", pos)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Backend {
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    InputCapturePortal,
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::InputCapturePortal => write!(f, "input-capture-portal"),
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::LayerShell => write!(f, "layer-shell"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            Backend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            Backend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            Backend::MacOs => write!(f, "MacOS"),
+            Backend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpin {
+    /// create a new client with the given id
+    fn create(&mut self, id: CaptureHandle, pos: Position) -> io::Result<()>;
+
+    /// destroy the client with the given id, if it exists
+    fn destroy(&mut self, id: CaptureHandle) -> io::Result<()>;
+
+    /// release mouse
+    fn release(&mut self) -> io::Result<()>;
+}
+
+pub async fn create_backend(
+    backend: Backend,
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+{
+    match backend {
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
+        #[cfg(windows)]
+        Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
+        #[cfg(target_os = "macos")]
+        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
+        Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
+    }
+}
+
+pub async fn create(
+    backend: Option<Backend>,
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+{
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using capture backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::InputCapturePortal,
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11,
+        #[cfg(windows)]
+        Backend::Windows,
+        #[cfg(target_os = "macos")]
+        Backend::MacOs,
+        Backend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using capture backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
+        }
+    }
+    Err(CaptureCreationError::NoAvailableBackend)
+}

input-capture/src/libei.rs

@@ -0,0 +1,583 @@
+use anyhow::{anyhow, Result};
+use ashpd::{
+    desktop::{
+        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
+        ResponseError, Session,
+    },
+    enumflags2::BitFlags,
+};
+use futures::StreamExt;
+use reis::{
+    ei::{self, keyboard::KeyState},
+    eis::button::ButtonState,
+    event::{DeviceCapability, EiEvent},
+    tokio::{EiConvertEventStream, EiEventStream},
+};
+use std::{
+    cell::Cell,
+    collections::HashMap,
+    io,
+    os::unix::net::UnixStream,
+    pin::Pin,
+    rc::Rc,
+    task::{ready, Context, Poll},
+};
+use tokio::{
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};
+
+use futures_core::Stream;
+use once_cell::sync::Lazy;
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use super::{
+    error::LibeiCaptureCreationError, CaptureHandle, InputCapture as LanMouseInputCapture, Position,
+};
+
+#[derive(Debug)]
+enum ProducerEvent {
+    Release,
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+}
+
+#[allow(dead_code)]
+pub struct LibeiInputCapture<'a> {
+    input_capture: Pin<Box<InputCapture<'a>>>,
+    libei_task: JoinHandle<Result<()>>,
+    event_rx: tokio::sync::mpsc::Receiver<(CaptureHandle, Event)>,
+    notify_tx: tokio::sync::mpsc::Sender<ProducerEvent>,
+}
+
+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
+fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
+    let (x, y) = (r.x_offset(), r.y_offset());
+    let (width, height) = (r.width() as i32, r.height() as i32);
+    match pos {
+        Position::Left => (x, y, x, y + height - 1), // start pos, end pos, inclusive
+        Position::Right => (x + width, y, x + width, y + height - 1),
+        Position::Top => (x, y, x + width - 1, y),
+        Position::Bottom => (x, y + height, x + width - 1, y + height),
+    }
+}
+
+fn select_barriers(
+    zones: &Zones,
+    clients: &Vec<(CaptureHandle, Position)>,
+    next_barrier_id: &mut u32,
+) -> (Vec<Barrier>, HashMap<BarrierID, CaptureHandle>) {
+    let mut client_for_barrier = HashMap::new();
+    let mut barriers: Vec<Barrier> = vec![];
+
+    for (handle, pos) in clients {
+        let mut client_barriers = zones
+            .regions()
+            .iter()
+            .map(|r| {
+                let id = *next_barrier_id;
+                *next_barrier_id = id + 1;
+                let position = pos_to_barrier(r, *pos);
+                client_for_barrier.insert(id, *handle);
+                Barrier::new(id, position)
+            })
+            .collect();
+        barriers.append(&mut client_barriers);
+    }
+    (barriers, client_for_barrier)
+}
+
+async fn update_barriers(
+    input_capture: &InputCapture<'_>,
+    session: &Session<'_>,
+    active_clients: &Vec<(CaptureHandle, Position)>,
+    next_barrier_id: &mut u32,
+) -> Result<HashMap<BarrierID, CaptureHandle>> {
+    let zones = input_capture.zones(session).await?.response()?;
+    log::debug!("zones: {zones:?}");
+
+    let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
+    log::debug!("barriers: {barriers:?}");
+    log::debug!("client for barrier id: {id_map:?}");
+
+    let response = input_capture
+        .set_pointer_barriers(session, &barriers, zones.zone_set())
+        .await?;
+    let response = response.response()?;
+    log::debug!("{response:?}");
+    Ok(id_map)
+}
+
+impl<'a> Drop for LibeiInputCapture<'a> {
+    fn drop(&mut self) {
+        self.libei_task.abort();
+    }
+}
+
+async fn create_session<'a>(
+    input_capture: &'a InputCapture<'a>,
+) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
+    log::debug!("creating input capture session");
+    let (session, capabilities) = loop {
+        match input_capture
+            .create_session(
+                &ashpd::WindowIdentifier::default(),
+                Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
+            )
+            .await
+        {
+            Ok(s) => break s,
+            Err(ashpd::Error::Response(ResponseError::Cancelled)) => continue,
+            o => o?,
+        };
+    };
+    log::debug!("capabilities: {capabilities:?}");
+    Ok((session, capabilities))
+}
+
+async fn connect_to_eis(
+    input_capture: &InputCapture<'_>,
+    session: &Session<'_>,
+) -> Result<(ei::Context, EiConvertEventStream)> {
+    log::debug!("connect_to_eis");
+    let fd = input_capture.connect_to_eis(session).await?;
+
+    // create unix stream from fd
+    let stream = UnixStream::from(fd);
+    stream.set_nonblocking(true)?;
+
+    // create ei context
+    let context = ei::Context::new(stream)?;
+    let mut event_stream = EiEventStream::new(context.clone())?;
+    let response = match reis::tokio::ei_handshake(
+        &mut event_stream,
+        "de.feschber.LanMouse",
+        ei::handshake::ContextType::Receiver,
+        &INTERFACES,
+    )
+    .await
+    {
+        Ok(res) => res,
+        Err(e) => return Err(anyhow!("ei handshake failed: {e:?}")),
+    };
+    let event_stream = EiConvertEventStream::new(event_stream, response.serial);
+
+    Ok((context, event_stream))
+}
+
+async fn libei_event_handler(
+    mut ei_event_stream: EiConvertEventStream,
+    context: ei::Context,
+    event_tx: Sender<(CaptureHandle, Event)>,
+    current_client: Rc<Cell<Option<CaptureHandle>>>,
+) -> Result<()> {
+    loop {
+        let ei_event = match ei_event_stream.next().await {
+            Some(Ok(event)) => event,
+            Some(Err(e)) => return Err(anyhow!("libei connection closed: {e:?}")),
+            None => return Err(anyhow!("libei connection closed")),
+        };
+        log::trace!("from ei: {ei_event:?}");
+        let client = current_client.get();
+        handle_ei_event(ei_event, client, &context, &event_tx).await;
+    }
+}
+
+async fn wait_for_active_client(
+    notify_rx: &mut Receiver<ProducerEvent>,
+    active_clients: &mut Vec<(CaptureHandle, Position)>,
+) -> Result<()> {
+    // wait for a client update
+    while let Some(producer_event) = notify_rx.recv().await {
+        if let ProducerEvent::Create(c, p) = producer_event {
+            handle_producer_event(ProducerEvent::Create(c, p), active_clients)?;
+            break;
+        }
+    }
+    Ok(())
+}
+
+impl<'a> LibeiInputCapture<'a> {
+    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
+        let input_capture = Box::pin(InputCapture::new().await?);
+        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
+        let mut first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
+
+        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
+        let libei_task = tokio::task::spawn_local(async move {
+            /* safety: libei_task does not outlive Self */
+            let input_capture = unsafe { &*input_capture_ptr };
+
+            let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+            let mut next_barrier_id = 1u32;
+
+            /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
+             * prevents receiving further events after a session has been disabled once.
+             * Therefore the session needs to recreated when the barriers are updated */
+
+            loop {
+                // otherwise it asks to capture input even with no active clients
+                if active_clients.is_empty() {
+                    wait_for_active_client(&mut notify_rx, &mut active_clients).await?;
+                    continue;
+                }
+
+                let current_client = Rc::new(Cell::new(None));
+
+                // create session
+                let (session, _) = match first_session.take() {
+                    Some(s) => s,
+                    _ => create_session(input_capture).await?,
+                };
+
+                // connect to eis server
+                let (context, ei_event_stream) = connect_to_eis(input_capture, &session).await?;
+
+                // async event task
+                let mut ei_task: JoinHandle<Result<(), anyhow::Error>> =
+                    tokio::task::spawn_local(libei_event_handler(
+                        ei_event_stream,
+                        context,
+                        event_tx.clone(),
+                        current_client.clone(),
+                    ));
+
+                let mut activated = input_capture.receive_activated().await?;
+                let mut zones_changed = input_capture.receive_zones_changed().await?;
+
+                // set barriers
+                let client_for_barrier_id = update_barriers(
+                    input_capture,
+                    &session,
+                    &active_clients,
+                    &mut next_barrier_id,
+                )
+                .await?;
+
+                log::debug!("enabling session");
+                input_capture.enable(&session).await?;
+
+                loop {
+                    tokio::select! {
+                        activated = activated.next() => {
+                            let activated = activated.ok_or(anyhow!("error receiving activation token"))?;
+                            log::debug!("activated: {activated:?}");
+
+                            let client = *client_for_barrier_id
+                                .get(&activated.barrier_id())
+                                .expect("invalid barrier id");
+                            current_client.replace(Some(client));
+
+                            event_tx.send((client, Event::Enter())).await?;
+
+                            tokio::select! {
+                                producer_event = notify_rx.recv() => {
+                                    let producer_event = producer_event.expect("channel closed");
+                                    if handle_producer_event(producer_event, &mut active_clients)? {
+                                        break; /* clients updated */
+                                    }
+                                }
+                                zones_changed = zones_changed.next() => {
+                                    log::debug!("zones changed: {zones_changed:?}");
+                                    break;
+                                }
+                                res = &mut ei_task => {
+                                    if let Err(e) = res.expect("ei task paniced") {
+                                        log::warn!("libei task exited: {e}");
+                                    }
+                                    break;
+                                }
+                            }
+                            release_capture(
+                                input_capture,
+                                &session,
+                                activated,
+                                client,
+                                &active_clients,
+                            ).await?;
+                        }
+                        producer_event = notify_rx.recv() => {
+                            let producer_event = producer_event.expect("channel closed");
+                            if handle_producer_event(producer_event, &mut active_clients)? {
+                                /* clients updated */
+                                break;
+                            }
+                        },
+                        res = &mut ei_task => {
+                            if let Err(e) = res.expect("ei task paniced") {
+                                log::warn!("libei task exited: {e}");
+                            }
+                            break;
+                        }
+                    }
+                }
+                ei_task.abort();
+                input_capture.disable(&session).await?;
+            }
+        });
+
+        let producer = Self {
+            input_capture,
+            event_rx,
+            libei_task,
+            notify_tx,
+        };
+
+        Ok(producer)
+    }
+}
+
+async fn release_capture(
+    input_capture: &InputCapture<'_>,
+    session: &Session<'_>,
+    activated: Activated,
+    current_client: CaptureHandle,
+    active_clients: &[(CaptureHandle, Position)],
+) -> Result<()> {
+    log::debug!("releasing input capture {}", activated.activation_id());
+    let (x, y) = activated.cursor_position();
+    let pos = active_clients
+        .iter()
+        .filter(|(c, _)| *c == current_client)
+        .map(|(_, p)| p)
+        .next()
+        .unwrap(); // FIXME
+    let (dx, dy) = match pos {
+        // offset cursor position to not enter again immediately
+        Position::Left => (1., 0.),
+        Position::Right => (-1., 0.),
+        Position::Top => (0., 1.),
+        Position::Bottom => (0., -1.),
+    };
+    // release 1px to the right of the entered zone
+    let cursor_position = (x as f64 + dx, y as f64 + dy);
+    input_capture
+        .release(session, activated.activation_id(), cursor_position)
+        .await?;
+    Ok(())
+}
+
+fn handle_producer_event(
+    producer_event: ProducerEvent,
+    active_clients: &mut Vec<(CaptureHandle, Position)>,
+) -> Result<bool> {
+    log::debug!("handling event: {producer_event:?}");
+    let updated = match producer_event {
+        ProducerEvent::Release => false,
+        ProducerEvent::Create(c, p) => {
+            active_clients.push((c, p));
+            true
+        }
+        ProducerEvent::Destroy(c) => {
+            active_clients.retain(|(h, _)| *h != c);
+            true
+        }
+    };
+    Ok(updated)
+}
+
+async fn handle_ei_event(
+    ei_event: EiEvent,
+    current_client: Option<CaptureHandle>,
+    context: &ei::Context,
+    event_tx: &Sender<(CaptureHandle, Event)>,
+) {
+    match ei_event {
+        EiEvent::SeatAdded(s) => {
+            s.seat.bind_capabilities(&[
+                DeviceCapability::Pointer,
+                DeviceCapability::PointerAbsolute,
+                DeviceCapability::Keyboard,
+                DeviceCapability::Touch,
+                DeviceCapability::Scroll,
+                DeviceCapability::Button,
+            ]);
+            context.flush().unwrap();
+        }
+        EiEvent::SeatRemoved(_) => {}
+        EiEvent::DeviceAdded(_) => {}
+        EiEvent::DeviceRemoved(_) => {}
+        EiEvent::DevicePaused(_) => {}
+        EiEvent::DeviceResumed(_) => {}
+        EiEvent::KeyboardModifiers(mods) => {
+            let modifier_event = KeyboardEvent::Modifiers {
+                mods_depressed: mods.depressed,
+                mods_latched: mods.latched,
+                mods_locked: mods.locked,
+                group: mods.group,
+            };
+            if let Some(current_client) = current_client {
+                event_tx
+                    .send((current_client, Event::Keyboard(modifier_event)))
+                    .await
+                    .unwrap();
+            }
+        }
+        EiEvent::Frame(_) => {}
+        EiEvent::DeviceStartEmulating(_) => {
+            log::debug!("START EMULATING =============>");
+        }
+        EiEvent::DeviceStopEmulating(_) => {
+            log::debug!("==================> STOP EMULATING");
+        }
+        EiEvent::PointerMotion(motion) => {
+            let motion_event = PointerEvent::Motion {
+                time: motion.time as u32,
+                relative_x: motion.dx as f64,
+                relative_y: motion.dy as f64,
+            };
+            if let Some(current_client) = current_client {
+                event_tx
+                    .send((current_client, Event::Pointer(motion_event)))
+                    .await
+                    .unwrap();
+            }
+        }
+        EiEvent::PointerMotionAbsolute(_) => {}
+        EiEvent::Button(button) => {
+            let button_event = PointerEvent::Button {
+                time: button.time as u32,
+                button: button.button,
+                state: match button.state {
+                    ButtonState::Released => 0,
+                    ButtonState::Press => 1,
+                },
+            };
+            if let Some(current_client) = current_client {
+                event_tx
+                    .send((current_client, Event::Pointer(button_event)))
+                    .await
+                    .unwrap();
+            }
+        }
+        EiEvent::ScrollDelta(delta) => {
+            if let Some(handle) = current_client {
+                let mut events = vec![];
+                if delta.dy != 0. {
+                    events.push(PointerEvent::Axis {
+                        time: 0,
+                        axis: 0,
+                        value: delta.dy as f64,
+                    });
+                }
+                if delta.dx != 0. {
+                    events.push(PointerEvent::Axis {
+                        time: 0,
+                        axis: 1,
+                        value: delta.dx as f64,
+                    });
+                }
+                for event in events {
+                    event_tx
+                        .send((handle, Event::Pointer(event)))
+                        .await
+                        .unwrap();
+                }
+            }
+        }
+        EiEvent::ScrollStop(_) => {}
+        EiEvent::ScrollCancel(_) => {}
+        EiEvent::ScrollDiscrete(scroll) => {
+            if scroll.discrete_dy != 0 {
+                let event = PointerEvent::AxisDiscrete120 {
+                    axis: 0,
+                    value: scroll.discrete_dy,
+                };
+                if let Some(current_client) = current_client {
+                    event_tx
+                        .send((current_client, Event::Pointer(event)))
+                        .await
+                        .unwrap();
+                }
+            }
+            if scroll.discrete_dx != 0 {
+                let event = PointerEvent::AxisDiscrete120 {
+                    axis: 1,
+                    value: scroll.discrete_dx,
+                };
+                if let Some(current_client) = current_client {
+                    event_tx
+                        .send((current_client, Event::Pointer(event)))
+                        .await
+                        .unwrap();
+                }
+            };
+        }
+        EiEvent::KeyboardKey(key) => {
+            let key_event = KeyboardEvent::Key {
+                key: key.key,
+                state: match key.state {
+                    KeyState::Press => 1,
+                    KeyState::Released => 0,
+                },
+                time: key.time as u32,
+            };
+            if let Some(current_client) = current_client {
+                event_tx
+                    .send((current_client, Event::Keyboard(key_event)))
+                    .await
+                    .unwrap();
+            }
+        }
+        EiEvent::TouchDown(_) => {}
+        EiEvent::TouchUp(_) => {}
+        EiEvent::TouchMotion(_) => {}
+        EiEvent::Disconnected(d) => {
+            log::error!("disconnect: {d:?}");
+        }
+    }
+}
+
+impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+    fn create(&mut self, handle: super::CaptureHandle, pos: super::Position) -> io::Result<()> {
+        let notify_tx = self.notify_tx.clone();
+        tokio::task::spawn_local(async move {
+            let _ = notify_tx.send(ProducerEvent::Create(handle, pos)).await;
+        });
+        Ok(())
+    }
+
+    fn destroy(&mut self, handle: super::CaptureHandle) -> io::Result<()> {
+        let notify_tx = self.notify_tx.clone();
+        tokio::task::spawn_local(async move {
+            let _ = notify_tx.send(ProducerEvent::Destroy(handle)).await;
+        });
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        let notify_tx = self.notify_tx.clone();
+        tokio::task::spawn_local(async move {
+            let _ = notify_tx.send(ProducerEvent::Release).await;
+        });
+        Ok(())
+    }
+}
+
+impl<'a> Stream for LibeiInputCapture<'a> {
+    type Item = io::Result<(CaptureHandle, Event)>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match ready!(self.event_rx.poll_recv(cx)) {
+            None => Poll::Ready(None),
+            Some(e) => Poll::Ready(Some(Ok(e))),
+        }
+    }
+}

input-capture/src/macos.rs

@@ -0,0 +1,35 @@
+use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
+use futures_core::Stream;
+use input_event::Event;
+use std::task::{Context, Poll};
+use std::{io, pin::Pin};
+
+pub struct MacOSInputCapture;
+
+impl MacOSInputCapture {
+    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+        Err(MacOSInputCaptureCreationError::NotImplemented)
+    }
+}
+
+impl Stream for MacOSInputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}
+
+impl InputCapture for MacOSInputCapture {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

input-capture/src/wayland.rs

@@ -0,0 +1,995 @@
+use futures_core::Stream;
+use memmap::MmapOptions;
+use std::{
+    collections::VecDeque,
+    env,
+    io::{self, ErrorKind},
+    os::fd::{AsFd, OwnedFd, RawFd},
+    pin::Pin,
+    task::{ready, Context, Poll},
+};
+use tokio::io::unix::AsyncFd;
+
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+    os::unix::prelude::{AsRawFd, FromRawFd},
+    rc::Rc,
+};
+
+use wayland_protocols::{
+    wp::{
+        keyboard_shortcuts_inhibit::zv1::client::{
+            zwp_keyboard_shortcuts_inhibit_manager_v1::ZwpKeyboardShortcutsInhibitManagerV1,
+            zwp_keyboard_shortcuts_inhibitor_v1::ZwpKeyboardShortcutsInhibitorV1,
+        },
+        pointer_constraints::zv1::client::{
+            zwp_locked_pointer_v1::ZwpLockedPointerV1,
+            zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1},
+        },
+        relative_pointer::zv1::client::{
+            zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
+            zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
+        },
+    },
+    xdg::xdg_output::zv1::client::{
+        zxdg_output_manager_v1::ZxdgOutputManagerV1,
+        zxdg_output_v1::{self, ZxdgOutputV1},
+    },
+};
+
+use wayland_protocols_wlr::layer_shell::v1::client::{
+    zwlr_layer_shell_v1::{Layer, ZwlrLayerShellV1},
+    zwlr_layer_surface_v1::{self, Anchor, KeyboardInteractivity, ZwlrLayerSurfaceV1},
+};
+
+use wayland_client::{
+    backend::{ReadEventsGuard, WaylandError},
+    delegate_noop,
+    globals::{registry_queue_init, GlobalListContents},
+    protocol::{
+        wl_buffer, wl_compositor,
+        wl_keyboard::{self, WlKeyboard},
+        wl_output::{self, WlOutput},
+        wl_pointer::{self, WlPointer},
+        wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool,
+        wl_surface::WlSurface,
+    },
+    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
+};
+
+use tempfile;
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use super::{
+    error::{LayerShellCaptureCreationError, WaylandBindError},
+    CaptureHandle, InputCapture, Position,
+};
+
+struct Globals {
+    compositor: wl_compositor::WlCompositor,
+    pointer_constraints: ZwpPointerConstraintsV1,
+    relative_pointer_manager: ZwpRelativePointerManagerV1,
+    shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1,
+    seat: wl_seat::WlSeat,
+    shm: wl_shm::WlShm,
+    layer_shell: ZwlrLayerShellV1,
+    outputs: Vec<WlOutput>,
+    xdg_output_manager: ZxdgOutputManagerV1,
+}
+
+#[derive(Debug, Clone)]
+struct OutputInfo {
+    name: String,
+    position: (i32, i32),
+    size: (i32, i32),
+}
+
+impl OutputInfo {
+    fn new() -> Self {
+        Self {
+            name: "".to_string(),
+            position: (0, 0),
+            size: (0, 0),
+        }
+    }
+}
+
+struct State {
+    pointer: Option<WlPointer>,
+    keyboard: Option<WlKeyboard>,
+    pointer_lock: Option<ZwpLockedPointerV1>,
+    rel_pointer: Option<ZwpRelativePointerV1>,
+    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
+    client_for_window: Vec<(Rc<Window>, CaptureHandle)>,
+    focused: Option<(Rc<Window>, CaptureHandle)>,
+    g: Globals,
+    wayland_fd: OwnedFd,
+    read_guard: Option<ReadEventsGuard>,
+    qh: QueueHandle<Self>,
+    pending_events: VecDeque<(CaptureHandle, Event)>,
+    output_info: Vec<(WlOutput, OutputInfo)>,
+    scroll_discrete_pending: bool,
+}
+
+struct Inner {
+    state: State,
+    queue: EventQueue<State>,
+}
+
+impl AsRawFd for Inner {
+    fn as_raw_fd(&self) -> RawFd {
+        self.state.wayland_fd.as_raw_fd()
+    }
+}
+
+pub struct WaylandInputCapture(AsyncFd<Inner>);
+
+struct Window {
+    buffer: wl_buffer::WlBuffer,
+    surface: WlSurface,
+    layer_surface: ZwlrLayerSurfaceV1,
+    pos: Position,
+}
+
+impl Window {
+    fn new(
+        state: &State,
+        qh: &QueueHandle<State>,
+        output: &WlOutput,
+        pos: Position,
+        size: (i32, i32),
+    ) -> Window {
+        log::debug!("creating window output: {output:?}, size: {size:?}");
+        let g = &state.g;
+
+        let (width, height) = match pos {
+            Position::Left | Position::Right => (1, size.1 as u32),
+            Position::Top | Position::Bottom => (size.0 as u32, 1),
+        };
+        let mut file = tempfile::tempfile().unwrap();
+        draw(&mut file, (width, height));
+        let pool = g
+            .shm
+            .create_pool(file.as_fd(), (width * height * 4) as i32, qh, ());
+        let buffer = pool.create_buffer(
+            0,
+            width as i32,
+            height as i32,
+            (width * 4) as i32,
+            wl_shm::Format::Argb8888,
+            qh,
+            (),
+        );
+        let surface = g.compositor.create_surface(qh, ());
+
+        let layer_surface = g.layer_shell.get_layer_surface(
+            &surface,
+            Some(output),
+            Layer::Overlay,
+            "LAN Mouse Sharing".into(),
+            qh,
+            (),
+        );
+        let anchor = match pos {
+            Position::Left => Anchor::Left,
+            Position::Right => Anchor::Right,
+            Position::Top => Anchor::Top,
+            Position::Bottom => Anchor::Bottom,
+        };
+
+        layer_surface.set_anchor(anchor);
+        layer_surface.set_size(width, height);
+        layer_surface.set_exclusive_zone(-1);
+        layer_surface.set_margin(0, 0, 0, 0);
+        surface.set_input_region(None);
+        surface.commit();
+        Window {
+            pos,
+            buffer,
+            surface,
+            layer_surface,
+        }
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        log::debug!("destroying window!");
+        self.layer_surface.destroy();
+        self.surface.destroy();
+        self.buffer.destroy();
+    }
+}
+
+fn get_edges(outputs: &[(WlOutput, OutputInfo)], pos: Position) -> Vec<(WlOutput, i32)> {
+    outputs
+        .iter()
+        .map(|(o, i)| {
+            (
+                o.clone(),
+                match pos {
+                    Position::Left => i.position.0,
+                    Position::Right => i.position.0 + i.size.0,
+                    Position::Top => i.position.1,
+                    Position::Bottom => i.position.1 + i.size.1,
+                },
+            )
+        })
+        .collect()
+}
+
+fn get_output_configuration(state: &State, pos: Position) -> Vec<(WlOutput, OutputInfo)> {
+    // get all output edges corresponding to the position
+    let edges = get_edges(&state.output_info, pos);
+    log::debug!("edges: {edges:?}");
+    let opposite_edges = get_edges(&state.output_info, pos.opposite());
+
+    // remove those edges that are at the same position
+    // as an opposite edge of a different output
+    let outputs: Vec<WlOutput> = edges
+        .iter()
+        .filter(|(_, edge)| !opposite_edges.iter().map(|(_, e)| *e).any(|e| &e == edge))
+        .map(|(o, _)| o.clone())
+        .collect();
+    state
+        .output_info
+        .iter()
+        .filter(|(o, _)| outputs.contains(o))
+        .map(|(o, i)| (o.clone(), i.clone()))
+        .collect()
+}
+
+fn draw(f: &mut File, (width, height): (u32, u32)) {
+    let mut buf = BufWriter::new(f);
+    for _ in 0..height {
+        for _ in 0..width {
+            if env::var("LM_DEBUG_LAYER_SHELL").ok().is_some() {
+                // AARRGGBB
+                buf.write_all(&0xff11d116u32.to_ne_bytes()).unwrap();
+            } else {
+                // AARRGGBB
+                buf.write_all(&0x00000000u32.to_ne_bytes()).unwrap();
+            }
+        }
+    }
+}
+
+impl WaylandInputCapture {
+    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
+        let conn = Connection::connect_to_env()?;
+        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
+
+        let qh = queue.handle();
+
+        let compositor: wl_compositor::WlCompositor = g
+            .bind(&qh, 4..=5, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
+        let xdg_output_manager: ZxdgOutputManagerV1 = g
+            .bind(&qh, 1..=3, ())
+            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
+        let shm: wl_shm::WlShm = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
+        let layer_shell: ZwlrLayerShellV1 = g
+            .bind(&qh, 3..=4, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
+        let seat: wl_seat::WlSeat = g
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
+
+        let pointer_constraints: ZwpPointerConstraintsV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
+        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
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
+        let outputs = vec![];
+
+        let g = Globals {
+            compositor,
+            shm,
+            layer_shell,
+            seat,
+            pointer_constraints,
+            relative_pointer_manager,
+            shortcut_inhibit_manager,
+            outputs,
+            xdg_output_manager,
+        };
+
+        // flush outgoing events
+        queue.flush()?;
+
+        // prepare reading wayland events
+        let read_guard = queue.prepare_read().unwrap(); // there can not yet be events to dispatch
+        let wayland_fd = read_guard.connection_fd().try_clone_to_owned().unwrap();
+        std::mem::drop(read_guard);
+
+        let mut state = State {
+            pointer: None,
+            keyboard: None,
+            g,
+            pointer_lock: None,
+            rel_pointer: None,
+            shortcut_inhibitor: None,
+            client_for_window: Vec::new(),
+            focused: None,
+            qh,
+            wayland_fd,
+            read_guard: None,
+            pending_events: VecDeque::new(),
+            output_info: vec![],
+            scroll_discrete_pending: false,
+        };
+
+        // dispatch registry to () again, in order to read all wl_outputs
+        conn.display().get_registry(&state.qh, ());
+        log::debug!("==============> requested registry");
+
+        // roundtrip to read wl_output globals
+        queue.roundtrip(&mut state)?;
+        log::debug!("==============> roundtrip 1 done");
+
+        // read outputs
+        for output in state.g.outputs.iter() {
+            state
+                .g
+                .xdg_output_manager
+                .get_xdg_output(output, &state.qh, output.clone());
+        }
+
+        // roundtrip to read xdg_output events
+        queue.roundtrip(&mut state)?;
+
+        log::debug!("==============> roundtrip 2 done");
+        for i in &state.output_info {
+            log::debug!("{:#?}", i.1);
+        }
+
+        let read_guard = loop {
+            match queue.prepare_read() {
+                Some(r) => break r,
+                None => {
+                    queue.dispatch_pending(&mut state)?;
+                    continue;
+                }
+            }
+        };
+        state.read_guard = Some(read_guard);
+
+        let inner = AsyncFd::new(Inner { queue, state })?;
+
+        Ok(WaylandInputCapture(inner))
+    }
+
+    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+        self.0.get_mut().state.add_client(handle, pos);
+    }
+
+    fn delete_client(&mut self, handle: CaptureHandle) {
+        let inner = self.0.get_mut();
+        // remove all windows corresponding to this client
+        while let Some(i) = inner
+            .state
+            .client_for_window
+            .iter()
+            .position(|(_, c)| *c == handle)
+        {
+            inner.state.client_for_window.remove(i);
+            inner.state.focused = None;
+        }
+    }
+}
+
+impl State {
+    fn grab(
+        &mut self,
+        surface: &WlSurface,
+        pointer: &WlPointer,
+        serial: u32,
+        qh: &QueueHandle<State>,
+    ) {
+        let (window, _) = self.focused.as_ref().unwrap();
+
+        // hide the cursor
+        pointer.set_cursor(serial, None, 0, 0);
+
+        // capture input
+        window
+            .layer_surface
+            .set_keyboard_interactivity(KeyboardInteractivity::Exclusive);
+        window.surface.commit();
+
+        // lock pointer
+        if self.pointer_lock.is_none() {
+            self.pointer_lock = Some(self.g.pointer_constraints.lock_pointer(
+                surface,
+                pointer,
+                None,
+                Lifetime::Persistent,
+                qh,
+                (),
+            ));
+        }
+
+        // request relative input
+        if self.rel_pointer.is_none() {
+            self.rel_pointer = Some(self.g.relative_pointer_manager.get_relative_pointer(
+                pointer,
+                qh,
+                (),
+            ));
+        }
+
+        // capture modifier keys
+        if self.shortcut_inhibitor.is_none() {
+            self.shortcut_inhibitor = Some(self.g.shortcut_inhibit_manager.inhibit_shortcuts(
+                surface,
+                &self.g.seat,
+                qh,
+                (),
+            ));
+        }
+    }
+
+    fn ungrab(&mut self) {
+        // get focused client
+        let (window, _client) = match self.focused.as_ref() {
+            Some(focused) => focused,
+            None => return,
+        };
+
+        // ungrab surface
+        window
+            .layer_surface
+            .set_keyboard_interactivity(KeyboardInteractivity::None);
+        window.surface.commit();
+
+        // destroy pointer lock
+        if let Some(pointer_lock) = &self.pointer_lock {
+            pointer_lock.destroy();
+            self.pointer_lock = None;
+        }
+
+        // destroy relative input
+        if let Some(rel_pointer) = &self.rel_pointer {
+            rel_pointer.destroy();
+            self.rel_pointer = None;
+        }
+
+        // destroy shortcut inhibitor
+        if let Some(shortcut_inhibitor) = &self.shortcut_inhibitor {
+            shortcut_inhibitor.destroy();
+            self.shortcut_inhibitor = None;
+        }
+    }
+
+    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
+        let outputs = get_output_configuration(self, pos);
+
+        log::debug!("outputs: {outputs:?}");
+        outputs.iter().for_each(|(o, i)| {
+            let window = Window::new(self, &self.qh, o, pos, i.size);
+            let window = Rc::new(window);
+            self.client_for_window.push((window, client));
+        });
+    }
+
+    fn update_windows(&mut self) {
+        log::debug!("updating windows");
+        log::debug!("output info: {:?}", self.output_info);
+        let clients: Vec<_> = self
+            .client_for_window
+            .drain(..)
+            .map(|(w, c)| (c, w.pos))
+            .collect();
+        for (client, pos) in clients {
+            self.add_client(client, pos);
+        }
+    }
+}
+
+impl Inner {
+    fn read(&mut self) -> bool {
+        match self.state.read_guard.take().unwrap().read() {
+            Ok(_) => true,
+            Err(WaylandError::Io(e)) if e.kind() == ErrorKind::WouldBlock => false,
+            Err(WaylandError::Io(e)) => {
+                log::error!("error reading from wayland socket: {e}");
+                false
+            }
+            Err(WaylandError::Protocol(e)) => {
+                panic!("wayland protocol violation: {e}")
+            }
+        }
+    }
+
+    fn prepare_read(&mut self) -> io::Result<()> {
+        loop {
+            match self.queue.prepare_read() {
+                None => match self.queue.dispatch_pending(&mut self.state) {
+                    Ok(_) => continue,
+                    Err(DispatchError::Backend(WaylandError::Io(e))) => return Err(e),
+                    Err(e) => panic!("failed to dispatch wayland events: {e}"),
+                },
+                Some(r) => {
+                    self.state.read_guard = Some(r);
+                    break Ok(());
+                }
+            }
+        }
+    }
+
+    fn dispatch_events(&mut self) {
+        match self.queue.dispatch_pending(&mut self.state) {
+            Ok(_) => {}
+            Err(DispatchError::Backend(WaylandError::Io(e))) => {
+                log::error!("Wayland Error: {}", e);
+            }
+            Err(DispatchError::Backend(e)) => {
+                panic!("backend error: {}", e);
+            }
+            Err(DispatchError::BadMessage {
+                sender_id,
+                interface,
+                opcode,
+            }) => {
+                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
+            }
+        }
+    }
+
+    fn flush_events(&mut self) -> io::Result<()> {
+        // flush outgoing events
+        match self.queue.flush() {
+            Ok(_) => (),
+            Err(e) => match e {
+                WaylandError::Io(e) => {
+                    return Err(e);
+                }
+                WaylandError::Protocol(e) => {
+                    panic!("wayland protocol violation: {e}")
+                }
+            },
+        }
+        Ok(())
+    }
+}
+
+impl InputCapture for WaylandInputCapture {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+        self.add_client(handle, pos);
+        let inner = self.0.get_mut();
+        inner.flush_events()
+    }
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
+        self.delete_client(handle);
+        let inner = self.0.get_mut();
+        inner.flush_events()
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        log::debug!("releasing pointer");
+        let inner = self.0.get_mut();
+        inner.state.ungrab();
+        inner.flush_events()
+    }
+}
+
+impl Stream for WaylandInputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
+            return Poll::Ready(Some(Ok(event)));
+        }
+
+        loop {
+            let mut guard = ready!(self.0.poll_read_ready_mut(cx))?;
+
+            {
+                let inner = guard.get_inner_mut();
+
+                // read events
+                while inner.read() {
+                    // prepare next read
+                    match inner.prepare_read() {
+                        Ok(_) => {}
+                        Err(e) => return Poll::Ready(Some(Err(e))),
+                    }
+                }
+
+                // dispatch the events
+                inner.dispatch_events();
+
+                // flush outgoing events
+                if let Err(e) = inner.flush_events() {
+                    if e.kind() != ErrorKind::WouldBlock {
+                        return Poll::Ready(Some(Err(e)));
+                    }
+                }
+
+                // prepare for the next read
+                match inner.prepare_read() {
+                    Ok(_) => {}
+                    Err(e) => return Poll::Ready(Some(Err(e))),
+                }
+            }
+
+            // clear read readiness for tokio read guard
+            // guard.clear_ready_matching(Ready::READABLE);
+            guard.clear_ready();
+
+            // if an event has been queued during dispatch_events() we return it
+            match guard.get_inner_mut().state.pending_events.pop_front() {
+                Some(event) => return Poll::Ready(Some(Ok(event))),
+                None => continue,
+            }
+        }
+    }
+}
+
+impl Dispatch<wl_seat::WlSeat, ()> for State {
+    fn event(
+        state: &mut Self,
+        seat: &wl_seat::WlSeat,
+        event: <wl_seat::WlSeat as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        if let wl_seat::Event::Capabilities {
+            capabilities: WEnum::Value(capabilities),
+        } = event
+        {
+            if capabilities.contains(wl_seat::Capability::Pointer) && state.pointer.is_none() {
+                state.pointer.replace(seat.get_pointer(qh, ()));
+            }
+            if capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
+                seat.get_keyboard(qh, ());
+            }
+        }
+    }
+}
+
+impl Dispatch<WlPointer, ()> for State {
+    fn event(
+        app: &mut Self,
+        pointer: &WlPointer,
+        event: <WlPointer as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_pointer::Event::Enter {
+                serial,
+                surface,
+                surface_x: _,
+                surface_y: _,
+            } => {
+                // get client corresponding to the focused surface
+                {
+                    if let Some((window, client)) = app
+                        .client_for_window
+                        .iter()
+                        .find(|(w, _c)| w.surface == surface)
+                    {
+                        app.focused = Some((window.clone(), *client));
+                        app.grab(&surface, pointer, serial, qh);
+                    } else {
+                        return;
+                    }
+                }
+                let (_, client) = app
+                    .client_for_window
+                    .iter()
+                    .find(|(w, _c)| w.surface == surface)
+                    .unwrap();
+                app.pending_events.push_back((*client, Event::Enter()));
+            }
+            wl_pointer::Event::Leave { .. } => {
+                /* There are rare cases, where when a window is opened in
+                 * just the wrong moment, the pointer is released, while
+                 * still grabbed.
+                 * In that case, the pointer must be ungrabbed, otherwise
+                 * it is impossible to grab it again (since the pointer
+                 * lock, relative pointer,... objects are still in place)
+                 */
+                if app.pointer_lock.is_some() {
+                    log::warn!("compositor released mouse");
+                }
+                app.ungrab();
+            }
+            wl_pointer::Event::Button {
+                serial: _,
+                time,
+                button,
+                state,
+            } => {
+                let (_, client) = app.focused.as_ref().unwrap();
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::Button {
+                        time,
+                        button,
+                        state: u32::from(state),
+                    }),
+                ));
+            }
+            wl_pointer::Event::Axis { time, axis, value } => {
+                let (_, client) = app.focused.as_ref().unwrap();
+                if app.scroll_discrete_pending {
+                    // each axisvalue120 event is coupled with
+                    // a corresponding axis event, which needs to
+                    // be ignored to not duplicate the scrolling
+                    app.scroll_discrete_pending = false;
+                } else {
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Pointer(PointerEvent::Axis {
+                            time,
+                            axis: u32::from(axis) as u8,
+                            value,
+                        }),
+                    ));
+                }
+            }
+            wl_pointer::Event::AxisValue120 { axis, value120 } => {
+                let (_, client) = app.focused.as_ref().unwrap();
+                app.scroll_discrete_pending = true;
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::AxisDiscrete120 {
+                        axis: u32::from(axis) as u8,
+                        value: value120,
+                    }),
+                ));
+            }
+            wl_pointer::Event::Frame {} => {
+                // TODO properly handle frame events
+                // we simply insert a frame event on the client side
+                // after each event for now
+            }
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlKeyboard, ()> for State {
+    fn event(
+        app: &mut Self,
+        _: &WlKeyboard,
+        event: wl_keyboard::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        let (_window, client) = match &app.focused {
+            Some(focused) => (Some(&focused.0), Some(&focused.1)),
+            None => (None, None),
+        };
+        match event {
+            wl_keyboard::Event::Key {
+                serial: _,
+                time,
+                key,
+                state,
+            } => {
+                if let Some(client) = client {
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Key {
+                            time,
+                            key,
+                            state: u32::from(state) as u8,
+                        }),
+                    ));
+                }
+            }
+            wl_keyboard::Event::Modifiers {
+                serial: _,
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+            } => {
+                if let Some(client) = client {
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Modifiers {
+                            mods_depressed,
+                            mods_latched,
+                            mods_locked,
+                            group,
+                        }),
+                    ));
+                }
+            }
+            wl_keyboard::Event::Keymap {
+                format: _,
+                fd,
+                size: _,
+            } => {
+                let fd = unsafe { &File::from_raw_fd(fd.as_raw_fd()) };
+                let _mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+                // TODO keymap
+            }
+            _ => (),
+        }
+    }
+}
+
+impl Dispatch<ZwpRelativePointerV1, ()> for State {
+    fn event(
+        app: &mut Self,
+        _: &ZwpRelativePointerV1,
+        event: <ZwpRelativePointerV1 as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let zwp_relative_pointer_v1::Event::RelativeMotion {
+            utime_hi,
+            utime_lo,
+            dx: _,
+            dy: _,
+            dx_unaccel: surface_x,
+            dy_unaccel: surface_y,
+        } = event
+        {
+            if let Some((_window, client)) = &app.focused {
+                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::Motion {
+                        time,
+                        relative_x: surface_x,
+                        relative_y: surface_y,
+                    }),
+                ));
+            }
+        }
+    }
+}
+
+impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
+    fn event(
+        app: &mut Self,
+        layer_surface: &ZwlrLayerSurfaceV1,
+        event: <ZwlrLayerSurfaceV1 as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
+            if let Some((window, _client)) = app
+                .client_for_window
+                .iter()
+                .find(|(w, _c)| &w.layer_surface == layer_surface)
+            {
+                // client corresponding to the layer_surface
+                let surface = &window.surface;
+                let buffer = &window.buffer;
+                surface.attach(Some(buffer), 0, 0);
+                layer_surface.ack_configure(serial);
+                surface.commit();
+            }
+        }
+    }
+}
+
+// delegate wl_registry events to App itself
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
+    fn event(
+        _state: &mut Self,
+        _proxy: &wl_registry::WlRegistry,
+        _event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
+        _data: &GlobalListContents,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<wl_registry::WlRegistry, ()> for State {
+    fn event(
+        state: &mut Self,
+        registry: &wl_registry::WlRegistry,
+        event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_registry::Event::Global {
+                name,
+                interface,
+                version: _,
+            } => {
+                if interface.as_str() == "wl_output" {
+                    log::debug!("wl_output global");
+                    state
+                        .g
+                        .outputs
+                        .push(registry.bind::<WlOutput, _, _>(name, 4, qh, ()))
+                }
+            }
+            wl_registry::Event::GlobalRemove { .. } => {}
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<ZxdgOutputV1, WlOutput> for State {
+    fn event(
+        state: &mut Self,
+        _: &ZxdgOutputV1,
+        event: <ZxdgOutputV1 as wayland_client::Proxy>::Event,
+        wl_output: &WlOutput,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        log::debug!("xdg-output - {event:?}");
+        let output_info = match state.output_info.iter_mut().find(|(o, _)| o == wl_output) {
+            Some((_, c)) => c,
+            None => {
+                let output_info = OutputInfo::new();
+                state.output_info.push((wl_output.clone(), output_info));
+                &mut state.output_info.last_mut().unwrap().1
+            }
+        };
+
+        match event {
+            zxdg_output_v1::Event::LogicalPosition { x, y } => {
+                output_info.position = (x, y);
+            }
+            zxdg_output_v1::Event::LogicalSize { width, height } => {
+                output_info.size = (width, height);
+            }
+            zxdg_output_v1::Event::Done => {}
+            zxdg_output_v1::Event::Name { name } => {
+                output_info.name = name;
+            }
+            zxdg_output_v1::Event::Description { .. } => {}
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlOutput, ()> for State {
+    fn event(
+        state: &mut Self,
+        _proxy: &WlOutput,
+        event: <WlOutput as wayland_client::Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        if let wl_output::Event::Done = event {
+            state.update_windows();
+        }
+    }
+}
+
+// don't emit any events
+delegate_noop!(State: wl_region::WlRegion);
+delegate_noop!(State: wl_shm_pool::WlShmPool);
+delegate_noop!(State: wl_compositor::WlCompositor);
+delegate_noop!(State: ZwlrLayerShellV1);
+delegate_noop!(State: ZwpRelativePointerManagerV1);
+delegate_noop!(State: ZwpKeyboardShortcutsInhibitManagerV1);
+delegate_noop!(State: ZwpPointerConstraintsV1);
+
+// ignore events
+delegate_noop!(State: ignore ZxdgOutputManagerV1);
+delegate_noop!(State: ignore wl_shm::WlShm);
+delegate_noop!(State: ignore wl_buffer::WlBuffer);
+delegate_noop!(State: ignore WlSurface);
+delegate_noop!(State: ignore ZwpKeyboardShortcutsInhibitorV1);
+delegate_noop!(State: ignore ZwpLockedPointerV1);

input-capture/src/windows.rs

@@ -0,0 +1,630 @@
+use anyhow::Result;
+use core::task::{Context, Poll};
+use futures::Stream;
+use once_cell::unsync::Lazy;
+
+use std::collections::HashMap;
+use std::ptr::{addr_of, addr_of_mut};
+
+use futures::executor::block_on;
+use std::default::Default;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{mpsc, Mutex};
+use std::task::ready;
+use std::{io, pin::Pin, thread};
+use tokio::sync::mpsc::{channel, Receiver, Sender};
+use windows::core::{w, PCWSTR};
+use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
+use windows::Win32::Graphics::Gdi::{
+    EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
+    DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
+};
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::Threading::GetCurrentThreadId;
+
+use windows::Win32::UI::WindowsAndMessaging::{
+    CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
+    HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
+    WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
+    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
+    WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
+    WNDPROC,
+};
+
+use input_event::{
+    scancode::{self, Linux},
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+};
+
+use super::{CaptureHandle, InputCapture, Position};
+
+enum Request {
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+}
+
+pub struct WindowsInputCapture {
+    event_rx: Receiver<(CaptureHandle, Event)>,
+    msg_thread: Option<std::thread::JoinHandle<()>>,
+}
+
+enum EventType {
+    Request = 0,
+    Release = 1,
+    Exit = 2,
+}
+
+unsafe fn signal_message_thread(event_type: EventType) {
+    if let Some(event_tid) = get_event_tid() {
+        PostThreadMessageW(event_tid, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap();
+    } else {
+        panic!();
+    }
+}
+
+impl InputCapture for WindowsInputCapture {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Create(handle, pos));
+            }
+            signal_message_thread(EventType::Request);
+        }
+        Ok(())
+    }
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Destroy(handle));
+            }
+            signal_message_thread(EventType::Request);
+        }
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        unsafe { signal_message_thread(EventType::Release) };
+        Ok(())
+    }
+}
+
+static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
+static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(CaptureHandle, Event)>> = None;
+static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
+unsafe fn set_event_tid(tid: u32) {
+    EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
+}
+unsafe fn get_event_tid() -> Option<u32> {
+    match EVENT_THREAD_ID.load(Ordering::SeqCst) {
+        0 => None,
+        id => Some(id),
+    }
+}
+
+static mut ENTRY_POINT: (i32, i32) = (0, 0);
+
+fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
+    let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
+    match wparam {
+        WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_LEFT,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_MBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_MIDDLE,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_RBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_RIGHT,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_LBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_LEFT,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_MBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_MIDDLE,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_RBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_RIGHT,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_MOUSEMOVE as usize => unsafe {
+            let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+            let (ex, ey) = ENTRY_POINT;
+            let (dx, dy) = (x - ex, y - ey);
+            Some(PointerEvent::Motion {
+                time: 0,
+                relative_x: dx as f64,
+                relative_y: dy as f64,
+            })
+        },
+        WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
+            axis: 0,
+            value: -(mouse_low_level.mouseData as i32 >> 16),
+        }),
+        WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
+            let hb = mouse_low_level.mouseData >> 16;
+            let button = match hb {
+                1 => BTN_BACK,
+                2 => BTN_FORWARD,
+                _ => {
+                    log::warn!("unknown mouse button");
+                    return None;
+                }
+            };
+            Some(PointerEvent::Button {
+                time: 0,
+                button,
+                state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
+            })
+        }
+        w => {
+            log::warn!("unknown mouse event: {w:?}");
+            None
+        }
+    }
+}
+
+unsafe fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
+    let kybrdllhookstruct: KBDLLHOOKSTRUCT = *(lparam.0 as *const KBDLLHOOKSTRUCT);
+    let mut scan_code = kybrdllhookstruct.scanCode;
+    log::trace!("scan_code: {scan_code}");
+    if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
+        scan_code |= 0xE000;
+    }
+    let Ok(win_scan_code) = scancode::Windows::try_from(scan_code) else {
+        log::warn!("failed to translate to windows scancode: {scan_code}");
+        return None;
+    };
+    log::trace!("windows_scan: {win_scan_code:?}");
+    let Ok(linux_scan_code): Result<Linux, ()> = win_scan_code.try_into() else {
+        log::warn!("failed to translate into linux scancode: {win_scan_code:?}");
+        return None;
+    };
+    log::trace!("windows_scan: {linux_scan_code:?}");
+    let scan_code = linux_scan_code as u32;
+    match wparam {
+        WPARAM(p) if p == WM_KEYDOWN as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_KEYUP as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_SYSKEYDOWN as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_SYSKEYUP as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        _ => None,
+    }
+}
+
+///
+/// clamp point to display bounds
+///
+/// # Arguments
+///
+/// * `prev_point`: coordinates, the cursor was before entering, within bounds of a display
+/// * `entry_point`: point to clamp
+///
+/// returns: (i32, i32), the corrected entry point
+///
+fn clamp_to_display_bounds(prev_point: (i32, i32), point: (i32, i32)) -> (i32, i32) {
+    /* find display where movement came from */
+    let display_regions = unsafe { get_display_regions() };
+    let display = display_regions
+        .iter()
+        .find(|&d| is_within_dp_region(prev_point, d))
+        .unwrap();
+
+    /* clamp to bounds (inclusive) */
+    let (x, y) = point;
+    let (min_x, max_x) = (display.left, display.right - 1);
+    let (min_y, max_y) = (display.top, display.bottom - 1);
+    (x.clamp(min_x, max_x), y.clamp(min_y, max_y))
+}
+
+unsafe fn send_blocking(event: Event) {
+    if let Some(active) = ACTIVE_CLIENT {
+        block_on(async move {
+            let _ = EVENT_TX.as_ref().unwrap().send((active, event)).await;
+        });
+    }
+}
+
+unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
+    if wparam.0 != WM_MOUSEMOVE as usize {
+        return ACTIVE_CLIENT.is_some();
+    }
+    let mouse_low_level: MSLLHOOKSTRUCT = *(lparam.0 as *const MSLLHOOKSTRUCT);
+    static mut PREV_POS: Option<(i32, i32)> = None;
+    let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+    let prev_pos = PREV_POS.unwrap_or(curr_pos);
+    PREV_POS.replace(curr_pos);
+
+    /* next event is the first actual event */
+    let ret = ACTIVE_CLIENT.is_some();
+
+    /* client already active, no need to check */
+    if ACTIVE_CLIENT.is_some() {
+        return ret;
+    }
+
+    /* check if a client was activated */
+    let Some(pos) = entered_barrier(prev_pos, curr_pos, get_display_regions()) else {
+        return ret;
+    };
+
+    /* check if a client is registered for the barrier */
+    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
+        return ret;
+    };
+
+    /* update active client and entry point */
+    ACTIVE_CLIENT.replace(*client);
+    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
+
+    /* notify main thread */
+    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
+    send_blocking(Event::Enter());
+
+    ret
+}
+
+unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    let active = check_client_activation(wparam, lparam);
+
+    /* no client was active */
+    if !active {
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+    }
+
+    /* get active client if any */
+    let Some(client) = ACTIVE_CLIENT else {
+        return LRESULT(1);
+    };
+
+    /* convert to lan-mouse event */
+    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+    let event = (client, Event::Pointer(pointer_event));
+
+    /* notify mainthread (drop events if sending too fast) */
+    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
+        log::warn!("e: {e}");
+    }
+
+    /* don't pass event to applications */
+    LRESULT(1)
+}
+
+unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    /* get active client if any */
+    let Some(client) = ACTIVE_CLIENT else {
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+    };
+
+    /* convert to key event */
+    let Some(key_event) = to_key_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+    let event = (client, Event::Keyboard(key_event));
+
+    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
+        log::warn!("e: {e}");
+    }
+
+    /* don't pass event to applications */
+    LRESULT(1)
+}
+
+unsafe extern "system" fn window_proc(
+    _hwnd: HWND,
+    uint: u32,
+    _wparam: WPARAM,
+    _lparam: LPARAM,
+) -> LRESULT {
+    match uint {
+        x if x == WM_DISPLAYCHANGE => {
+            log::debug!("display resolution changed");
+            DISPLAY_RESOLUTION_CHANGED = true;
+        }
+        _ => {}
+    }
+    LRESULT(1)
+}
+
+fn enumerate_displays() -> Vec<RECT> {
+    unsafe {
+        let mut display_rects = vec![];
+        let mut devices = vec![];
+        for i in 0.. {
+            let mut device: DISPLAY_DEVICEW = std::mem::zeroed();
+            device.cb = std::mem::size_of::<DISPLAY_DEVICEW>() as u32;
+            let ret = EnumDisplayDevicesW(None, i, &mut device, EDD_GET_DEVICE_INTERFACE_NAME);
+            if ret == FALSE {
+                break;
+            }
+            if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
+                devices.push(device.DeviceName);
+            }
+        }
+        for device in devices {
+            let mut dev_mode: DEVMODEW = std::mem::zeroed();
+            dev_mode.dmSize = std::mem::size_of::<DEVMODEW>() as u16;
+            let ret = EnumDisplaySettingsW(
+                PCWSTR::from_raw(&device as *const _),
+                ENUM_CURRENT_SETTINGS,
+                &mut dev_mode,
+            );
+            if ret == FALSE {
+                log::warn!("no display mode");
+            }
+
+            let pos = dev_mode.Anonymous1.Anonymous2.dmPosition;
+            let (x, y) = (pos.x, pos.y);
+            let (width, height) = (dev_mode.dmPelsWidth, dev_mode.dmPelsHeight);
+
+            display_rects.push(RECT {
+                left: x,
+                right: x + width as i32,
+                top: y,
+                bottom: y + height as i32,
+            });
+        }
+        display_rects
+    }
+}
+
+static mut DISPLAY_RESOLUTION_CHANGED: bool = true;
+
+unsafe fn get_display_regions() -> &'static Vec<RECT> {
+    static mut DISPLAYS: Vec<RECT> = vec![];
+    if DISPLAY_RESOLUTION_CHANGED {
+        DISPLAYS = enumerate_displays();
+        DISPLAY_RESOLUTION_CHANGED = false;
+        log::debug!("displays: {DISPLAYS:?}");
+    }
+    &*addr_of!(DISPLAYS)
+}
+
+fn is_within_dp_region(point: (i32, i32), display: &RECT) -> bool {
+    [
+        Position::Left,
+        Position::Right,
+        Position::Top,
+        Position::Bottom,
+    ]
+    .iter()
+    .all(|&pos| is_within_dp_boundary(point, display, pos))
+}
+fn is_within_dp_boundary(point: (i32, i32), display: &RECT, pos: Position) -> bool {
+    let (x, y) = point;
+    match pos {
+        Position::Left => display.left <= x,
+        Position::Right => display.right > x,
+        Position::Top => display.top <= y,
+        Position::Bottom => display.bottom > y,
+    }
+}
+
+/// returns whether the given position is within the display bounds with respect to the given
+/// barrier position
+///
+/// # Arguments
+///
+/// * `x`:
+/// * `y`:
+/// * `displays`:
+/// * `pos`:
+///
+/// returns: bool
+///
+fn in_bounds(point: (i32, i32), displays: &[RECT], pos: Position) -> bool {
+    displays
+        .iter()
+        .any(|d| is_within_dp_boundary(point, d, pos))
+}
+
+fn in_display_region(point: (i32, i32), displays: &[RECT]) -> bool {
+    displays.iter().any(|d| is_within_dp_region(point, d))
+}
+
+fn moved_across_boundary(
+    prev_pos: (i32, i32),
+    curr_pos: (i32, i32),
+    displays: &[RECT],
+    pos: Position,
+) -> bool {
+    /* was within bounds, but is not anymore */
+    in_display_region(prev_pos, displays) && !in_bounds(curr_pos, displays, pos)
+}
+
+fn entered_barrier(
+    prev_pos: (i32, i32),
+    curr_pos: (i32, i32),
+    displays: &[RECT],
+) -> Option<Position> {
+    [
+        Position::Left,
+        Position::Right,
+        Position::Top,
+        Position::Bottom,
+    ]
+    .into_iter()
+    .find(|&pos| moved_across_boundary(prev_pos, curr_pos, displays, pos))
+}
+
+fn get_msg() -> Option<MSG> {
+    unsafe {
+        let mut msg = std::mem::zeroed();
+        let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
+        match ret.0 {
+            0 => None,
+            x if x > 0 => Some(msg),
+            _ => panic!("error in GetMessageW"),
+        }
+    }
+}
+
+fn message_thread(ready_tx: mpsc::Sender<()>) {
+    unsafe {
+        set_event_tid(GetCurrentThreadId());
+        ready_tx.send(()).expect("channel closed");
+        let mouse_proc: HOOKPROC = Some(mouse_proc);
+        let kybrd_proc: HOOKPROC = Some(kybrd_proc);
+        let window_proc: WNDPROC = Some(window_proc);
+
+        /* register hooks */
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
+
+        let instance = GetModuleHandleW(None).unwrap();
+        let window_class: WNDCLASSW = WNDCLASSW {
+            lpfnWndProc: window_proc,
+            hInstance: instance.into(),
+            lpszClassName: w!("lan-mouse-message-window-class"),
+            ..Default::default()
+        };
+
+        let ret = RegisterClassW(&window_class);
+        if ret == 0 {
+            panic!("RegisterClassW");
+        }
+
+        /* window is used ro receive WM_DISPLAYCHANGE messages */
+        let ret = CreateWindowExW(
+            Default::default(),
+            w!("lan-mouse-message-window-class"),
+            w!("lan-mouse-msg-window"),
+            WINDOW_STYLE::default(),
+            0,
+            0,
+            0,
+            0,
+            HWND::default(),
+            HMENU::default(),
+            instance,
+            None,
+        );
+        if ret.0 == 0 {
+            panic!("CreateWindowExW");
+        }
+
+        /* run message loop */
+        loop {
+            // mouse / keybrd proc do not actually return a message
+            let Some(msg) = get_msg() else {
+                break;
+            };
+            if msg.hwnd.0 == 0 {
+                /* messages sent via PostThreadMessage */
+                match msg.wParam.0 {
+                    x if x == EventType::Exit as usize => break,
+                    x if x == EventType::Release as usize => {
+                        ACTIVE_CLIENT.take();
+                    }
+                    x if x == EventType::Request as usize => {
+                        let requests = {
+                            let mut res = vec![];
+                            let mut requests = REQUEST_BUFFER.lock().unwrap();
+                            for request in requests.drain(..) {
+                                res.push(request);
+                            }
+                            res
+                        };
+
+                        for request in requests {
+                            update_clients(request)
+                        }
+                    }
+                    _ => {}
+                }
+            } else {
+                /* other messages for window_procs */
+                TranslateMessage(&msg);
+                DispatchMessageW(&msg);
+            }
+        }
+    }
+}
+
+fn update_clients(request: Request) {
+    match request {
+        Request::Create(handle, pos) => {
+            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
+        }
+        Request::Destroy(handle) => unsafe {
+            for pos in [
+                Position::Left,
+                Position::Right,
+                Position::Top,
+                Position::Bottom,
+            ] {
+                if ACTIVE_CLIENT == Some(handle) {
+                    ACTIVE_CLIENT.take();
+                }
+                if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
+                    CLIENT_FOR_POS.remove(&pos);
+                }
+            }
+        },
+    }
+}
+
+impl WindowsInputCapture {
+    pub(crate) fn new() -> Self {
+        unsafe {
+            let (tx, rx) = channel(10);
+            EVENT_TX.replace(tx);
+            let (ready_tx, ready_rx) = mpsc::channel();
+            let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
+            /* wait for thread to set its id */
+            ready_rx.recv().expect("channel closed");
+            Self {
+                msg_thread,
+                event_rx: rx,
+            }
+        }
+    }
+}
+
+impl Stream for WindowsInputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match ready!(self.event_rx.poll_recv(cx)) {
+            None => Poll::Ready(None),
+            Some(e) => Poll::Ready(Some(Ok(e))),
+        }
+    }
+}
+
+impl Drop for WindowsInputCapture {
+    fn drop(&mut self) {
+        unsafe { signal_message_thread(EventType::Exit) };
+        let _ = self.msg_thread.take().unwrap().join();
+    }
+}

input-capture/src/x11.rs

@@ -0,0 +1,43 @@
+use std::io;
+use std::task::Poll;
+
+use futures_core::Stream;
+
+use super::InputCapture;
+use input_event::Event;
+
+use super::error::X11InputCaptureCreationError;
+use super::{CaptureHandle, Position};
+
+pub struct X11InputCapture {}
+
+impl X11InputCapture {
+    pub fn new() -> std::result::Result<Self, X11InputCaptureCreationError> {
+        Err(X11InputCaptureCreationError::NotImplemented)
+    }
+}
+
+impl InputCapture for X11InputCapture {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Stream for X11InputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}