chore: Release

split features for emulation and capture backends
fix conditional compilation for xdp only build
2026-03-16 17:50:54 +03:00 · 2024-11-07 12:49:59 +01:00 · 2024-11-07 12:43:42 +01:00 · 2024-11-07 12:21:38 +01:00 · 2024-11-07 02:37:40 +01:00 · 2024-11-07 02:36:11 +01:00
33 changed files with 1459 additions and 1144 deletions
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -55,7 +55,9 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        pipx install gvsbuild
+        py -m venv .venv
        .venv\Scripts\activate.ps1
        py -m pip install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -66,7 +66,9 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        pipx install gvsbuild
+        py -m venv .venv
        .venv\Scripts\activate.ps1
        py -m pip install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -51,7 +51,9 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        pipx install gvsbuild
+        py -m venv .venv
        .venv\Scripts\activate.ps1
        py -m pip install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@ members = [
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.9.1"
+version = "0.10.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -22,13 +22,13 @@ strip = true
 lto = "fat"
 [dependencies]
-input-event = { path = "input-event", version = "0.2.1" }
+input-event = { path = "input-event", version = "0.3.0" }
-input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
+input-emulation = { path = "input-emulation", version = "0.3.0", default-features = false }
-input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
+input-capture = { path = "input-capture", version = "0.3.0", default-features = false }
-lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
+lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
-lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
+lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
-lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
+lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
-lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }
+lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
 hickory-resolver = "0.24.1"
 toml = "0.8"
@@ -49,7 +49,7 @@ tokio = { version = "1.32.0", features = [
 futures = "0.3.28"
 clap = { version = "4.4.11", features = ["derive"] }
 slab = "0.4.9"
-thiserror = "1.0.61"
+thiserror = "2.0.0"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
@@ -57,9 +57,21 @@ local-channel = "0.1.5"
 libc = "0.2.148"
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+default = [
-wayland = ["input-capture/wayland", "input-emulation/wayland"]
+    "gtk",
-x11 = ["input-capture/x11", "input-emulation/x11"]
+    "layer_shell_capture",
-xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
+    "x11_capture",
-libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
+    "libei_capture",
    "wlroots_emulation",
    "libei_emulation",
    "rdp_emulation",
    "x11_emulation",
 ]
 gtk = ["dep:lan-mouse-gtk"]
 layer_shell_capture = ["input-capture/layer_shell"]
 x11_capture = ["input-capture/x11"]
 libei_capture = ["input-event/libei", "input-capture/libei"]
 libei_emulation = ["input-event/libei", "input-emulation/libei"]
 wlroots_emulation = ["input-emulation/wlroots"]
 x11_emulation = ["input-emulation/x11"]
 rdp_emulation = ["input-emulation/remote_desktop_portal"]
--- a/README.md
+++ b/README.md
@@ -1,78 +1,65 @@
 # Lan Mouse
-Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices.
+Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
-It allows for using multiple pcs with a single set of mouse and keyboard.
+It allows for using multiple PCs via a single set of mouse and keyboard.
 This is also known as a Software KVM switch.
-The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
+Goal of this project is to be an open-source alternative to proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/)
 and an alternative to other open source tools like [Deskflow](https://github.com/deskflow/deskflow) or [Input Leap](https://github.com/input-leap) (Synergy fork).
 Focus lies on performance, ease of use and a maintainable implementation that can be expanded to support additional backends for e.g. Android, iOS, ... in the future.
 ***blazingly fast™*** because it's written in rust.
 - _Now with a gtk frontend_
 <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
+    <source media="(prefers-color-scheme: dark)" srcset="/screenshots/dark.png?raw=true">
-    <source media="(prefers-color-scheme: light)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/d6318340-f811-4e16-9d6e-d1b79883c709">
+    <source media="(prefers-color-scheme: light)" srcset="/screenshots/light.png?raw=true">
-    <img alt="Screenshot of Lan-Mouse" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
+    <img alt="Screenshot of Lan-Mouse" srcset="/screenshots/dark.png">
 </picture>
 Goal of this project is to be an open-source replacement for proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/).
 Focus lies on performance and a clean, manageable implementation that can easily be expanded to support additional backends like e.g. Android, iOS, ... .
 ***blazingly fast™*** because it's written in rust.
 For an alternative (with slightly different goals) you may check out [Synergy 1 Community Edition](https://github.com/symless/synergy) or [Input Leap](https://github.com/input-leap) (Synergy fork).
 > [!WARNING]
-> Since this tool has gained a bit of popularity over the past couple of days:
+> DISCLAIMER:
->
+> Until [#200](https://github.com/feschber/lan-mouse/pull/200) is merged, all network traffic is **unencrypted** and sent in **plaintext**!
 > All network traffic is currently **unencrypted** and sent in **plaintext**.
 >
 > A malicious actor with access to the network could read input data or send input events with spoofed IPs to take control over a device.
 >
-> Therefore you should only use this tool in your local network with trusted devices for now
+> Therefore you should only use this tool in your local network with trusted devices.
-> and I take no responsibility for any leakage of data!
+> I take no responsibility for any security breaches!
 ## OS Support
-The following table shows support for input emulation (to emulate events received from other clients) and
+Most current desktop environments and operating systems are fully supported, this includes
-input capture (to send events *to* other clients) on different operating systems:
+- GNOME >= 45
 - KDE Plasma >= 6.1
 - Most wlroots based compositors, including Sway (>= 1.8), Hyprland and Wayfire
 - Windows
 - MacOS
-| OS / Desktop Environment  | input emulation          | input capture                        |
+
-|---------------------------|--------------------------|--------------------------------------|
+### Caveats / Known Issues
 | Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
 | Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
 | Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark: (starting at GNOME 45) |
 | Windows                   | :heavy_check_mark:       | :heavy_check_mark:                   |
 | X11                       | :heavy_check_mark:       | WIP                                  |
 | MacOS                     | :heavy_check_mark:       | WIP                                  |
 > [!Important]
-> Gnome -> Sway only partially works (modifier events are not handled correctly)
+> - **X11** currently only has support for input emulation, i.e. can only be used on the receiving end.
 > [!Important]
 > **Wayfire**
 >
-> If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
+> - **Sway / wlroots**: Wlroots based compositors without libei support on the receiving end currently do not handle modifier events on the client side.
 > This results in CTRL / SHIFT / ALT / SUPER keys not working with a sending device that is NOT using the `layer-shell` backend
 >
 > - **Wayfire**: If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
-
+>
-> [!Important]
+> - **Windows**: The mouse cursor will be invisible when sending input to a Windows system if
 > The mouse cursor will be invisible when sending input to a Windows system if
 > there is no real mouse connected to the machine.
 For more detailed information about os support see [Detailed OS Support](#detailed-os-support)
 ## Installation
 ### Install via cargo
 ```sh
 cargo install lan-mouse
 ```
-### Download from Releases
+<details>
-Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
+    <summary>Arch Linux</summary>
 For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
 ### Arch Linux
 Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):
@@ -80,39 +67,37 @@ Lan Mouse can be installed from the [official repositories](https://archlinux.or
 pacman -S lan-mouse
 ```
-It is also available on the AUR:
+The prerelease version (following `main`) is available on the AUR:
 ```sh
 # git version (includes latest changes)
 paru -S lan-mouse-git
 # alternatively
 paru -S lan-mouse-bin
 ```
 </details>
 <details>
    <summary>Nix (OS)</summary>
 ### Nix
 - nixpkgs: [search.nixos.org](https://search.nixos.org/packages?channel=unstable&show=lan-mouse&from=0&size=50&sort=relevance&type=packages&query=lan-mouse)
 - flake: [README.md](./nix/README.md)
 </details>
-### Manual Installation
+
 <details>
    <summary>Manual Installation</summary>
 First make sure to [install the necessary dependencies](#installing-dependencies).
-Build in release mode:
+Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
-```sh
+For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
 cargo build --release
 ```
-Run directly:
+Alternatively, the `lan-mouse` binary can be compiled from source (see below).
 ```sh
 cargo run --release
 ```
-Install the files:
+### Installing desktop file, app icon and firewall rules (optional)
 ```sh
-# install lan-mouse
+# install lan-mouse (replace path/to/ with the correct path)
-sudo cp target/release/lan-mouse /usr/local/bin/
+sudo cp path/to/lan-mouse /usr/local/bin/
 # install app icon
 sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
@@ -130,17 +115,34 @@ sudo cp firewall/lan-mouse.xml /etc/firewalld/services
 # -> enable the service in firewalld settings
 ```
-### Conditional Compilation
+Instead of downloading from the releases, the `lan-mouse` binary
 can be easily compiled via cargo or nix:
-Currently only x11, wayland, windows and MacOS are supported backends.
+### Compiling and installing manually:
-Depending on the toolchain used, support for other platforms is omitted
+```sh
-automatically (it does not make sense to build a Windows `.exe` with
+# compile in release mode
-support for x11 and wayland backends).
+cargo build --release
-However one might still want to omit support for e.g. wayland, x11 or libei on
+# install lan-mouse
-a Linux system.
+sudo cp target/release/lan-mouse /usr/local/bin/
 ```
-This is possible through
+### Compiling and installing via cargo:
 ```sh
 # will end up in ~/.cargo/bin
 cargo install lan-mouse
 ```
 ### Compiling and installing via nix:
 ```sh
 # you can find the executable in result/bin/lan-mouse
 nix-build
 ```
 ### Conditional compilation
 Support for other platforms is omitted automatically based on the active
 rust toolchain.
 Additionally, available backends and frontends can be configured manually via
 [cargo features](https://doc.rust-lang.org/cargo/reference/features.html).
 E.g. if only wayland support is needed, the following command produces
@@ -149,14 +151,17 @@ an executable with just support for wayland:
 cargo build --no-default-features --features wayland
 ```
 For a detailed list of available features, checkout the [Cargo.toml](./Cargo.toml)
 </details>
-## Installing Dependencies
+
 ## Installing Dependencies for Development / Compiling from Source
 <details>
    <summary>MacOS</summary>
 ```sh
-brew install libadwaita
+brew install libadwaita pkg-config
 ```
 </details>
@@ -184,10 +189,22 @@ sudo dnf install libadwaita-devel libXtst-devel libX11-devel
 ```
 </details>
 <details>
-    <summary>Windows</summary>
+    <summary>Nix</summary>
 ```sh
 nix-shell .
 ```
 </details>
 <details>
    <summary>Nix (flake)</summary>
 ```sh
 nix develop
 ```
 </details>
-> [!NOTE]
+<details>
-> This is only necessary when building lan-mouse from source. The windows release comes with precompiled gtk dlls.
+    <summary>Windows</summary>
 - First install [Rust](https://www.rust-lang.org/tools/install).
@@ -219,18 +236,20 @@ python -m pipx ensurepath
 pipx install gvsbuild
 # build gtk + libadwaita
-gvsbuild build gtk4 libadwaita librsvg
+gvsbuild build gtk4 libadwaita librsvg adwaita-icon-theme
 ```
 - **Make sure to add the directory** `C:\gtk-build\gtk\x64\release\bin`
 [**to the `PATH` environment variable**]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.
 To avoid building GTK from source, it is possible to disable
-the gtk frontend (see conditional compilation below).
+the gtk frontend (see conditional compilation).
 </details>
 ## Usage
-### Gtk Frontend
+<details>
    <summary>Gtk Frontend</summary>
 By default the gtk frontend will open when running `lan-mouse`.
 To add a new connection, simply click the `Add` button on *both* devices,
@@ -238,8 +257,11 @@ enter the corresponding hostname and activate it.
 If the mouse can not be moved onto a device, make sure you have port `4242` (or the one selected)
 opened up in your firewall.
 </details>
 <details>
    <summary>Command Line Interface</summary>
 ### Command Line Interface
 The cli interface can be enabled using `--frontend cli` as commandline arguments.
 Type `help` to list the available commands.
@@ -253,13 +275,17 @@ $ cargo run --release -- --frontend cli
 (...)
 > activate 0
 ```
 </details>
 <details>
    <summary>Daemon Mode</summary>
 Lan Mouse can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).
 ### Daemon
 Lan Mouse can be launched in daemon mode to keep it running in the background.
 To do so, add `--daemon` to the commandline args:
 ```sh
-$ cargo run --release -- --daemon
+lan-mouse --daemon
 ```
 In order to start lan-mouse with a graphical session automatically,
@@ -272,6 +298,7 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
 </details>
 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
@@ -327,109 +354,60 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [x] Liveness tracking: Automatically release keys, when server offline
 - [x] MacOS KeyCode Translation
 - [x] Libei Input Capture
 - [x] MacOS Input Capture
 - [x] Windows Input Capture
 - [ ] *Encryption* (WIP)
 - [ ] X11 Input Capture
 - [ ] Windows Input Capture
 - [ ] MacOS Input Capture
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
 - [ ] Clipboard support
 - [ ] *Encryption*
 ## Protocol
 Currently *all* mouse and keyboard events are sent via **UDP** for performance reasons.
 Each event is sent as one single datagram, currently without any acknowledgement to guarantee 0% packet loss.
 This means, any packet that is lost results in a discarded mouse / key event, which is ignored for now.
 **UDP** also has the additional benefit that no reconnection logic is required.
 Any client can just go offline and it will simply start working again as soon as it comes back online.
 Additionally a tcp server is hosted for data that needs to be sent reliably (e.g. the keymap from the server or clipboard contents in the future) can be requested via a tcp connection.
 ## Bandwidth considerations
 The most bandwidth is taken up by mouse events. A typical office mouse has a polling rate of 125Hz
 while gaming mice typically have a much higher polling rate of 1000Hz.
 A mouse Event consists of 21 Bytes:
 - 1 Byte for the event type enum,
 - 4 Bytes (u32) for the timestamp,
 - 8 Bytes (f64) for dx,
 - 8 Bytes (f64) for dy.
 Additionally the IP header with 20 Bytes and the udp header with 8 Bytes take up another 28 Byte.
 So in total there is 49 * 1000 Bytes/s for a 1000Hz gaming mouse.
 This makes for a bandwidth requirement of 392 kbit/s in total _even_ for a high end gaming mouse.
 So bandwidth is a non-issue.
 Larger data chunks, like the keymap are offered by the server via tcp listening on the same port.
 This way we dont need to implement any congestion control and leave this up to tcp.
 In the future this can be used for e.g. clipboard contents as well.
 ## Packets per Second
 While on LAN the performance is great,
 some WIFI cards seem to struggle with the amount of packets per second,
 particularly on high-end gaming mice with 1000Hz+ polling rates.
 The plan is to implement a way of accumulating packets and sending them as
 one single key event to reduce the packet rate (basically reducing the polling
 rate artificially).
 The way movement data is currently sent is also quite wasteful since even a 16bit integer
 is likely enough to represent even the fastest possible mouse movement.
 A different encoding that is more efficient for smaller values like
 [Protocol Buffers](https://protobuf.dev/programming-guides/encoding/)
 would be a better choice for the future and could also help for WIFI connections.
 ## Security
 Sending key and mouse event data over the local network might not be the biggest security concern but in any public network or business environment it's *QUITE* a problem to basically broadcast your keystrokes.
 - There should be an encryption layer below the application to enable a secure link.
 - The encryption keys could be generated by the graphical frontend.
-## Wayland support
+## Detailed OS Support
 ### Input Emulation (for receiving events)
 On wayland input-emulation is in an early/unstable state as of writing this.
-For this reason a suitable backend is chosen based on the active desktop environment / compositor.
+In order to use a device for sending events, an **input-capture** backend is required, while receiving events requires
 a supported **input-emulation** *and* **input-capture** backend.
-Different compositors have different ways of enabling input emulation:
+A suitable backend is chosen automatically based on the active desktop environment / compositor.
-#### Wlroots
+The following sections detail the emulation and capture backends provided by lan-mouse and their support in desktop environments / operating systems.
 Most wlroots-based compositors like Hyprland and Sway support the following
 unstable wayland protocols for keyboard and mouse emulation:
 - [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
 - [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1)
-#### KDE
+### Input Emulation Support
 KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)),
 it is however not exposed to third party applications.
-The recommended way to emulate input on KDE is the
+| Desktop / Backend         | layer-shell              | libei                    | windows                  |   macos                                | x11 |
-[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).
+|---------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|-----|
 | Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                                        |     |
 | Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |     |
 | Wayland (Gnome)           |                          | :heavy_check_mark:       |                          |                                        |     |
 | Windows                   |                          |                          | :heavy_check_mark:       |                                        |     |
 | MacOS                     |                          |                          |                          |   :heavy_check_mark:                   |     |
 | X11                       |                          |                          |                          |                                        | WIP |
-#### Gnome
+- `wlroots`: This backend makes use of the [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1) and [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1) protocols and is supported by most wlroots based compositors.
-Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation and capture,
+- `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
-which has the goal to become the general approach for emulating and capturing Input on Wayland.
+- `xdp`: This backend uses the [freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop) and is supported on GNOME and Plasma.
 - `x11`: Backend for X11 sessions.
 - `windows`: Backend for Windows.
 - `macos`: Backend for MacOS.
 ### Input capture
 To capture mouse and keyboard input, a few things are necessary:
 - Displaying an immovable surface at screen edges
 - Locking the mouse in place
 - (optionally but highly recommended) reading unaccelerated mouse input
-|  Required Protocols  (Event Emitting)  | Sway               | Kwin                 | Gnome                |
+### Input Capture Support
 |----------------------------------------|--------------------|----------------------|----------------------|
 | pointer-constraints-unstable-v1        | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
 | relative-pointer-unstable-v1           | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
 | keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
 | wlr-layer-shell-unstable-v1            | :heavy_check_mark: | :heavy_check_mark:   | :x:                  |
-The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
+| Desktop / Backend         | wlroots                  | libei                    | remote-desktop portal    | windows                  |   macos                                | x11                |
-to display surfaces on screen edges and used to display the immovable window on
+|---------------------------|--------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|--------------------|
-both wlroots based compositors and KDE.
+| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                          |                                        |                    |
 | Wayland (KDE)             |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
 | Wayland (Gnome)           |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
 | Windows                   |                          |                          |                          | :heavy_check_mark:       |                                        |                    |
 | MacOS                     |                          |                          |                          |                          |   :heavy_check_mark:                   |                    |
 | X11                       |                          |                          |                          |                          |                                        | :heavy_check_mark: |
 - `layer-shell`: This backend creates a single pixel wide window on the edges of Displays to capture the cursor using the [layer-shell protocol](https://wayland.app/protocols/wlr-layer-shell-unstable-v1).
 - `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
 - `windows`: Backend for input capture on Windows.
 - `macos`: Backend for input capture on MacOS.
 - `x11`: TODO (not yet supported)
 Gnome unfortunately does not support this protocol
 and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).
 ~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
 (this works natively on sway versions >= 1.8)
--- a/default.nix
+++ b/default.nix
@@ -0,0 +1,3 @@
 { pkgs ? import <nixpkgs> { }
 }:
 pkgs.callPackage nix/default.nix { }
--- a/flake.lock
+++ b/flake.lock
@@ -1,30 +1,12 @@
 {
  "nodes": {
    "flake-utils": {
      "inputs": {
        "systems": "systems"
      },
      "locked": {
        "lastModified": 1705309234,
        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
        "owner": "numtide",
        "repo": "flake-utils",
        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
        "type": "github"
      },
      "original": {
        "owner": "numtide",
        "repo": "flake-utils",
        "type": "github"
      }
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1716293225,
+        "lastModified": 1728018373,
-        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
+        "narHash": "sha256-NOiTvBbRLIOe5F6RbHaAh6++BNjsb149fGZd1T4+KBg=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
+        "rev": "bc947f541ae55e999ffdb4013441347d83b00feb",
        "type": "github"
      },
      "original": {
@@ -42,17 +24,16 @@
    },
    "rust-overlay": {
      "inputs": {
        "flake-utils": "flake-utils",
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
-        "lastModified": 1716257780,
+        "lastModified": 1728181869,
-        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
+        "narHash": "sha256-sQXHXsjIcGEoIHkB+RO6BZdrPfB+43V1TEpyoWRI3ww=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
+        "rev": "cd46aa3906c14790ef5cbe278d9e54f2c38f95c0",
        "type": "github"
      },
      "original": {
@@ -60,21 +41,6 @@
        "repo": "rust-overlay",
        "type": "github"
      }
    },
    "systems": {
      "locked": {
        "lastModified": 1681028828,
        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
        "owner": "nix-systems",
        "repo": "default",
        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
        "type": "github"
      },
      "original": {
        "owner": "nix-systems",
        "repo": "default",
        "type": "github"
      }
    }
  },
  "root": "root",
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,10 +10,10 @@ repository = "https://github.com/feschber/lan-mouse"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.3.0" }
 memmap = "0.7"
 tempfile = "3.8"
-thiserror = "1.0.61"
+thiserror = "2.0.0"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -40,18 +40,18 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.2", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }
 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.23", features = ["highsierra"] }
+core-graphics = { version = "0.24.0", features = ["highsierra"] }
-core-foundation = "0.9.4"
+core-foundation = "0.10.0"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
 keycode = "0.4.0"
-bitflags = "2.5.0"
+bitflags = "2.6.0"
 [target.'cfg(windows)'.dependencies]
 windows = { version = "0.58.0", features = [
@@ -65,8 +65,8 @@ windows = { version = "0.58.0", features = [
 ] }
 [features]
-default = ["wayland", "x11", "libei"]
+default = ["layer_shell", "x11", "libei"]
-wayland = [
+layer_shell = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -8,7 +8,7 @@ use futures_core::Stream;
 use input_event::PointerEvent;
 use tokio::time::{self, Instant, Interval};
-use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
+use super::{Capture, CaptureError, CaptureEvent, Position};
 pub struct DummyInputCapture {
    start: Option<Instant>,
@@ -34,11 +34,11 @@ impl Default for DummyInputCapture {
 #[async_trait]
 impl Capture for DummyInputCapture {
-    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }
-    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }
@@ -55,7 +55,7 @@ const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;
 impl Stream for DummyInputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let current = ready!(self.interval.poll_tick(cx));
@@ -81,6 +81,6 @@ impl Stream for DummyInputCapture {
                }))
            }
        };
-        Poll::Ready(Some(Ok((0, event))))
+        Poll::Ready(Some(Ok((Position::Left, event))))
    }
 }
--- a/input-capture/src/error.rs
+++ b/input-capture/src/error.rs
@@ -8,9 +8,9 @@ pub enum InputCaptureError {
    Capture(#[from] CaptureError),
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
 use std::io;
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
@@ -19,26 +19,10 @@ use wayland_client::{
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::desktop::ResponseError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::{EiConvertEventStreamError, HandshakeError};
 #[cfg(target_os = "macos")]
 use core_graphics::base::CGError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("error in libei stream: {inner:?}")]
 pub struct ReisConvertEventStreamError {
    inner: EiConvertEventStreamError,
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
    fn from(e: EiConvertEventStreamError) -> Self {
        Self { inner: e }
    }
 }
 #[derive(Debug, Error)]
 pub enum CaptureError {
    #[error("activation stream closed unexpectedly")]
@@ -48,11 +32,8 @@ pub enum CaptureError {
    #[error("io error: `{0}`")]
    Io(#[from] std::io::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("error in libei stream: `{0}`")]
+    #[error("libei error: `{0}`")]
-    Reis(#[from] ReisConvertEventStreamError),
+    Reis(#[from] reis::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei handshake failed: `{0}`")]
    Handshake(#[from] HandshakeError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error(transparent)]
    Portal(#[from] ashpd::Error),
@@ -83,7 +64,7 @@ pub enum CaptureCreationError {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("error creating input-capture-portal backend: `{0}`")]
    Libei(#[from] LibeiCaptureCreationError),
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
    #[error("error creating layer-shell capture backend: `{0}`")]
    LayerShell(#[from] LayerShellCaptureCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -93,7 +74,7 @@ pub enum CaptureCreationError {
    #[error("error creating windows capture backend")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[error("error creating macos capture backend")]
+    #[error("error creating macos capture backend: `{0}`")]
    MacOS(#[from] MacosCaptureCreationError),
 }
@@ -121,7 +102,7 @@ pub enum LibeiCaptureCreationError {
    Ashpd(#[from] ashpd::Error),
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("{protocol} protocol not supported: {inner}")]
 pub struct WaylandBindError {
@@ -129,14 +110,14 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "layer_shell", 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")))]
+#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LayerShellCaptureCreationError {
    #[error(transparent)]
@@ -165,6 +146,9 @@ pub enum X11InputCaptureCreationError {
 pub enum MacosCaptureCreationError {
    #[error("event source creation failed!")]
    EventSourceCreation,
    #[cfg(target_os = "macos")]
    #[error("event tap creation failed")]
    EventTapCreation,
    #[error("failed to set CG Cursor property")]
    CGCursorProperty,
    #[cfg(target_os = "macos")]
--- a/input-capture/src/layer_shell.rs
+++ b/input-capture/src/layer_shell.rs
@@ -64,7 +64,7 @@ use crate::{CaptureError, CaptureEvent};
 use super::{
    error::{LayerShellCaptureCreationError, WaylandBindError},
-    Capture, CaptureHandle, Position,
+    Capture, Position,
 };
 struct Globals {
@@ -102,13 +102,13 @@ struct State {
    pointer_lock: Option<ZwpLockedPointerV1>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
+    active_windows: Vec<Arc<Window>>,
-    focused: Option<(Arc<Window>, CaptureHandle)>,
+    focused: Option<Arc<Window>>,
    g: Globals,
    wayland_fd: RawFd,
    read_guard: Option<ReadEventsGuard>,
    qh: QueueHandle<Self>,
-    pending_events: VecDeque<(CaptureHandle, CaptureEvent)>,
+    pending_events: VecDeque<(Position, CaptureEvent)>,
    output_info: Vec<(WlOutput, OutputInfo)>,
    scroll_discrete_pending: bool,
 }
@@ -124,7 +124,7 @@ impl AsRawFd for Inner {
    }
 }
-pub struct WaylandInputCapture(AsyncFd<Inner>);
+pub struct LayerShellInputCapture(AsyncFd<Inner>);
 struct Window {
    buffer: wl_buffer::WlBuffer,
@@ -256,7 +256,7 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
    }
 }
-impl WaylandInputCapture {
+impl LayerShellInputCapture {
    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
        let conn = Connection::connect_to_env()?;
        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
@@ -323,7 +323,7 @@ impl WaylandInputCapture {
            pointer_lock: None,
            rel_pointer: None,
            shortcut_inhibitor: None,
-            client_for_window: Vec::new(),
+            active_windows: Vec::new(),
            focused: None,
            qh,
            wayland_fd,
@@ -370,23 +370,18 @@ impl WaylandInputCapture {
        let inner = AsyncFd::new(Inner { queue, state })?;
-        Ok(WaylandInputCapture(inner))
+        Ok(LayerShellInputCapture(inner))
    }
-    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+    fn add_client(&mut self, pos: Position) {
-        self.0.get_mut().state.add_client(handle, pos);
+        self.0.get_mut().state.add_client(pos);
    }
-    fn delete_client(&mut self, handle: CaptureHandle) {
+    fn delete_client(&mut self, pos: Position) {
        let inner = self.0.get_mut();
        // remove all windows corresponding to this client
-        while let Some(i) = inner
+        while let Some(i) = inner.state.active_windows.iter().position(|w| w.pos == pos) {
-            .state
+            inner.state.active_windows.remove(i);
            .client_for_window
            .iter()
            .position(|(_, c)| *c == handle)
        {
            inner.state.client_for_window.remove(i);
            inner.state.focused = None;
        }
    }
@@ -400,7 +395,7 @@ impl State {
        serial: u32,
        qh: &QueueHandle<State>,
    ) {
-        let (window, _) = self.focused.as_ref().unwrap();
+        let window = self.focused.as_ref().unwrap();
        // hide the cursor
        pointer.set_cursor(serial, None, 0, 0);
@@ -443,7 +438,7 @@ impl State {
    fn ungrab(&mut self) {
        // get focused client
-        let (window, _client) = match self.focused.as_ref() {
+        let window = match self.focused.as_ref() {
            Some(focused) => focused,
            None => return,
        };
@@ -473,27 +468,23 @@ impl State {
        }
    }
-    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
+    fn add_client(&mut self, 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 = Arc::new(window);
-            self.client_for_window.push((window, client));
+            self.active_windows.push(window);
        });
    }
    fn update_windows(&mut self) {
        log::debug!("updating windows");
        log::debug!("output info: {:?}", self.output_info);
-        let clients: Vec<_> = self
+        let clients: Vec<_> = self.active_windows.drain(..).map(|w| w.pos).collect();
-            .client_for_window
+        for pos in clients {
-            .drain(..)
+            self.add_client(pos);
            .map(|(w, c)| (c, w.pos))
            .collect();
        for (client, pos) in clients {
            self.add_client(client, pos);
        }
    }
 }
@@ -566,15 +557,15 @@ impl Inner {
 }
 #[async_trait]
-impl Capture for WaylandInputCapture {
+impl Capture for LayerShellInputCapture {
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.add_client(handle, pos);
+        self.add_client(pos);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }
-    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.delete_client(handle);
+        self.delete_client(pos);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }
@@ -591,8 +582,8 @@ impl Capture for WaylandInputCapture {
    }
 }
-impl Stream for WaylandInputCapture {
+impl Stream for LayerShellInputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    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() {
@@ -657,10 +648,16 @@ impl Dispatch<wl_seat::WlSeat, ()> for State {
            capabilities: WEnum::Value(capabilities),
        } = event
        {
-            if capabilities.contains(wl_seat::Capability::Pointer) && state.pointer.is_none() {
+            if capabilities.contains(wl_seat::Capability::Pointer) {
                if let Some(p) = state.pointer.take() {
                    p.release();
                }
                state.pointer.replace(seat.get_pointer(qh, ()));
            }
-            if capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
+            if capabilities.contains(wl_seat::Capability::Keyboard) {
                if let Some(k) = state.keyboard.take() {
                    k.release();
                }
                seat.get_keyboard(qh, ());
            }
        }
@@ -685,23 +682,20 @@ impl Dispatch<WlPointer, ()> for State {
            } => {
                // get client corresponding to the focused surface
                {
-                    if let Some((window, client)) = app
+                    if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
-                        .client_for_window
+                        app.focused = Some(window.clone());
                        .iter()
                        .find(|(w, _c)| w.surface == surface)
                    {
                        app.focused = Some((window.clone(), *client));
                        app.grab(&surface, pointer, serial, qh);
                    } else {
                        return;
                    }
                }
-                let (_, client) = app
+                let pos = app
-                    .client_for_window
+                    .active_windows
                    .iter()
-                    .find(|(w, _c)| w.surface == surface)
+                    .find(|w| w.surface == surface)
                    .map(|w| w.pos)
                    .unwrap();
-                app.pending_events.push_back((*client, CaptureEvent::Begin));
+                app.pending_events.push_back((pos, CaptureEvent::Begin));
            }
            wl_pointer::Event::Leave { .. } => {
                /* There are rare cases, where when a window is opened in
@@ -722,9 +716,9 @@ impl Dispatch<WlPointer, ()> for State {
                button,
                state,
            } => {
-                let (_, client) = app.focused.as_ref().unwrap();
+                let window = app.focused.as_ref().unwrap();
                app.pending_events.push_back((
-                    *client,
+                    window.pos,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                        time,
                        button,
@@ -733,7 +727,7 @@ impl Dispatch<WlPointer, ()> for State {
                ));
            }
            wl_pointer::Event::Axis { time, axis, value } => {
-                let (_, client) = app.focused.as_ref().unwrap();
+                let window = app.focused.as_ref().unwrap();
                if app.scroll_discrete_pending {
                    // each axisvalue120 event is coupled with
                    // a corresponding axis event, which needs to
@@ -741,7 +735,7 @@ impl Dispatch<WlPointer, ()> for State {
                    app.scroll_discrete_pending = false;
                } else {
                    app.pending_events.push_back((
-                        *client,
+                        window.pos,
                        CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
                            time,
                            axis: u32::from(axis) as u8,
@@ -751,10 +745,10 @@ impl Dispatch<WlPointer, ()> for State {
                }
            }
            wl_pointer::Event::AxisValue120 { axis, value120 } => {
-                let (_, client) = app.focused.as_ref().unwrap();
+                let window = app.focused.as_ref().unwrap();
                app.scroll_discrete_pending = true;
                app.pending_events.push_back((
-                    *client,
+                    window.pos,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
                        axis: u32::from(axis) as u8,
                        value: value120,
@@ -780,10 +774,7 @@ impl Dispatch<WlKeyboard, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        let (_window, client) = match &app.focused {
+        let window = &app.focused;
            Some(focused) => (Some(&focused.0), Some(&focused.1)),
            None => (None, None),
        };
        match event {
            wl_keyboard::Event::Key {
                serial: _,
@@ -791,9 +782,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                key,
                state,
            } => {
-                if let Some(client) = client {
+                if let Some(window) = window {
                    app.pending_events.push_back((
-                        *client,
+                        window.pos,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
                            time,
                            key,
@@ -809,9 +800,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                mods_locked,
                group,
            } => {
-                if let Some(client) = client {
+                if let Some(window) = window {
                    app.pending_events.push_back((
-                        *client,
+                        window.pos,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
                            depressed: mods_depressed,
                            latched: mods_latched,
@@ -843,10 +834,10 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
            ..
        } = event
        {
-            if let Some((_window, client)) = &app.focused {
+            if let Some(window) = &app.focused {
                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                app.pending_events.push_back((
-                    *client,
+                    window.pos,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
                ));
            }
@@ -864,10 +855,10 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
        _: &QueueHandle<Self>,
    ) {
        if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
-            if let Some((window, _client)) = app
+            if let Some(window) = app
-                .client_for_window
+                .active_windows
                .iter()
-                .find(|(w, _c)| &w.layer_surface == layer_surface)
+                .find(|w| &w.layer_surface == layer_surface)
            {
                // client corresponding to the layer_surface
                let surface = &window.surface;
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,4 +1,9 @@
-use std::{collections::HashSet, fmt::Display, task::Poll};
+use std::{
    collections::{HashMap, HashSet, VecDeque},
    fmt::Display,
    mem::swap,
    task::{ready, Poll},
 };
 use async_trait::async_trait;
 use futures::StreamExt;
@@ -16,8 +21,8 @@ mod libei;
 #[cfg(target_os = "macos")]
 mod macos;
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-mod wayland;
+mod layer_shell;
 #[cfg(windows)]
 mod windows;
@@ -82,7 +87,7 @@ impl Display for Position {
 pub enum Backend {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
    LayerShell,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -98,7 +103,7 @@ impl Display for Backend {
        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")))]
+            #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
            Backend::LayerShell => write!(f, "layer-shell"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -112,19 +117,52 @@ impl Display for Backend {
 }
 pub struct InputCapture {
    /// capture backend
    capture: Box<dyn Capture>,
    /// keys pressed by active capture
    pressed_keys: HashSet<scancode::Linux>,
    /// map from position to ids
    position_map: HashMap<Position, Vec<CaptureHandle>>,
    /// map from id to position
    id_map: HashMap<CaptureHandle, Position>,
    /// pending events
    pending: VecDeque<(CaptureHandle, CaptureEvent)>,
 }
 impl InputCapture {
    /// create a new client with the given id
    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
-        self.capture.create(id, pos).await
+        assert!(!self.id_map.contains_key(&id));
        self.id_map.insert(id, pos);
        if let Some(v) = self.position_map.get_mut(&pos) {
            v.push(id);
            Ok(())
        } else {
            self.position_map.insert(pos, vec![id]);
            self.capture.create(pos).await
        }
    }
    /// destroy the client with the given id, if it exists
    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
-        self.capture.destroy(id).await
+        let pos = self
            .id_map
            .remove(&id)
            .expect("no position for this handle");
        log::debug!("destroying capture {id} @ {pos}");
        let remaining = self.position_map.get_mut(&pos).expect("id vector");
        remaining.retain(|&i| i != id);
        log::debug!("remaining ids @ {pos}: {remaining:?}");
        if remaining.is_empty() {
            log::debug!("destroying capture @ {pos} - no remaining ids");
            self.position_map.remove(&pos);
            self.capture.destroy(pos).await?;
        }
        Ok(())
    }
    /// release mouse
@@ -143,6 +181,9 @@ impl InputCapture {
        let capture = create(backend).await?;
        Ok(Self {
            capture,
            id_map: Default::default(),
            pending: Default::default(),
            position_map: Default::default(),
            pressed_keys: HashSet::new(),
        })
    }
@@ -170,29 +211,65 @@ impl Stream for InputCapture {
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> Poll<Option<Self::Item>> {
-        match self.capture.poll_next_unpin(cx) {
+        if let Some(e) = self.pending.pop_front() {
-            Poll::Ready(e) => {
+            return Poll::Ready(Some(Ok(e)));
-                if let Some(Ok((
+        }
-                    _,
+
-                    CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })),
+        // ready
-                ))) = e
+        let event = ready!(self.capture.poll_next_unpin(cx));
        // stream closed
        let event = match event {
            Some(e) => e,
            None => return Poll::Ready(None),
        };
        // error occurred
        let (pos, event) = match event {
            Ok(e) => e,
            Err(e) => return Poll::Ready(Some(Err(e))),
        };
        // handle key presses
        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
            self.update_pressed_keys(key, state);
        }
        let len = self
            .position_map
            .get(&pos)
            .map(|ids| ids.len())
            .unwrap_or(0);
        match len {
            0 => Poll::Pending,
            1 => Poll::Ready(Some(Ok((
                self.position_map.get(&pos).expect("no id")[0],
                event,
            )))),
            _ => {
                let mut position_map = HashMap::new();
                swap(&mut self.position_map, &mut position_map);
                {
-                    self.update_pressed_keys(key, state);
+                    for &id in position_map.get(&pos).expect("position") {
                        self.pending.push_back((id, event));
                    }
                }
-                Poll::Ready(e)
+                swap(&mut self.position_map, &mut position_map);
                Poll::Ready(Some(Ok(self.pending.pop_front().expect("event"))))
            }
            Poll::Pending => Poll::Pending,
        }
    }
 }
 #[async_trait]
-trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>> + Unpin {
+trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + Unpin {
    /// create a new client with the given id
-    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
+    async fn create(&mut self, pos: Position) -> Result<(), CaptureError>;
    /// destroy the client with the given id, if it exists
-    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;
+    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
    /// release mouse
    async fn release(&mut self) -> Result<(), CaptureError>;
@@ -204,14 +281,14 @@ trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>
 async fn create_backend(
    backend: Backend,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
    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")))]
+        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
+        Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
        #[cfg(windows)]
@@ -225,7 +302,7 @@ async fn create_backend(
 async fn create(
    backend: Option<Backend>,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
    CaptureCreationError,
 > {
    if let Some(backend) = backend {
@@ -239,7 +316,7 @@ async fn create(
    for backend in [
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal,
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
        Backend::LayerShell,
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11,
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -1,6 +1,9 @@
 use ashpd::{
    desktop::{
-        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
+        input_capture::{
            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
            Zones,
        },
        Session,
    },
    enumflags2::BitFlags,
@@ -8,14 +11,15 @@ use ashpd::{
 use async_trait::async_trait;
 use futures::{FutureExt, StreamExt};
 use reis::{
-    ei,
+    ei::{self, handshake::ContextType},
-    event::{DeviceCapability, EiEvent},
+    event::{Connection, DeviceCapability, EiEvent},
-    tokio::{EiConvertEventStream, EiEventStream},
+    tokio::EiConvertEventStream,
 };
 use std::{
    cell::Cell,
    collections::HashMap,
    io,
    num::NonZeroU32,
    os::unix::net::UnixStream,
    pin::Pin,
    rc::Rc,
@@ -32,15 +36,14 @@ use tokio::{
 use tokio_util::sync::CancellationToken;
 use futures_core::Stream;
 use once_cell::sync::Lazy;
 use input_event::Event;
 use crate::CaptureEvent;
 use super::{
-    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    error::{CaptureError, LibeiCaptureCreationError},
-    Capture as LanMouseInputCapture, CaptureHandle, Position,
+    Capture as LanMouseInputCapture, Position,
 };
 /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
@@ -50,37 +53,21 @@ use super::{
 /// events that necessitate restarting the capture session
 #[derive(Clone, Copy, Debug)]
 enum LibeiNotifyEvent {
-    Create(CaptureHandle, Position),
+    Create(Position),
-    Destroy(CaptureHandle),
+    Destroy(Position),
 }
 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
    input_capture: Pin<Box<InputCapture<'a>>>,
    capture_task: JoinHandle<Result<(), CaptureError>>,
-    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
+    event_rx: Receiver<(Position, CaptureEvent)>,
    notify_capture: Sender<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    cancellation_token: CancellationToken,
    terminated: bool,
 }
 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
 });
 /// returns (start pos, end pos), inclusive
 fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
    let (x, y) = (r.x_offset(), r.y_offset());
@@ -117,35 +104,37 @@ impl From<ICBarrier> for Barrier {
 fn select_barriers(
    zones: &Zones,
-    clients: &[(CaptureHandle, Position)],
+    clients: &[Position],
-    next_barrier_id: &mut u32,
+    next_barrier_id: &mut NonZeroU32,
-) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
+) -> (Vec<ICBarrier>, HashMap<BarrierID, Position>) {
-    let mut client_for_barrier = HashMap::new();
+    let mut pos_for_barrier = HashMap::new();
    let mut barriers: Vec<ICBarrier> = vec![];
-    for (handle, pos) in clients {
+    for pos in clients {
        let mut client_barriers = zones
            .regions()
            .iter()
            .map(|r| {
                let id = *next_barrier_id;
-                *next_barrier_id = id + 1;
+                *next_barrier_id = next_barrier_id
                    .checked_add(1)
                    .expect("barrier id out of range");
                let position = pos_to_barrier(r, *pos);
-                client_for_barrier.insert(id, *handle);
+                pos_for_barrier.insert(id, *pos);
                ICBarrier::new(id, position)
            })
            .collect();
        barriers.append(&mut client_barriers);
    }
-    (barriers, client_for_barrier)
+    (barriers, pos_for_barrier)
 }
 async fn update_barriers(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-    active_clients: &[(CaptureHandle, Position)],
+    active_clients: &[Position],
-    next_barrier_id: &mut u32,
+    next_barrier_id: &mut NonZeroU32,
-) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
+) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
    let zones = input_capture.zones(session).await?.response()?;
    log::debug!("zones: {zones:?}");
@@ -168,7 +157,7 @@ async fn create_session<'a>(
    log::debug!("creating input capture session");
    input_capture
        .create_session(
-            &ashpd::WindowIdentifier::default(),
+            None,
            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
        )
        .await
@@ -177,7 +166,7 @@ async fn create_session<'a>(
 async fn connect_to_eis(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
+) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
    log::debug!("connect_to_eis");
    let fd = input_capture.connect_to_eis(session).await?;
@@ -187,34 +176,27 @@ async fn connect_to_eis(
    // create ei context
    let context = ei::Context::new(stream)?;
-    let mut event_stream = EiEventStream::new(context.clone())?;
+    let (conn, event_stream) = context
-    let response = reis::tokio::ei_handshake(
+        .handshake_tokio("de.feschber.LanMouse", ContextType::Receiver)
-        &mut event_stream,
+        .await?;
        "de.feschber.LanMouse",
        ei::handshake::ContextType::Receiver,
        &INTERFACES,
    )
    .await?;
    let event_stream = EiConvertEventStream::new(event_stream, response.serial);
-    Ok((context, event_stream))
+    Ok((context, conn, event_stream))
 }
 async fn libei_event_handler(
    mut ei_event_stream: EiConvertEventStream,
    context: ei::Context,
-    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
+    event_tx: Sender<(Position, CaptureEvent)>,
    release_session: Arc<Notify>,
-    current_client: Rc<Cell<Option<CaptureHandle>>>,
+    current_pos: Rc<Cell<Option<Position>>>,
 ) -> Result<(), CaptureError> {
    loop {
        let ei_event = ei_event_stream
            .next()
            .await
-            .ok_or(CaptureError::EndOfStream)?
+            .ok_or(CaptureError::EndOfStream)??;
            .map_err(ReisConvertEventStreamError::from)?;
        log::trace!("from ei: {ei_event:?}");
-        let client = current_client.get();
+        let client = current_pos.get();
        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
    }
 }
@@ -260,15 +242,15 @@ async fn do_capture(
    mut capture_event: Receiver<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
-    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
+    event_tx: Sender<(Position, CaptureEvent)>,
    cancellation_token: CancellationToken,
 ) -> Result<(), CaptureError> {
    let mut session = session.map(|s| s.0);
    /* safety: libei_task does not outlive Self */
    let input_capture = unsafe { &*input_capture };
-    let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+    let mut active_clients: Vec<Position> = vec![];
-    let mut next_barrier_id = 1u32;
+    let mut next_barrier_id = NonZeroU32::new(1).expect("id must be non-zero");
    let mut zones_changed = input_capture.receive_zones_changed().await?;
@@ -341,8 +323,8 @@ async fn do_capture(
        // update clients if requested
        if let Some(event) = capture_event_occured.take() {
            match event {
-                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
+                LibeiNotifyEvent::Create(p) => active_clients.push(p),
-                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
+                LibeiNotifyEvent::Destroy(p) => active_clients.retain(|&pos| pos != p),
            }
        }
@@ -356,21 +338,21 @@ async fn do_capture(
 async fn do_capture_session(
    input_capture: &InputCapture<'_>,
    session: &mut Session<'_, InputCapture<'_>>,
-    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
+    event_tx: &Sender<(Position, CaptureEvent)>,
-    active_clients: &[(CaptureHandle, Position)],
+    active_clients: &[Position],
-    next_barrier_id: &mut u32,
+    next_barrier_id: &mut NonZeroU32,
    notify_release: &Notify,
    cancel: (CancellationToken, CancellationToken),
 ) -> Result<(), CaptureError> {
    let (cancel_session, cancel_update) = cancel;
    // current client
-    let current_client = Rc::new(Cell::new(None));
+    let current_pos = Rc::new(Cell::new(None));
    // connect to eis server
-    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;
+    let (context, _conn, ei_event_stream) = connect_to_eis(input_capture, session).await?;
    // set barriers
-    let (barriers, client_for_barrier_id) =
+    let (barriers, pos_for_barrier_id) =
        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
    log::debug!("enabling session");
@@ -382,7 +364,7 @@ async fn do_capture_session(
    // async event task
    let cancel_ei_handler = CancellationToken::new();
    let event_chan = event_tx.clone();
-    let client = current_client.clone();
+    let pos = current_pos.clone();
    let cancel_session_clone = cancel_session.clone();
    let release_session_clone = release_session.clone();
    let cancel_ei_handler_clone = cancel_ei_handler.clone();
@@ -393,7 +375,7 @@ async fn do_capture_session(
                context,
                event_chan,
                release_session_clone,
-                client,
+                pos,
            ) => {
                log::debug!("libei exited: {r:?} cancelling session task");
                cancel_session_clone.cancel();
@@ -415,17 +397,17 @@ async fn do_capture_session(
                    // get barrier id from activation
                    let barrier_id = match activated.barrier_id() {
-                        Some(bid) => bid,
+                        Some(ActivatedBarrier::Barrier(id)) => id,
                        // workaround for KDE plasma not reporting barrier ids
-                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
+                        Some(ActivatedBarrier::UnknownBarrier) | None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
                    };
                    // find client corresponding to barrier
-                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
+                    let pos = *pos_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
-                    current_client.replace(Some(client));
+                    current_pos.replace(Some(pos));
                    // client entered => send event
-                    event_tx.send((client, CaptureEvent::Begin)).await.expect("no channel");
+                    event_tx.send((pos, CaptureEvent::Begin)).await.expect("no channel");
                    tokio::select! {
                        _ = notify_release.notified() => { /* capture release */
@@ -441,7 +423,7 @@ async fn do_capture_session(
                        },
                    }
-                    release_capture(input_capture, session, activated, client, active_clients).await?;
+                    release_capture(input_capture, session, activated, pos).await?;
                }
                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
@@ -484,8 +466,7 @@ async fn release_capture<'a>(
    input_capture: &InputCapture<'a>,
    session: &Session<'a, InputCapture<'a>>,
    activated: Activated,
-    current_client: CaptureHandle,
+    current_pos: Position,
    active_clients: &[(CaptureHandle, Position)],
 ) -> Result<(), CaptureError> {
    if let Some(activation_id) = activated.activation_id() {
        log::debug!("releasing input capture {activation_id}");
@@ -494,13 +475,7 @@ async fn release_capture<'a>(
        .cursor_position()
        .expect("compositor did not report cursor position!");
    log::debug!("client entered @ ({x}, {y})");
-    let pos = active_clients
+    let (dx, dy) = match current_pos {
        .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.),
@@ -554,9 +529,9 @@ static ALL_CAPABILITIES: &[DeviceCapability] = &[
 async fn handle_ei_event(
    ei_event: EiEvent,
-    current_client: Option<CaptureHandle>,
+    current_client: Option<Position>,
    context: &ei::Context,
-    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
+    event_tx: &Sender<(Position, CaptureEvent)>,
    release_session: &Notify,
 ) -> Result<(), CaptureError> {
    match ei_event {
@@ -575,9 +550,9 @@ async fn handle_ei_event(
            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
        }
        _ => {
-            if let Some(handle) = current_client {
+            if let Some(pos) = current_client {
                for event in Event::from_ei_event(ei_event) {
-                    event_tx.send((handle, CaptureEvent::Input(event))).await.expect("no channel");
+                    event_tx.send((pos, CaptureEvent::Input(event))).await.expect("no channel");
                }
            }
        }
@@ -587,18 +562,18 @@ async fn handle_ei_event(
 #[async_trait]
 impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Create(handle, pos))
+            .send(LibeiNotifyEvent::Create(pos))
            .await;
        Ok(())
    }
-    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Destroy(handle))
+            .send(LibeiNotifyEvent::Destroy(pos))
            .await;
        Ok(())
    }
@@ -629,7 +604,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {
 }
 impl<'a> Stream for LibeiInputCapture<'a> {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match self.capture_task.poll_unpin(cx) {
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -1,6 +1,4 @@
-use super::{
+use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
    error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle, Position,
 };
 use async_trait::async_trait;
 use bitflags::bitflags;
 use core_foundation::base::{kCFAllocatorDefault, CFRelease};
@@ -20,14 +18,14 @@ use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::ffi::{c_char, CString};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{ready, Context, Poll};
 use std::thread::{self};
-use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::mpsc::{self, Receiver, Sender};
-use tokio::sync::Mutex;
+use tokio::sync::{oneshot, Mutex};
 #[derive(Debug, Default)]
 struct Bounds {
@@ -39,44 +37,44 @@ struct Bounds {
 #[derive(Debug)]
 struct InputCaptureState {
-    client_for_pos: Lazy<HashMap<Position, CaptureHandle>>,
+    active_clients: Lazy<HashSet<Position>>,
-    current_client: Option<(CaptureHandle, Position)>,
+    current_pos: Option<Position>,
    bounds: Bounds,
 }
 #[derive(Debug)]
 enum ProducerEvent {
    Release,
-    Create(CaptureHandle, Position),
+    Create(Position),
-    Destroy(CaptureHandle),
+    Destroy(Position),
-    Grab((CaptureHandle, Position)),
+    Grab(Position),
    EventTapDisabled,
 }
 impl InputCaptureState {
    fn new() -> Result<Self, MacosCaptureCreationError> {
        let mut res = Self {
-            client_for_pos: Lazy::new(HashMap::new),
+            active_clients: Lazy::new(HashSet::new),
-            current_client: None,
+            current_pos: None,
            bounds: Bounds::default(),
        };
        res.update_bounds()?;
        Ok(res)
    }
-    fn crossed(&mut self, event: &CGEvent) -> Option<(CaptureHandle, Position)> {
+    fn crossed(&mut self, event: &CGEvent) -> Option<Position> {
        let location = event.location();
        let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
        let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);
-        for (position, client) in self.client_for_pos.iter() {
+        for &position in self.active_clients.iter() {
-            if (position == &Position::Left && (location.x + relative_x) <= self.bounds.xmin)
+            if (position == Position::Left && (location.x + relative_x) <= self.bounds.xmin)
-                || (position == &Position::Right && (location.x + relative_x) >= self.bounds.xmax)
+                || (position == Position::Right && (location.x + relative_x) >= self.bounds.xmax)
-                || (position == &Position::Top && (location.y + relative_y) <= self.bounds.ymin)
+                || (position == Position::Top && (location.y + relative_y) <= self.bounds.ymin)
-                || (position == &Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
+                || (position == Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
            {
-                log::debug!("Crossed barrier into client: {client}, {position:?}");
+                log::debug!("Crossed barrier into position: {position:?}");
-                return Some((*client, *position));
+                return Some(position);
            }
        }
        None
@@ -102,7 +100,7 @@ impl InputCaptureState {
    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
    // random location when we exit the client
    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
-        if let Some((_, pos)) = self.current_client {
+        if let Some(pos) = self.current_pos {
            let location = event.location();
            let edge_offset = 1.0;
@@ -146,40 +144,31 @@ impl InputCaptureState {
        log::debug!("handling event: {producer_event:?}");
        match producer_event {
            ProducerEvent::Release => {
-                if self.current_client.is_some() {
+                if self.current_pos.is_some() {
                    CGDisplay::show_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_client = None;
+                    self.current_pos = None;
                }
            }
-            ProducerEvent::Grab(client) => {
+            ProducerEvent::Grab(pos) => {
-                if self.current_client.is_none() {
+                if self.current_pos.is_none() {
                    CGDisplay::hide_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_client = Some(client);
+                    self.current_pos = Some(pos);
                }
            }
-            ProducerEvent::Create(c, p) => {
+            ProducerEvent::Create(p) => {
-                self.client_for_pos.insert(p, c);
+                self.active_clients.insert(p);
            }
-            ProducerEvent::Destroy(c) => {
+            ProducerEvent::Destroy(p) => {
-                for pos in [
+                if let Some(current) = self.current_pos {
-                    Position::Left,
+                    if current == p {
-                    Position::Right,
+                        CGDisplay::show_cursor(&CGDisplay::main())
-                    Position::Top,
+                            .map_err(CaptureError::CoreGraphics)?;
-                    Position::Bottom,
+                        self.current_pos = None;
-                ] {
+                    };
                    if let Some((current_c, _)) = self.current_client {
                        if current_c == c {
                            CGDisplay::show_cursor(&CGDisplay::main())
                                .map_err(CaptureError::CoreGraphics)?;
                            self.current_client = None;
                        };
                    }
                    if self.client_for_pos.get(&pos).copied() == Some(c) {
                        self.client_for_pos.remove(&pos);
                    }
                }
                self.active_clients.remove(&p);
            }
            ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
        };
@@ -333,12 +322,11 @@ fn get_events(
    Ok(())
 }
-fn event_tap_thread(
+fn create_event_tap<'a>(
    client_state: Arc<Mutex<InputCaptureState>>,
    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    exit: tokio::sync::oneshot::Sender<Result<(), &'static str>>,
+    event_tx: Sender<(Position, CaptureEvent)>,
-) {
+) -> Result<CGEventTap<'a>, MacosCaptureCreationError> {
    let cg_events_of_interest: Vec<CGEventType> = vec![
        CGEventType::LeftMouseDown,
        CGEventType::LeftMouseUp,
@@ -356,15 +344,11 @@ fn event_tap_thread(
        CGEventType::FlagsChanged,
    ];
-    let tap = CGEventTap::new(
+    let event_tap_callback =
-        CGEventTapLocation::Session,
+        move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
        CGEventTapPlacement::HeadInsertEventTap,
        CGEventTapOptions::Default,
        cg_events_of_interest,
        |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
            log::trace!("Got event from tap: {event_type:?}");
            let mut state = client_state.blocking_lock();
-            let mut client = None;
+            let mut pos = None;
            let mut res_events = vec![];
            if matches!(
@@ -380,8 +364,8 @@ fn event_tap_thread(
            }
            // Are we in a client?
-            if let Some((current_client, _)) = state.current_client {
+            if let Some(current_pos) = state.current_pos {
-                client = Some(current_client);
+                pos = Some(current_pos);
                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
                    log::error!("Failed to get events: {e}");
                });
@@ -395,19 +379,19 @@ fn event_tap_thread(
            }
            // Did we cross a barrier?
            else if matches!(event_type, CGEventType::MouseMoved) {
-                if let Some((new_client, pos)) = state.crossed(cg_ev) {
+                if let Some(new_pos) = state.crossed(cg_ev) {
-                    client = Some(new_client);
+                    pos = Some(new_pos);
                    res_events.push(CaptureEvent::Begin);
                    notify_tx
-                        .blocking_send(ProducerEvent::Grab((new_client, pos)))
+                        .blocking_send(ProducerEvent::Grab(new_pos))
                        .expect("Failed to send notification");
                }
            }
-            if let Some(client) = client {
+            if let Some(pos) = pos {
                res_events.iter().for_each(|e| {
                    event_tx
-                        .blocking_send((client, *e))
+                        .blocking_send((pos, *e))
                        .expect("Failed to send event");
                });
                // Returning None should stop the event from being processed
@@ -415,9 +399,16 @@ fn event_tap_thread(
                cg_ev.set_type(CGEventType::Null);
            }
            Some(cg_ev.to_owned())
-        },
+        };
    let tap = CGEventTap::new(
        CGEventTapLocation::Session,
        CGEventTapPlacement::HeadInsertEventTap,
        CGEventTapOptions::Default,
        cg_events_of_interest,
        event_tap_callback,
    )
-    .expect("Failed creating tap");
+    .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
    let tap_source: CFRunLoopSource = tap
        .mach_port
@@ -428,22 +419,43 @@ fn event_tap_thread(
        CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
    }
    Ok(tap)
 }
 fn event_tap_thread(
    client_state: Arc<Mutex<InputCaptureState>>,
    event_tx: Sender<(Position, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
    exit: oneshot::Sender<Result<(), &'static str>>,
 ) {
    let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
        Err(e) => {
            ready.send(Err(e)).expect("channel closed");
            return;
        }
        Ok(tap) => {
            ready.send(Ok(())).expect("channel closed");
            tap
        }
    };
    CFRunLoop::run_current();
    let _ = exit.send(Err("tap thread exited"));
 }
 pub struct MacOSInputCapture {
-    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
+    event_rx: Receiver<(Position, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
 }
 impl MacOSInputCapture {
    pub async fn new() -> Result<Self, MacosCaptureCreationError> {
        let state = Arc::new(Mutex::new(InputCaptureState::new()?));
-        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (event_tx, event_rx) = mpsc::channel(32);
-        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_tx, mut notify_rx) = mpsc::channel(32);
-        let (tap_exit_tx, mut tap_exit_rx) = tokio::sync::oneshot::channel();
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel();
        let (tap_exit_tx, mut tap_exit_rx) = oneshot::channel();
        unsafe {
            configure_cf_settings()?;
@@ -457,10 +469,14 @@ impl MacOSInputCapture {
                event_tap_thread_state,
                event_tx,
                event_tap_notify,
                ready_tx,
                tap_exit_tx,
            )
        });
        // wait for event tap creation result
        ready_rx.recv().expect("channel closed")?;
        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
            loop {
                tokio::select! {
@@ -491,21 +507,21 @@ impl MacOSInputCapture {
 #[async_trait]
 impl Capture for MacOSInputCapture {
-    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("creating client {id}, {pos}");
+            log::debug!("creating capture, {pos}");
-            let _ = notify_tx.send(ProducerEvent::Create(id, pos)).await;
+            let _ = notify_tx.send(ProducerEvent::Create(pos)).await;
            log::debug!("done !");
        });
        Ok(())
    }
-    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("destroying client {id}");
+            log::debug!("destroying capture {pos}");
-            let _ = notify_tx.send(ProducerEvent::Destroy(id)).await;
+            let _ = notify_tx.send(ProducerEvent::Destroy(pos)).await;
            log::debug!("done !");
        });
        Ok(())
@@ -526,7 +542,7 @@ impl Capture for MacOSInputCapture {
 }
 impl Stream for MacOSInputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -3,12 +3,12 @@ use core::task::{Context, Poll};
 use futures::Stream;
 use once_cell::unsync::Lazy;
-use std::collections::HashMap;
+use std::collections::HashSet;
 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::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::sync::{mpsc, Mutex};
 use std::task::ready;
 use std::{pin::Pin, thread};
@@ -37,15 +37,15 @@ use input_event::{
    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
-use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
+use super::{Capture, CaptureError, CaptureEvent, Position};
 enum Request {
-    Create(CaptureHandle, Position),
+    Create(Position),
-    Destroy(CaptureHandle),
+    Destroy(Position),
 }
 pub struct WindowsInputCapture {
-    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
+    event_rx: Receiver<(Position, CaptureEvent)>,
    msg_thread: Option<std::thread::JoinHandle<()>>,
 }
@@ -65,22 +65,22 @@ unsafe fn signal_message_thread(event_type: EventType) {
 #[async_trait]
 impl Capture for WindowsInputCapture {
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Create(handle, pos));
+                requests.push(Request::Create(pos));
            }
            signal_message_thread(EventType::Request);
        }
        Ok(())
    }
-    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Destroy(handle));
+                requests.push(Request::Destroy(pos));
            }
            signal_message_thread(EventType::Request);
        }
@@ -98,9 +98,9 @@ impl Capture for WindowsInputCapture {
 }
 static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
-static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut ACTIVE_CLIENT: Option<Position> = None;
-static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut CLIENTS: Lazy<HashSet<Position>> = Lazy::new(HashSet::new);
-static mut EVENT_TX: Option<Sender<(CaptureHandle, CaptureEvent)>> = None;
+static mut EVENT_TX: Option<Sender<(Position, CaptureEvent)>> = None;
 static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
 unsafe fn set_event_tid(tid: u32) {
    EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
@@ -281,12 +281,12 @@ unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
    };
    /* check if a client is registered for the barrier */
-    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
+    if !CLIENTS.contains(&pos) {
        return ret;
-    };
+    }
    /* update active client and entry point */
-    ACTIVE_CLIENT.replace(*client);
+    ACTIVE_CLIENT.replace(pos);
    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
    /* notify main thread */
@@ -305,7 +305,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    }
    /* get active client if any */
-    let Some(client) = ACTIVE_CLIENT else {
+    let Some(pos) = ACTIVE_CLIENT else {
        return LRESULT(1);
    };
@@ -313,7 +313,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
        return LRESULT(1);
    };
-    let event = (client, CaptureEvent::Input(Event::Pointer(pointer_event)));
+    let event = (pos, CaptureEvent::Input(Event::Pointer(pointer_event)));
    /* notify mainthread (drop events if sending too fast) */
    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
@@ -493,6 +493,8 @@ fn get_msg() -> Option<MSG> {
    }
 }
 static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
 fn message_thread(ready_tx: mpsc::Sender<()>) {
    unsafe {
        set_event_tid(GetCurrentThreadId());
@@ -513,9 +515,15 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            ..Default::default()
        };
-        let ret = RegisterClassW(&window_class);
+        if WINDOW_CLASS_REGISTERED
-        if ret == 0 {
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-            panic!("RegisterClassW");
+            .is_ok()
        {
            /* register window class if not yet done so */
            let ret = RegisterClassW(&window_class);
            if ret == 0 {
                panic!("RegisterClassW");
            }
        }
        /* window is used ro receive WM_DISPLAYCHANGE messages */
@@ -575,23 +583,16 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
 fn update_clients(request: Request) {
    match request {
-        Request::Create(handle, pos) => {
+        Request::Create(pos) => {
-            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
+            unsafe { CLIENTS.insert(pos) };
        }
-        Request::Destroy(handle) => unsafe {
+        Request::Destroy(pos) => unsafe {
-            for pos in [
+            if let Some(active_pos) = ACTIVE_CLIENT {
-                Position::Left,
+                if pos == active_pos {
-                Position::Right,
+                    let _ = ACTIVE_CLIENT.take();
                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);
                }
            }
            CLIENTS.remove(&pos);
        },
    }
 }
@@ -614,7 +615,7 @@ impl WindowsInputCapture {
 }
 impl Stream for WindowsInputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    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),
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -3,10 +3,7 @@ use std::task::Poll;
 use async_trait::async_trait;
 use futures_core::Stream;
-use super::{
+use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
    error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle,
    Position,
 };
 pub struct X11InputCapture {}
@@ -18,11 +15,11 @@ impl X11InputCapture {
 #[async_trait]
 impl Capture for X11InputCapture {
-    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }
-    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }
@@ -36,7 +33,7 @@ impl Capture for X11InputCapture {
 }
 impl Stream for X11InputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+    type Item = Result<(Position, CaptureEvent), CaptureError>;
    fn poll_next(
        self: std::pin::Pin<&mut Self>,
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.2.1"
+version = "0.3.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,8 +10,8 @@ repository = "https://github.com/feschber/lan-mouse"
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.3.0" }
-thiserror = "1.0.61"
+thiserror = "2.0.0"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -38,13 +38,14 @@ wayland-protocols-misc = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.2", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }
 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.23", features = ["highsierra"] }
+bitflags = "2.6.0"
 core-graphics = { version = "0.24.0", features = ["highsierra"] }
 keycode = "0.4.0"
 [target.'cfg(windows)'.dependencies]
@@ -59,13 +60,13 @@ windows = { version = "0.58.0", features = [
 ] }
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+default = ["wlroots", "x11", "remote_desktop_portal", "libei"]
-wayland = [
+wlroots = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
    "dep:wayland-protocols-misc",
 ]
 x11 = ["dep:x11"]
-xdg_desktop_portal = ["dep:ashpd"]
+remote_desktop_portal = ["dep:ashpd"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-emulation/src/error.rs
+++ b/input-emulation/src/error.rs
@@ -6,53 +6,35 @@ pub enum InputEmulationError {
    Emulate(#[from] EmulationError),
 }
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[cfg(all(
    unix,
    any(feature = "remote_desktop_portal", feature = "libei"),
    not(target_os = "macos")
 ))]
 use ashpd::{desktop::ResponseError, Error::Response};
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::EiConvertEventStreamError;
 use std::io;
 use thiserror::Error;
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
    ConnectError, DispatchError,
 };
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::HandshakeError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("error in libei stream: {inner:?}")]
 pub struct ReisConvertStreamError {
    inner: EiConvertEventStreamError,
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl From<EiConvertEventStreamError> for ReisConvertStreamError {
    fn from(e: EiConvertEventStreamError) -> Self {
        Self { inner: e }
    }
 }
 #[derive(Debug, Error)]
 pub enum EmulationError {
    #[error("event stream closed")]
    EndOfStream,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei error flushing events: `{0}`")]
+    #[error("libei error: `{0}`")]
-    Libei(#[from] reis::event::Error),
+    Libei(#[from] reis::Error),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
    #[error("")]
    LibeiConvertStream(#[from] ReisConvertStreamError),
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wayland error: `{0}`")]
    Wayland(#[from] wayland_client::backend::WaylandError),
    #[cfg(all(
        unix,
-        any(feature = "xdg_desktop_portal", feature = "libei"),
+        any(feature = "remote_desktop_portal", feature = "libei"),
        not(target_os = "macos")
    ))]
    #[error("xdg-desktop-portal: `{0}`")]
@@ -63,13 +45,13 @@ pub enum EmulationError {
 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
    #[error("wlroots backend: `{0}`")]
    Wlroots(#[from] WlrootsEmulationCreationError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei backend: `{0}`")]
    Libei(#[from] LibeiEmulationCreationError),
-    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
    #[error("xdg-desktop-portal: `{0}`")]
    Xdp(#[from] XdpEmulationCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -97,7 +79,7 @@ impl EmulationCreationError {
        ) {
            return true;
        }
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
        if matches!(
            self,
            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
@@ -110,7 +92,7 @@ impl EmulationCreationError {
    }
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {
    #[error(transparent)]
@@ -127,7 +109,7 @@ pub enum WlrootsEmulationCreationError {
    Io(#[from] std::io::Error),
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("wayland protocol \"{protocol}\" not supported: {inner}")]
 pub struct WaylandBindError {
@@ -135,7 +117,7 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
        Self { inner, protocol }
@@ -150,10 +132,10 @@ pub enum LibeiEmulationCreationError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
-    Handshake(#[from] HandshakeError),
+    Reis(#[from] reis::Error),
 }
-#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum XdpEmulationCreationError {
    #[error(transparent)]
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -14,10 +14,10 @@ mod windows;
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 mod x11;
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 mod wlroots;
-#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
 mod xdg_desktop_portal;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
@@ -34,11 +34,11 @@ pub type EmulationHandle = u64;
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Backend {
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
    Wlroots,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    Libei,
-    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
    Xdp,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -52,11 +52,11 @@ pub enum Backend {
 impl Display for Backend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
            Backend::Wlroots => write!(f, "wlroots"),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => write!(f, "xdg-desktop-portal"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -78,13 +78,13 @@ pub struct InputEmulation {
 impl InputEmulation {
    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
        let emulation: Box<dyn Emulation> = match backend {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => Box::new(x11::X11Emulation::new()?),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
            #[cfg(windows)]
            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
@@ -109,11 +109,11 @@ impl InputEmulation {
        }
        for backend in [
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
            Backend::Wlroots,
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei,
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp,
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11,
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,23 +1,18 @@
 use futures::{future, StreamExt};
 use once_cell::sync::Lazy;
 use std::{
    collections::HashMap,
    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    sync::{
-        atomic::{AtomicBool, AtomicU32, Ordering},
+        atomic::{AtomicBool, Ordering},
        Arc, Mutex, RwLock,
    },
    time::{SystemTime, UNIX_EPOCH},
 };
 use tokio::task::JoinHandle;
-use ashpd::{
+use ashpd::desktop::{
-    desktop::{
+    remote_desktop::{DeviceType, RemoteDesktop},
-        remote_desktop::{DeviceType, RemoteDesktop},
+    PersistMode, Session,
        PersistMode, Session,
    },
    WindowIdentifier,
 };
 use async_trait::async_trait;
@@ -26,32 +21,16 @@ use reis::{
        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
        Pointer, Scroll,
    },
-    event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
+    event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
-    tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
+    tokio::EiConvertEventStream,
 };
 use input_event::{Event, KeyboardEvent, PointerEvent};
-use crate::error::{EmulationError, ReisConvertStreamError};
+use crate::error::EmulationError;
 use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
 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
 });
 #[derive(Clone, Default)]
 struct Devices {
    pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
@@ -62,11 +41,11 @@ struct Devices {
 pub(crate) struct LibeiEmulation<'a> {
    context: ei::Context,
    conn: event::Connection,
    devices: Devices,
    ei_task: JoinHandle<()>,
    error: Arc<Mutex<Option<EmulationError>>>,
    libei_error: Arc<AtomicBool>,
    serial: AtomicU32,
    _remote_desktop: RemoteDesktop<'a>,
    session: Session<'a, RemoteDesktop<'a>>,
 }
@@ -89,10 +68,7 @@ async fn get_ei_fd<'a>(
        .await?;
    log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop
+    let _devices = remote_desktop.start(&session, None).await?.response()?;
        .start(&session, &WindowIdentifier::default())
        .await?
        .response()?;
    let fd = remote_desktop.connect_to_eis(&session).await?;
    Ok((remote_desktop, session, fd))
@@ -104,20 +80,15 @@ impl<'a> LibeiEmulation<'a> {
        let stream = UnixStream::from(eifd);
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
-        let mut events = EiEventStream::new(context.clone())?;
+        let (conn, events) = context
-        let handshake = ei_handshake(
+            .handshake_tokio("de.feschber.LanMouse", ContextType::Sender)
-            &mut events,
+            .await?;
            "de.feschber.LanMouse",
            ContextType::Sender,
            &INTERFACES,
        )
        .await?;
        let events = EiConvertEventStream::new(events, handshake.serial);
        let devices = Devices::default();
        let libei_error = Arc::new(AtomicBool::default());
        let error = Arc::new(Mutex::new(None));
        let ei_handler = ei_task(
            events,
            conn.clone(),
            context.clone(),
            devices.clone(),
            libei_error.clone(),
@@ -125,15 +96,13 @@ impl<'a> LibeiEmulation<'a> {
        );
        let ei_task = tokio::task::spawn_local(ei_handler);
        let serial = AtomicU32::new(handshake.serial);
        Ok(Self {
            context,
            conn,
            devices,
            ei_task,
            error,
            libei_error,
            serial,
            _remote_desktop,
            session,
        })
@@ -169,7 +138,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                    let pointer_device = self.devices.pointer.read().unwrap();
                    if let Some((d, p)) = pointer_device.as_ref() {
                        p.motion_relative(dx as f32, dy as f32);
-                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                        d.frame(self.conn.serial(), now);
                    }
                }
                PointerEvent::Button {
@@ -186,7 +155,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                                _ => ButtonState::Press,
                            },
                        );
-                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                        d.frame(self.conn.serial(), now);
                    }
                }
                PointerEvent::Axis {
@@ -200,7 +169,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                            0 => s.scroll(0., value as f32),
                            _ => s.scroll(value as f32, 0.),
                        }
-                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                        d.frame(self.conn.serial(), now);
                    }
                }
                PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -210,7 +179,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                            0 => s.scroll_discrete(0, value),
                            _ => s.scroll_discrete(value, 0),
                        }
-                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                        d.frame(self.conn.serial(), now);
                    }
                }
            },
@@ -229,7 +198,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                                _ => KeyState::Press,
                            },
                        );
-                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                        d.frame(self.conn.serial(), now);
                    }
                }
                KeyboardEvent::Modifiers { .. } => {}
@@ -252,6 +221,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
 async fn ei_task(
    mut events: EiConvertEventStream,
    _conn: Connection,
    context: ei::Context,
    devices: Devices,
    libei_error: Arc<AtomicBool>,
@@ -276,11 +246,7 @@ async fn ei_event_handler(
    devices: &Devices,
 ) -> Result<(), EmulationError> {
    loop {
-        let event = events
+        let event = events.next().await.ok_or(EmulationError::EndOfStream)??;
            .next()
            .await
            .ok_or(EmulationError::EndOfStream)?
            .map_err(ReisConvertStreamError::from)?;
        const CAPABILITIES: &[DeviceCapability] = &[
            DeviceCapability::Pointer,
            DeviceCapability::PointerAbsolute,
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,16 +1,20 @@
 use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
 use bitflags::bitflags;
 use core_graphics::base::CGFloat;
 use core_graphics::display::{
    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
 };
 use core_graphics::event::{
-    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
+    CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
    ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
 use std::ops::{Index, IndexMut};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::{sync::Notify, task::JoinHandle};
@@ -24,6 +28,7 @@ pub(crate) struct MacOSEmulation {
    event_source: CGEventSource,
    repeat_task: Option<JoinHandle<()>>,
    button_state: ButtonState,
    modifier_state: Rc<Cell<XMods>>,
    notify_repeat_task: Arc<Notify>,
 }
@@ -71,6 +76,7 @@ impl MacOSEmulation {
            button_state,
            repeat_task: None,
            notify_repeat_task: Arc::new(Notify::new()),
            modifier_state: Rc::new(Cell::new(XMods::empty())),
        })
    }
@@ -85,6 +91,7 @@ impl MacOSEmulation {
        self.cancel_repeat_task().await;
        let event_source = self.event_source.clone();
        let notify = self.notify_repeat_task.clone();
        let modifiers = self.modifier_state.clone();
        let repeat_task = tokio::task::spawn_local(async move {
            let stop = tokio::select! {
                _ = tokio::time::sleep(DEFAULT_REPEAT_DELAY) => false,
@@ -92,7 +99,7 @@ impl MacOSEmulation {
            };
            if !stop {
                loop {
-                    key_event(event_source.clone(), key, 1);
+                    key_event(event_source.clone(), key, 1, modifiers.get());
                    tokio::select! {
                        _ = tokio::time::sleep(DEFAULT_REPEAT_INTERVAL) => {},
                        _ = notify.notified() => break,
@@ -100,7 +107,8 @@ impl MacOSEmulation {
                }
            }
            // release key when cancelled
-            key_event(event_source.clone(), key, 0);
+            update_modifiers(&modifiers, key as u32, 0);
            key_event(event_source.clone(), key, 0, modifiers.get());
        });
        self.repeat_task = Some(repeat_task);
    }
@@ -113,7 +121,7 @@ impl MacOSEmulation {
    }
 }
-fn key_event(event_source: CGEventSource, key: u16, state: u8) {
+fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
    let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
        Ok(e) => e,
        Err(_) => {
@@ -121,7 +129,21 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
            return;
        }
    };
    event.set_flags(to_cgevent_flags(modifiers));
    event.post(CGEventTapLocation::HID);
    log::trace!("key event: {key} {state}");
 }
 fn modifier_event(event_source: CGEventSource, depressed: XMods) {
    let Ok(event) = CGEvent::new(event_source) else {
        log::warn!("could not create CGEvent");
        return;
    };
    let flags = to_cgevent_flags(depressed);
    event.set_type(CGEventType::FlagsChanged);
    event.set_flags(flags);
    event.post(CGEventTapLocation::HID);
    log::trace!("modifiers updated: {depressed:?}");
 }
 fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
@@ -364,9 +386,23 @@ impl Emulation for MacOSEmulation {
                        1 => self.spawn_repeat_task(code).await,
                        _ => self.cancel_repeat_task().await,
                    }
-                    key_event(self.event_source.clone(), code, state)
+                    update_modifiers(&self.modifier_state, key, state);
                    key_event(
                        self.event_source.clone(),
                        code,
                        state,
                        self.modifier_state.get(),
                    );
                }
                KeyboardEvent::Modifiers {
                    depressed,
                    latched,
                    locked,
                    group,
                } => {
                    set_modifiers(&self.modifier_state, depressed, latched, locked, group);
                    modifier_event(self.event_source.clone(), self.modifier_state.get());
                }
                KeyboardEvent::Modifiers { .. } => {}
            },
        }
        // FIXME
@@ -379,3 +415,81 @@ impl Emulation for MacOSEmulation {
    async fn terminate(&mut self) {}
 }
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
    if let Ok(key) = scancode::Linux::try_from(key) {
        let mask = match key {
            scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
            scancode::Linux::KeyCapsLock => XMods::LockMask,
            scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
            scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
            scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
            _ => XMods::empty(),
        };
        // unchanged
        if mask.is_empty() {
            return false;
        }
        let mut mods = modifiers.get();
        match state {
            1 => mods.insert(mask),
            _ => mods.remove(mask),
        }
        modifiers.set(mods);
        true
    } else {
        false
    }
 }
 fn set_modifiers(
    active_modifiers: &Cell<XMods>,
    depressed: u32,
    latched: u32,
    locked: u32,
    group: u32,
 ) {
    let depressed = XMods::from_bits(depressed).unwrap_or_default();
    let _latched = XMods::from_bits(latched).unwrap_or_default();
    let _locked = XMods::from_bits(locked).unwrap_or_default();
    let _group = XMods::from_bits(group).unwrap_or_default();
    // we only care about the depressed modifiers for now
    active_modifiers.replace(depressed);
 }
 fn to_cgevent_flags(depressed: XMods) -> CGEventFlags {
    let mut flags = CGEventFlags::empty();
    if depressed.contains(XMods::ShiftMask) {
        flags |= CGEventFlags::CGEventFlagShift;
    }
    if depressed.contains(XMods::LockMask) {
        flags |= CGEventFlags::CGEventFlagAlphaShift;
    }
    if depressed.contains(XMods::ControlMask) {
        flags |= CGEventFlags::CGEventFlagControl;
    }
    if depressed.contains(XMods::Mod1Mask) {
        flags |= CGEventFlags::CGEventFlagAlternate;
    }
    if depressed.contains(XMods::Mod4Mask) {
        flags |= CGEventFlags::CGEventFlagCommand;
    }
    flags
 }
 // From X11/X.h
 bitflags! {
    #[repr(C)]
    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
    struct XMods: u32 {
        const ShiftMask = (1<<0);
        const LockMask = (1<<1);
        const ControlMask = (1<<2);
        const Mod1Mask = (1<<3);
        const Mod2Mask = (1<<4);
        const Mod3Mask = (1<<5);
        const Mod4Mask = (1<<6);
        const Mod5Mask = (1<<7);
    }
 }
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -4,7 +4,6 @@ use ashpd::{
        PersistMode, Session,
    },
    zbus::AsyncDrop,
    WindowIdentifier,
 };
 use async_trait::async_trait;
@@ -43,10 +42,7 @@ impl<'a> DesktopPortalEmulation<'a> {
            .await?;
        log::info!("requesting permission for input emulation");
-        let _devices = proxy
+        let _devices = proxy.start(&session, None).await?.response()?;
            .start(&session, &WindowIdentifier::default())
            .await?
            .response()?;
        log::debug!("started session");
        let session = session;
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.2.1"
+version = "0.3.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,10 +11,10 @@ futures-core = "0.3.30"
 log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
-thiserror = "1.0.61"
+thiserror = "2.0.0"
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.2.0", optional = true }
+reis = { version = "0.4", optional = true }
 [features]
 default = ["libei"]
--- a/lan-mouse-cli/Cargo.toml
+++ b/lan-mouse-cli/Cargo.toml
@@ -1,14 +1,14 @@
 [package]
 name = "lan-mouse-cli"
 description = "CLI Frontend for lan-mouse"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
 [dependencies]
 futures = "0.3.30"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-gtk"
 description = "GTK4 / Libadwaita Frontend for lan-mouse"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -12,7 +12,7 @@ adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
 async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-ipc"
 description = "library for communication between lan-mouse service and frontends"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,6 +11,6 @@ futures = "0.3.30"
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
-thiserror = "1.0.63"
+thiserror = "2.0.0"
 tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-proto/Cargo.toml
+++ b/lan-mouse-proto/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
 name = "lan-mouse-proto"
 description = "network protocol for lan-mouse"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
 [dependencies]
 num_enum = "0.7.2"
-thiserror = "1.0.61"
+thiserror = "2.0.0"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.3.0" }
 paste = "1.0"
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -44,6 +44,9 @@ rustPlatform.buildRustPackage {
  postInstall = ''
    wrapProgram "$out/bin/lan-mouse" \
      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
    install -Dm444 *.desktop -t $out/share/applications
    install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
  '';
  meta = with lib; {
--- a/screenshots/dark.png
+++ b/screenshots/dark.png
--- a/screenshots/light.png
+++ b/screenshots/light.png
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -11,6 +11,7 @@ pub async fn run(config: Config) -> Result<(), InputCaptureError> {
        let mut input_capture = InputCapture::new(backend).await?;
        log::info!("creating clients");
        input_capture.create(0, Position::Left).await?;
        input_capture.create(4, Position::Left).await?;
        input_capture.create(1, Position::Right).await?;
        input_capture.create(2, Position::Top).await?;
        input_capture.create(3, Position::Bottom).await?;
@@ -28,12 +29,13 @@ async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError
            .await
            .ok_or(CaptureError::EndOfStream)??;
        let pos = match client {
-            0 => Position::Left,
+            0 | 4 => Position::Left,
            1 => Position::Right,
            2 => Position::Top,
-            _ => Position::Bottom,
+            3 => Position::Bottom,
            _ => panic!(),
        };
-        log::info!("position: {pos}, event: {event}");
+        log::info!("position: {client} ({pos}), event: {event}");
        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
            input_capture.release().await?;
            break Ok(());
--- a/src/config.rs
+++ b/src/config.rs
@@ -85,27 +85,33 @@ struct CliArgs {
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum CaptureBackend {
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
    #[serde(rename = "input-capture-portal")]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
    #[serde(rename = "layer-shell")]
    LayerShell,
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
    #[serde(rename = "x11")]
    X11,
    #[cfg(windows)]
    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
    #[serde(rename = "macos")]
    MacOs,
    #[serde(rename = "dummy")]
    Dummy,
 }
 impl Display for CaptureBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
            CaptureBackend::LayerShell => write!(f, "layer-shell"),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
            CaptureBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            CaptureBackend::Windows => write!(f, "windows"),
@@ -119,11 +125,11 @@ impl Display for CaptureBackend {
 impl From<CaptureBackend> for input_capture::Backend {
    fn from(backend: CaptureBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
            CaptureBackend::LayerShell => Self::LayerShell,
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
            CaptureBackend::X11 => Self::X11,
            #[cfg(windows)]
            CaptureBackend::Windows => Self::Windows,
@@ -136,31 +142,38 @@ impl From<CaptureBackend> for input_capture::Backend {
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum EmulationBackend {
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
    #[serde(rename = "wlroots")]
    Wlroots,
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
    #[serde(rename = "libei")]
    Libei,
-    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
    #[serde(rename = "xdp")]
    Xdp,
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
    #[serde(rename = "x11")]
    X11,
    #[cfg(windows)]
    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
    #[serde(rename = "macos")]
    MacOs,
    #[serde(rename = "dummy")]
    Dummy,
 }
 impl From<EmulationBackend> for input_emulation::Backend {
    fn from(backend: EmulationBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
            EmulationBackend::Wlroots => Self::Wlroots,
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
            EmulationBackend::Libei => Self::Libei,
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
            EmulationBackend::Xdp => Self::Xdp,
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
            EmulationBackend::X11 => Self::X11,
            #[cfg(windows)]
            EmulationBackend::Windows => Self::Windows,
@@ -174,13 +187,13 @@ impl From<EmulationBackend> for input_emulation::Backend {
 impl Display for EmulationBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
            EmulationBackend::Wlroots => write!(f, "wlroots"),
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
            EmulationBackend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
            EmulationBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            EmulationBackend::Windows => write!(f, "windows"),
@@ -193,7 +206,9 @@ impl Display for EmulationBackend {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
 pub enum Frontend {
    #[serde(rename = "gtk")]
    Gtk,
    #[serde(rename = "cli")]
    Cli,
 }
Author	SHA1	Message	Date
Ferdinand Schober	4703a4c947	chore: Release	2024-11-07 12:49:59 +01:00
Ferdinand Schober	a870a9e3a9	split features for emulation and capture backends	2024-11-07 12:43:42 +01:00
Ferdinand Schober	1433a3021b	fix conditional compilation for xdp only build	2024-11-07 12:21:38 +01:00
Ferdinand Schober	ef92bd69d9	Update README.md	2024-11-07 02:37:40 +01:00
Ferdinand Schober	526d8004b6	Update README.md	2024-11-07 02:36:11 +01:00
Ferdinand Schober	fef702ffdd	Update README.md (#229 )	2024-11-07 02:35:32 +01:00
Ferdinand Schober	41ab25cc19	update screenshots (#228 )	2024-11-07 01:18:55 +01:00
Ferdinand Schober	66456f18f1	update core-graphics / foundation (#227 )	2024-11-07 01:15:35 +01:00
Ferdinand Schober	1d25dfbe50	upgrade ashpd + reis (#226 )	2024-11-07 00:38:26 +01:00
Ferdinand Schober	9d28fe6c7b	bump dependencies	2024-11-06 23:53:42 +01:00
byquanton	de674c631a	Rename Synergy Community Edition to Deskflow (#225 )	2024-11-06 13:46:19 +01:00
Ferdinand Schober	cd2cabf25b	adapt config backend options to cli arg names	2024-11-06 12:14:47 +01:00
Ferdinand Schober	71f7e2e5e0	fix left over capture barrier	2024-11-05 14:32:39 +01:00
Ferdinand Schober	e7a18b9696	recreate wl_{pointer,keyboard} on capability event (#222 ) this should fix #88 fixes #123	2024-11-04 22:45:57 +01:00
Ferdinand Schober	7496015d8d	macos: implement client side modifier events (#219 ) closes #198 closes #199	2024-10-27 08:41:26 +01:00
Ferdinand Schober	75b790ec2e	propagate event tap creation error (#218 )	2024-10-25 16:31:15 +02:00
Emile Akbarzadeh	9f52a2ac93	Add default.nix file to main and update readme (#211 ) Co-authored-by: Emile Akbarzadeh <emile@dromeda.com.au>	2024-10-25 16:20:15 +02:00
Ferdinand Schober	4856199153	fix windows ci	2024-10-25 15:12:20 +02:00
虢豳	24e7a1d07f	Add desktop and icon (#212 ) * nix flake update * nix: add desktop and icon closes #210	2024-10-07 12:05:07 +02:00
Ferdinand Schober	555fbfeb79	formatting	2024-10-05 21:48:49 +02:00
Ferdinand Schober	6191216873	windows: fix panic when recreating input-capture RegisterWindowClassW fails when called again	2024-10-05 21:47:12 +02:00
Ferdinand Schober	5b1dc4ccf8	reference count capture (#209 ) * reference count capture Multiple captures can now be created at the same position. Captures at the same position are reference counted. * update testcase will be required by #200 / #164	2024-10-05 21:22:28 +02:00
Ferdinand Schober	ab1b45ff45	macos: fix key-release with repeat logic (#206 )	2024-10-04 18:21:40 +02:00