implement xdg-foreign to put capture dialog on top

.editorconfig

@@ -1,24 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-charset = utf-8
-
-[*.rs]
-indent_style = space
-indent_size = 4
-max_line_length = 100
-
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-[*.toml]
-indent_style = space
-indent_size = 4
-
-[*.nix]
-indent_style = space
-indent_size = 2

.githooks/pre-commit

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Ensure we're at the repo root
-cd "$(git rev-parse --show-toplevel)" || exit 1
-
-echo "Running cargo fmt (auto-format)..."
-# Run formatter to apply fixes but do not stage them. If formatting changed,
-# fail the commit so the user can review and stage the changes manually.
-cargo fmt --all
-if ! git diff --quiet --exit-code; then
-  echo "" >&2
-  echo "ERROR: cargo fmt modified files. Review changes, stage them, and commit again." >&2
-  git --no-pager diff --name-only
-  exit 1
-fi
-
-echo "Running cargo clippy..."
-# Matches CI: deny warnings to keep code health strict
-if ! cargo clippy --workspace --all-targets --all-features -- -D warnings; then
-  echo "" >&2
-  echo "ERROR: clippy found warnings/errors. Fix them before committing." >&2
-  exit 1
-fi
-
-echo "Running cargo test..."
-if ! cargo test --workspace --all-features; then
-  echo "" >&2
-  echo "ERROR: Some tests failed. Fix tests before committing." >&2
-  exit 1
-fi
-
-echo "All pre-commit checks passed."
-exit 0

.github/workflows/cachix.yml

@@ -1,50 +1,40 @@
-name: Nix Binary Cache
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
+name: Binary Cache
 
+on: [push, pull_request, workflow_dispatch]
 jobs:
   nix:
     strategy:
       matrix:
-        os:
-          - ubuntu-latest
-          - macos-15-intel
-          - macos-latest
+       os: 
+        - ubuntu-latest
+        - macos-15-intel
+        - macos-14
     name: "Build"
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }} 
     steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
 
-      # - uses: DeterminateSystems/nix-installer-action@main
-      #   with:
-      #     logger: pretty
-      # - uses: DeterminateSystems/magic-nix-cache-action@main
-      - uses: cachix/install-nix-action@v31
-      - uses: cachix/cachix-action@v16
-        with:
-          name: lan-mouse
-          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+    - uses: DeterminateSystems/nix-installer-action@main
+      with:
+        logger: pretty
+    - uses: DeterminateSystems/magic-nix-cache-action@main
+    - uses: cachix/cachix-action@v14
+      with:
+        name: lan-mouse
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
 
-      - name: Build lan-mouse (x86_64-linux)
-        if: matrix.os == 'ubuntu-latest'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
+    - name: Build lan-mouse (x86_64-linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
 
-      - name: Build lan-mouse (x86_64-darwin)
-        if: matrix.os == 'macos-15-intel'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+    - name: Build lan-mouse (x86_64-darwin)
+      if: matrix.os == 'macos-15-intel'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+
+    - name: Build lan-mouse (aarch64-darwin)
+      if: matrix.os == 'macos-14'
+      run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse
 
-      - name: Build lan-mouse (aarch64-darwin)
-        if: matrix.os == 'macos-latest'
-        run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse

.github/workflows/pre-release.yml

@@ -1,17 +1,10 @@
-name: "Release"
-run-name: "Release - ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || github.event.inputs.name || github.ref_name }}"
+name: "pre-release"
 
 on:
   push:
     branches: [ "main" ]
-    tags:
-      - v**
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'Development release name'
-        required: false
-        default: ''
+
+
 
 env:
   CARGO_TERM_COLOR: always
@@ -20,40 +13,19 @@ jobs:
   linux-release-build:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: install dependencies
       run: |
         sudo apt-get update
         sudo apt-get install libx11-dev libxtst-dev
         sudo apt-get install libadwaita-1-dev libgtk-4-dev
     - name: Release Build
-      run: |
-        cargo build --release
-        cp target/release/lan-mouse lan-mouse-linux-x86_64
+      run: cargo build --release
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-linux-x86_64
-        path: lan-mouse-linux-x86_64
-
-  linux-arm64-release-build:
-    runs-on: ubuntu-22.04-arm
-    steps:
-    - uses: actions/checkout@v6
-    - name: install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install libx11-dev libxtst-dev
-        sudo apt-get install libadwaita-1-dev libgtk-4-dev
-    - name: Release Build
-      run: |
-        cargo build --release
-        cp target/release/lan-mouse lan-mouse-linux-arm64
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v6
-      with:
-        name: lan-mouse-linux-arm64
-        path: lan-mouse-linux-arm64
+        name: lan-mouse-linux
+        path: target/release/lan-mouse
 
   windows-release-build:
     runs-on: windows-latest
@@ -92,7 +64,7 @@ jobs:
         gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
         Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
         Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Release Build
       run: cargo build --release
     - name: Create Archive
@@ -100,21 +72,19 @@ jobs:
         mkdir "lan-mouse-windows"
         Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "lan-mouse-windows"
         Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
-        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows-x86_64.zip
+        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-windows-x86_64
-        path: lan-mouse-windows-x86_64.zip
+        name: lan-mouse-windows
+        path: lan-mouse-windows.zip
 
   macos-release-build:
     runs-on: macos-15-intel
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: install dependencies
-      run: |
-        brew install --cask inkscape
-        brew install gtk4 libadwaita imagemagick librsvg
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
@@ -132,23 +102,21 @@ jobs:
         cd target/release/bundle/osx
         zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
         name: lan-mouse-macos-intel
         path: target/release/bundle/osx/lan-mouse-macos-intel.zip
 
-  macos-arm64-release-build:
-    runs-on: macos-15
+  macos-aarch64-release-build:
+    runs-on: macos-14
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: install dependencies
-      run: |
-        brew install --cask inkscape
-        brew install gtk4 libadwaita imagemagick librsvg
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
-        cp target/release/lan-mouse lan-mouse-macos-arm64
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
     - name: Make icns
       run: scripts/makeicns.sh
     - name: Install cargo bundle
@@ -160,45 +128,29 @@ jobs:
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
-        zip -r "lan-mouse-macos-arm64.zip" "Lan Mouse.app"
+        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos-arm64
-        path: target/release/bundle/osx/lan-mouse-macos-arm64.zip
+        name: lan-mouse-macos-aarch64
+        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
 
-  release:
-    name: "Release"
-    needs: [windows-release-build, linux-release-build, linux-arm64-release-build, macos-release-build, macos-arm64-release-build]
+  pre-release:
+    name: "Pre Release"
+    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
       uses: actions/download-artifact@v4
-    - name: Create Pre-Release
-      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
-      uses: softprops/action-gh-release@v2
+    - name: Create Release
+      uses: "marvinpinto/action-automatic-releases@latest"
       with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        tag_name: ${{ github.event.inputs.name || github.ref_name }}
-        name: ${{ github.event.inputs.name || github.ref_name }}
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        automatic_release_tag: "latest"
         prerelease: true
-        generate_release_notes: true
+        title: "Development Build"
         files: |
-          lan-mouse-linux-x86_64/lan-mouse-linux-x86_64
-          lan-mouse-linux-arm64/lan-mouse-linux-arm64
+          lan-mouse-linux/lan-mouse
           lan-mouse-macos-intel/lan-mouse-macos-intel.zip
-          lan-mouse-macos-arm64/lan-mouse-macos-arm64.zip
-          lan-mouse-windows-x86_64/lan-mouse-windows-x86_64.zip
-    - name: Create Tagged Release
-      if: startsWith(github.ref, 'refs/tags/')
-      uses: softprops/action-gh-release@v2
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        name: ${{ github.ref_name }}
-        generate_release_notes: true
-        files: |
-          lan-mouse-linux-x86_64/lan-mouse-linux-x86_64
-          lan-mouse-linux-arm64/lan-mouse-linux-arm64
-          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
-          lan-mouse-macos-arm64/lan-mouse-macos-arm64.zip
-          lan-mouse-windows-x86_64/lan-mouse-windows-x86_64.zip
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
+          lan-mouse-windows/lan-mouse-windows.zip

.github/workflows/rust.yml

@@ -9,16 +9,12 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   fmt:
     name: Formatting
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - name: cargo fmt
         run: cargo fmt --check
 
@@ -39,7 +35,7 @@ jobs:
           - clippy
           - test
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - uses: Swatinem/rust-cache@v2
       - name: Install Linux deps
         if: runner.os == 'Linux'
@@ -80,7 +76,7 @@ jobs:
           gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
       - name: cargo build
         if: matrix.job == 'build'
-        run: cargo build
+        run: cargo check --workspace --all-targets --all-features
 
       - name: cargo check
         if: matrix.job == 'check'

.github/workflows/tagged-release.yml

@@ -0,0 +1,150 @@
+name: "Tagged Release"
+
+on:
+  push:
+    tags:
+      - v**
+
+jobs:
+  linux-release-build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
+    - name: Release Build
+      run: cargo build --release
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-linux
+        path: target/release/lan-mouse
+
+  windows-release-build:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+    # needed for cache restore
+    - name: create gtk dir
+      run: mkdir C:\gtk-build\gtk\x64\release
+    - uses: actions/cache@v3
+      id: cache
+      with:
+        path: c:/gtk-build/gtk/x64/release/**
+        key: gtk-windows-build
+        restore-keys: gtk-windows-build
+    - name: Update path
+      run: |
+        echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo $env:GITHUB_PATH
+        echo $env:PATH
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        # choco install msys2
+        # choco install visualstudio2022-workload-vctools
+        # choco install pkgconfiglite
+        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"
+        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
+        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
+        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
+    - uses: actions/checkout@v4
+    - name: Release Build
+      run: cargo build --release
+    - name: Create Archive
+      run: |
+        mkdir "lan-mouse-windows"
+        Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "lan-mouse-windows"
+        Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
+        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-windows
+        path: lan-mouse-windows.zip
+
+  macos-release-build:
+    runs-on: macos-15-intel
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-intel
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-intel.zip
+        path: target/release/bundle/osx/lan-mouse-macos-intel.zip
+
+  macos-aarch64-release-build:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64.zip
+        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
+
+  tagged-release:
+    name: "Tagged Release"
+    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
+    runs-on: "ubuntu-latest"
+    steps:
+    - name: Download build artifacts
+      uses: actions/download-artifact@v4
+    - name: Create Release
+      uses: "marvinpinto/action-automatic-releases@latest"
+      with:
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        prerelease: false
+        files: |
+          lan-mouse-linux/lan-mouse
+          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
+          lan-mouse-windows/lan-mouse-windows.zip

AGENTS.md

@@ -1,65 +0,0 @@
-# Lan Mouse Agent Instructions
-
-## Overview
-
-Lan Mouse is an open-source Software KVM sharing mouse/keyboard input across local networks. The Rust workspace combines a GTK frontend, CLI/daemon mode, and multi-OS capture/emulation backends for Linux, Windows, and macOS.
-
-## Core principles
-
-- **Scope discipline.** Only implement what was requested; describe follow-up work instead of absorbing it.
-- **Clarify OS behavior.** Ask when requirements touch OS-specific capture/emulation (they differ significantly).
-- **Docs stay current.** Update [README.md](README.md) or [DOC.md](DOC.md) when touching public APIs or platform support.
-- **Rust idioms.** Use `Result`/`Option`, `thiserror` for errors, descriptive logs, and concise comments for non-obvious invariants.
-
-## Terminology
-
-- **Client:** A remote machine that can receive or send input events. Each client is either _active_ (receiving events) or _inactive_ (can send events back). This mutual exclusion prevents feedback loops.
-- **Backend:** OS-specific implementation for capture or emulation (e.g., libei, layer-shell, wlroots, X11, Windows, macOS).
-- **Handle:** A per-client identifier used to route events and track state (pressed keys, position).
-
-## Architecture
-
-**Pipeline:** `input-capture` → `lan-mouse-ipc` → `input-emulation`
-
-- **input-capture:** Reads OS events into a `Stream<CaptureEvent>`. Backends tried in priority order (libei → layer-shell → X11 → fallback). Tracks `pressed_keys` to avoid stuck modifiers. `position_map` queues events when multiple clients share a screen edge.
-- **input-emulation:** Replays events via the `Emulation` trait (`consume`, `create`, `destroy`, `terminate`). Maintains `pressed_keys` and releases them on disconnect.
-- **lan-mouse-ipc / lan-mouse-proto:** Protocol glue and serialization. Events are UDP; connection requests are TCP on the same port. Version bumps required when serialization changes.
-- **input-event:** Shared scancode enums and abstract event types—extend here, don't duplicate translations.
-
-## Feature & cfg discipline
-
-- Feature flags live in root `Cargo.toml`. Gate OS-specific modules with tight cfgs (e.g., `cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))`).
-- Prefer module-level gating over per-function cfgs to avoid empty stubs.
-- New backends: add feature in `Cargo.toml`, create gated module, log backend selection.
-
-## Async patterns
-
-- Tokio runtime with `futures` streams and `async_trait`. Model new flows as streams or async methods.
-- Avoid blocking; use `spawn_blocking` if needed. Prefer existing single-threaded stream handling.
-- `InputCapture` implements `Stream` and manually pumps backends—don't short-circuit this logic.
-
-## Commands
-
-```sh
-cargo build --workspace                                    # full build
-cargo build -p <crate>                                     # single crate
-cargo test --workspace                                     # all tests
-cargo fmt && cargo clippy --workspace --all-targets --all-features  # lint
-RUST_LOG=lan_mouse=debug cargo run                         # debug logging
-```
-
-Run from repo root—no `cd` in scripts.
-
-## Testing
-
-- Unit tests for utilities; integration tests for protocol behavior.
-- OS-specific backends: test via GTK/CLI on target OS or document manual verification.
-- Dummy backend exercises pipeline without real dependencies.
-- Verify `terminate()` releases keys on unexpected disconnect.
-
-## Workflow
-
-1. Clarify ambiguous requirements, especially OS-specific behavior.
-2. Implement minimal change; flag follow-up work.
-3. Add proportional tests; run `cargo test` on affected crates.
-4. Run `cargo fmt` and `cargo clippy --workspace --all-targets --all-features`.

README.md

@@ -1,9 +1,4 @@
 # Lan Mouse
-
-[![CI](https://github.com/feschber/lan-mouse/actions/workflows/rust.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/rust.yml) [![Cachix](https://github.com/feschber/lan-mouse/actions/workflows/cachix.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/cachix.yml) [![Release](https://github.com/feschber/lan-mouse/actions/workflows/release.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/release.yml)
-
-[![crates.io](https://img.shields.io/crates/v/lan-mouse.svg)](https://crates.io/crates/lan-mouse)  [![license](https://img.shields.io/crates/l/lan-mouse.svg)](https://github.com/feschber/lan-mouse/blob/main/Cargo.toml)
-
 Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
 It allows for using multiple PCs via a single set of mouse and keyboard.
 This is also known as a Software KVM switch.
@@ -182,27 +177,8 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
 
 
 
-## Development
 
-### Git pre-commit hook
-
-This repository includes a local git hooks directory `.githooks/` with a `pre-commit` script that enforces formatting, lints, and tests before allowing a commit.  It is optional to enable it, but it will prevent you from committing code with failing unit tests or that needs clippy/fmt fixes. To enable the hook locally:
-
-1. Make the hook executable:
-
-```sh
-chmod +x .githooks/pre-commit
-```
-
-2. Point git to the hooks directory (one-time per clone):
-
-```sh
-git config core.hooksPath .githooks
-```
-
-The `pre-commit` script runs `cargo fmt --all` (and fails if files were modified), `cargo clippy --workspace --all-targets --all-features -- -D warnings`, and `cargo test --workspace --all-features`.
-
-### Dependencies & Compiling from Source
+## Installing Dependencies for Development / Compiling from Source
 <details>
     <summary>MacOS</summary>
 
@@ -475,4 +451,4 @@ The following sections detail the emulation and capture backends provided by lan
 - `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)
+- `x11`: TODO (not yet supported)

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1772963539,
-        "narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=",
+        "lastModified": 1770841267,
+        "narHash": "sha256-9xejG0KoqsoKEGp2kVbXRlEYtFFcDTHjidiuX8hGO44=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "9dcb002ca1690658be4a04645215baea8b95f31d",
+        "rev": "ec7c70d12ce2fc37cb92aff673dcdca89d187bae",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1773025773,
-        "narHash": "sha256-Wik8+xApNfldpUFjPmJkPdg0RrvUPSWGIZis+A/0N1w=",
+        "lastModified": 1770952264,
+        "narHash": "sha256-CjymNrJZWBtpavyuTkfPVPaZkwzIzGaf0E/3WgcwM14=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "3c06fdbbd36ff60386a1e590ee0cd52dcd1892bf",
+        "rev": "ec6a3d5cdf14bb5a1dd03652bd3f6351004d2188",
         "type": "github"
       },
       "original": {

flake.nix

@@ -7,87 +7,60 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
   };
-  outputs =
-    {
-      nixpkgs,
-      rust-overlay,
-      self,
-      ...
-    }:
-    let
-      inherit (nixpkgs) lib;
-      forEachPkgs =
-        f:
-        lib.genAttrs
-          [
-            "aarch64-darwin"
-            "aarch64-linux"
-            "x86_64-darwin"
-            "x86_64-linux"
-          ]
-          (
-            system:
-            let
-              pkgs = import nixpkgs {
-                inherit system;
-                overlays = [ rust-overlay.overlays.default ];
-              };
-              # Default toolchain for devshell
-              rustToolchain = pkgs.rust-bin.stable.latest.default.override {
-                extensions = [
-                  # includes already:
-                  # rustc
-                  # cargo
-                  # rust-std
-                  # rust-docs
-                  # rustfmt-preview
-                  # clippy-preview
-                  "rust-analyzer"
-                  "rust-src"
-                ];
-              };
-              # Minimal toolchain for builds (rustc + cargo + rust-std only)
-              rustToolchainForBuild = pkgs.rust-bin.stable.latest.minimal;
-            in
-            f { inherit pkgs rustToolchain rustToolchainForBuild; }
-          );
-    in
-    {
-      packages = forEachPkgs (
-        { pkgs, rustToolchainForBuild, ... }:
-        let
-          customRustPlatform = pkgs.makeRustPlatform {
-            cargo = rustToolchainForBuild;
-            rustc = rustToolchainForBuild;
-          };
-          lan-mouse = pkgs.callPackage ./nix { rustPlatform = customRustPlatform; };
-        in
-        {
-          default = lan-mouse;
-          inherit lan-mouse;
-        }
-      );
-      devShells = forEachPkgs (
-        { pkgs, rustToolchain, ... }:
-        {
-          default = pkgs.mkShell {
-            packages =
-              with pkgs;
-              [
-                rustToolchain
-                pkg-config
-                gtk4
-                libadwaita
-                librsvg
-              ]
-              ++ lib.optionals pkgs.stdenv.isLinux [
-                libX11
-                libXtst
-              ];
-            env.RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
-          };
-        }
-      );
-      homeManagerModules.default = import ./nix/hm-module.nix self;
-    };
+  outputs = {
+    self,
+    nixpkgs,
+    rust-overlay,
+    ...
+  }: let
+    inherit (nixpkgs) lib;
+    genSystems = lib.genAttrs [
+      "aarch64-darwin"
+      "aarch64-linux"
+      "x86_64-darwin"
+      "x86_64-linux"
+    ];
+    pkgsFor = system:
+      import nixpkgs {
+        inherit system;
+
+        overlays = [
+          rust-overlay.overlays.default
+        ];
+      };
+    mkRustToolchain = pkgs:
+      pkgs.rust-bin.stable.latest.default.override {
+        extensions = ["rust-src"];
+      };
+    pkgs = genSystems (system: import nixpkgs {inherit system;});
+  in {
+    packages = genSystems (system: rec {
+      default = pkgs.${system}.callPackage ./nix {};
+      lan-mouse = default;
+    });
+    homeManagerModules.default = import ./nix/hm-module.nix self;
+    devShells = genSystems (system: let
+      pkgs = pkgsFor system;
+      rust = mkRustToolchain pkgs;
+    in {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          rust
+          rust-analyzer-unwrapped
+          pkg-config
+          xorg.libX11
+          gtk4
+          libadwaita
+          librsvg
+          xorg.libXtst
+        ] ++ lib.optionals stdenv.isDarwin
+        (with darwin.apple_sdk_11_0.frameworks; [
+          CoreGraphics
+          ApplicationServices
+        ]);
+
+        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
+      };
+    });
+  };
 }

input-capture/Cargo.toml

@@ -41,7 +41,7 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.13.9", default-features = false, features = [
+ashpd = { git = "https://github.com/bilelmoussaoui/ashpd", default-features = false, features = [
     "input_capture",
     "tokio",
 ], optional = true }

input-capture/src/lib.rs

@@ -136,12 +136,11 @@ pub enum WindowIdentifier {
     X11(u32),
 }
 
-#[cfg(all(unix, feature = "libei"))]
 impl Into<ashpd::WindowIdentifier> for WindowIdentifier {
     fn into(self) -> ashpd::WindowIdentifier {
         match self {
             WindowIdentifier::Wayland(handle) => {
-                ashpd::WindowIdentifier::from_xdg_foreign_exported(handle)
+                ashpd::WindowIdentifier::from_xdg_foreign_exported_v2(handle)
             }
             WindowIdentifier::X11(_) => todo!(),
         }

input-capture/src/libei.rs

@@ -2,8 +2,8 @@ use ashpd::{
     desktop::{
         Session,
         input_capture::{
-            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, CreateSessionOptions,
-            InputCapture, Region, ReleaseOptions, Zones,
+            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
+            Zones,
         },
     },
     enumflags2::BitFlags,
@@ -135,10 +135,7 @@ async fn update_barriers(
     active_clients: &[Position],
     next_barrier_id: &mut NonZeroU32,
 ) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
-    let zones = input_capture
-        .zones(session, Default::default())
-        .await?
-        .response()?;
+    let zones = input_capture.zones(session).await?.response()?;
     log::debug!("zones: {zones:?}");
 
     let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
@@ -147,12 +144,7 @@ async fn update_barriers(
 
     let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
     let response = input_capture
-        .set_pointer_barriers(
-            session,
-            &ashpd_barriers,
-            zones.zone_set(),
-            Default::default(),
-        )
+        .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
         .await?;
     let response = response.response()?;
     log::debug!("{response:?}");
@@ -163,15 +155,15 @@ async fn create_session(
     input_capture: &InputCapture,
     window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 ) -> std::result::Result<(Session<InputCapture>, BitFlags<Capabilities>), ashpd::Error> {
-    log::debug!("creating input capture session: {window_identifier:?}");
     let window_identifier = window_identifier.lock().unwrap().clone();
-    let create_session_options = CreateSessionOptions::default().set_capabilities(
-        Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
-    );
+    log::debug!("creating input capture session: {window_identifier:?}");
     let ashpd_window_identifier: Option<ashpd::WindowIdentifier> =
         window_identifier.map(|i| i.into());
     input_capture
-        .create_session(ashpd_window_identifier.as_ref(), create_session_options)
+        .create_session(
+            ashpd_window_identifier.as_ref(),
+            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
+        )
         .await
 }
 
@@ -180,9 +172,7 @@ async fn connect_to_eis(
     session: &Session<InputCapture>,
 ) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
     log::debug!("connect_to_eis");
-    let fd = input_capture
-        .connect_to_eis(session, Default::default())
-        .await?;
+    let fd = input_capture.connect_to_eis(session).await?;
 
     // create unix stream from fd
     let stream = UnixStream::from(fd);
@@ -332,7 +322,7 @@ async fn do_capture(
 
             // disable capture
             log::debug!("disabling input capture");
-            if let Err(e) = input_capture.disable(&session, Default::default()).await {
+            if let Err(e) = input_capture.disable(&session).await {
                 log::warn!("input_capture.disable(&session) {e}");
             }
             if let Err(e) = session.close().await {
@@ -381,7 +371,7 @@ async fn do_capture_session(
         update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
 
     log::debug!("enabling session");
-    input_capture.enable(session, Default::default()).await?;
+    input_capture.enable(session).await?;
 
     // cancellation token to release session
     let release_session = Arc::new(Notify::new());
@@ -509,10 +499,9 @@ async fn release_capture(
     };
     // release 1px to the right of the entered zone
     let cursor_position = (x as f64 + dx, y as f64 + dy);
-    let release_options = ReleaseOptions::default()
-        .set_activation_id(activated.activation_id())
-        .set_cursor_position(Some(cursor_position));
-    input_capture.release(session, release_options).await?;
+    input_capture
+        .release(session, activated.activation_id(), Some(cursor_position))
+        .await?;
     Ok(())
 }
 

input-capture/src/macos.rs

@@ -18,9 +18,7 @@ use core_graphics::{
     event_source::{CGEventSource, CGEventSourceStateID},
 };
 use futures_core::Stream;
-use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
-};
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
@@ -306,28 +304,16 @@ fn get_events(
             })))
         }
         CGEventType::OtherMouseDown => {
-            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
-            let button = match btn_num {
-                3 => BTN_BACK,
-                4 => BTN_FORWARD,
-                _ => BTN_MIDDLE,
-            };
             result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                 time: 0,
-                button,
+                button: BTN_MIDDLE,
                 state: 1,
             })))
         }
         CGEventType::OtherMouseUp => {
-            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
-            let button = match btn_num {
-                3 => BTN_BACK,
-                4 => BTN_FORWARD,
-                _ => BTN_MIDDLE,
-            };
             result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                 time: 0,
-                button,
+                button: BTN_MIDDLE,
                 state: 0,
             })))
         }

input-emulation/Cargo.toml

@@ -40,7 +40,7 @@ wayland-protocols-misc = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.13.9", default-features = false, features = [
+ashpd = { git = "https://github.com/bilelmoussaoui/ashpd", default-features = false, features = [
     "remote_desktop",
     "screencast",
     "tokio",

input-emulation/src/libei.rs

@@ -13,7 +13,7 @@ use tokio::task::JoinHandle;
 
 use ashpd::desktop::{
     PersistMode, Session,
-    remote_desktop::{DeviceType, RemoteDesktop, SelectDevicesOptions},
+    remote_desktop::{DeviceType, RemoteDesktop},
 };
 use async_trait::async_trait;
 
@@ -90,20 +90,20 @@ async fn get_ei_fd() -> Result<(RemoteDesktop, Session<RemoteDesktop>, OwnedFd),
     let restore_token = read_token();
 
     log::debug!("creating session ...");
-    let session = remote_desktop.create_session(Default::default()).await?;
+    let session = remote_desktop.create_session().await?;
 
     log::debug!("selecting devices ...");
-    let options = SelectDevicesOptions::default()
-        .set_devices(DeviceType::Keyboard | DeviceType::Pointer)
-        .set_persist_mode(PersistMode::ExplicitlyRevoked)
-        .set_restore_token(restore_token.as_deref());
-    remote_desktop.select_devices(&session, options).await?;
+    remote_desktop
+        .select_devices(
+            &session,
+            DeviceType::Keyboard | DeviceType::Pointer,
+            restore_token.as_deref(),
+            PersistMode::ExplicitlyRevoked,
+        )
+        .await?;
 
     log::info!("requesting permission for input emulation");
-    let start_response = remote_desktop
-        .start(&session, None, Default::default())
-        .await?
-        .response()?;
+    let start_response = remote_desktop.start(&session, None).await?.response()?;
 
     // The restore token is only valid once, we need to re-save it each time
     if let Some(token_str) = start_response.restore_token() {
@@ -112,9 +112,7 @@ async fn get_ei_fd() -> Result<(RemoteDesktop, Session<RemoteDesktop>, OwnedFd),
         }
     }
 
-    let fd = remote_desktop
-        .connect_to_eis(&session, Default::default())
-        .await?;
+    let fd = remote_desktop.connect_to_eis(&session).await?;
     Ok((remote_desktop, session, fd))
 }
 

input-emulation/src/macos.rs

@@ -10,13 +10,10 @@ use core_graphics::event::{
     ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
-    scancode,
-};
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent, scancode};
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
-use std::collections::HashSet;
+use std::ops::{Index, IndexMut};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -33,10 +30,10 @@ pub(crate) struct MacOSEmulation {
     event_source: CGEventSource,
     /// task handle for key repeats
     repeat_task: Option<JoinHandle<()>>,
-    /// current state of the mouse buttons (tracked by evdev button code)
-    pressed_buttons: HashSet<u32>,
-    /// button previously pressed (evdev button code)
-    previous_button: Option<u32>,
+    /// current state of the mouse buttons
+    button_state: ButtonState,
+    /// button previously pressed
+    previous_button: Option<CGMouseButton>,
     /// timestamp of previous click (button down)
     previous_button_click: Option<Instant>,
     /// click state, i.e. number of clicks in quick succession
@@ -47,13 +44,31 @@ pub(crate) struct MacOSEmulation {
     notify_repeat_task: Arc<Notify>,
 }
 
-/// Maps an evdev button code to the CGEventType used for drag events.
-fn drag_event_type(button: u32) -> CGEventType {
-    match button {
-        BTN_LEFT => CGEventType::LeftMouseDragged,
-        BTN_RIGHT => CGEventType::RightMouseDragged,
-        // middle, back, forward, and any other button all use OtherMouseDragged
-        _ => CGEventType::OtherMouseDragged,
+struct ButtonState {
+    left: bool,
+    right: bool,
+    center: bool,
+}
+
+impl Index<CGMouseButton> for ButtonState {
+    type Output = bool;
+
+    fn index(&self, index: CGMouseButton) -> &Self::Output {
+        match index {
+            CGMouseButton::Left => &self.left,
+            CGMouseButton::Right => &self.right,
+            CGMouseButton::Center => &self.center,
+        }
+    }
+}
+
+impl IndexMut<CGMouseButton> for ButtonState {
+    fn index_mut(&mut self, index: CGMouseButton) -> &mut Self::Output {
+        match index {
+            CGMouseButton::Left => &mut self.left,
+            CGMouseButton::Right => &mut self.right,
+            CGMouseButton::Center => &mut self.center,
+        }
     }
 }
 
@@ -63,9 +78,14 @@ impl MacOSEmulation {
     pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
         let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
             .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
+        let button_state = ButtonState {
+            left: false,
+            right: false,
+            center: false,
+        };
         Ok(Self {
             event_source,
-            pressed_buttons: HashSet::new(),
+            button_state,
             previous_button: None,
             previous_button_click: None,
             button_click_state: 0,
@@ -241,14 +261,14 @@ impl Emulation for MacOSEmulation {
                         mouse_location.x = new_mouse_x;
                         mouse_location.y = new_mouse_y;
 
-                        // If any button is held, emit a drag event for it;
-                        // otherwise emit a normal mouse-moved event.
-                        let event_type = self
-                            .pressed_buttons
-                            .iter()
-                            .next()
-                            .map(|&btn| drag_event_type(btn))
-                            .unwrap_or(CGEventType::MouseMoved);
+                        let mut event_type = CGEventType::MouseMoved;
+                        if self.button_state.left {
+                            event_type = CGEventType::LeftMouseDragged
+                        } else if self.button_state.right {
+                            event_type = CGEventType::RightMouseDragged
+                        } else if self.button_state.center {
+                            event_type = CGEventType::OtherMouseDragged
+                        };
                         let event = match CGEvent::new_mouse_event(
                             self.event_source.clone(),
                             event_type,
@@ -270,12 +290,6 @@ impl Emulation for MacOSEmulation {
                         button,
                         state,
                     } => {
-                        // button number for OtherMouse events (3 = back, 4 = forward, etc.)
-                        let cg_button_number: Option<i64> = match button {
-                            BTN_BACK => Some(3),
-                            BTN_FORWARD => Some(4),
-                            _ => None,
-                        };
                         let (event_type, mouse_button) = match (button, state) {
                             (BTN_LEFT, 1) => (CGEventType::LeftMouseDown, CGMouseButton::Left),
                             (BTN_LEFT, 0) => (CGEventType::LeftMouseUp, CGMouseButton::Left),
@@ -283,29 +297,17 @@ impl Emulation for MacOSEmulation {
                             (BTN_RIGHT, 0) => (CGEventType::RightMouseUp, CGMouseButton::Right),
                             (BTN_MIDDLE, 1) => (CGEventType::OtherMouseDown, CGMouseButton::Center),
                             (BTN_MIDDLE, 0) => (CGEventType::OtherMouseUp, CGMouseButton::Center),
-                            (BTN_BACK, 1) | (BTN_FORWARD, 1) => {
-                                (CGEventType::OtherMouseDown, CGMouseButton::Center)
-                            }
-                            (BTN_BACK, 0) | (BTN_FORWARD, 0) => {
-                                (CGEventType::OtherMouseUp, CGMouseButton::Center)
-                            }
                             _ => {
                                 log::warn!("invalid button event: {button},{state}");
                                 return Ok(());
                             }
                         };
-                        // store button state using the evdev button code so
-                        // back, forward, and middle are tracked independently
-                        if state == 1 {
-                            self.pressed_buttons.insert(button);
-                        } else {
-                            self.pressed_buttons.remove(&button);
-                        }
+                        // store button state
+                        self.button_state[mouse_button] = state == 1;
 
-                        // update double-click tracking using the evdev button
-                        // code so that back/forward don't alias with middle
+                        // update previous button state
                         if state == 1 {
-                            if self.previous_button == Some(button)
+                            if self.previous_button.is_some_and(|b| b.eq(&mouse_button))
                                 && self
                                     .previous_button_click
                                     .is_some_and(|i| i.elapsed() < DOUBLE_CLICK_INTERVAL)
@@ -314,7 +316,7 @@ impl Emulation for MacOSEmulation {
                             } else {
                                 self.button_click_state = 1;
                             }
-                            self.previous_button = Some(button);
+                            self.previous_button = Some(mouse_button);
                             self.previous_button_click = Some(Instant::now());
                         }
 
@@ -336,13 +338,6 @@ impl Emulation for MacOSEmulation {
                             EventField::MOUSE_EVENT_CLICK_STATE,
                             self.button_click_state,
                         );
-                        // Set the button number for extra buttons (back=3, forward=4)
-                        if let Some(btn_num) = cg_button_number {
-                            event.set_integer_value_field(
-                                EventField::MOUSE_EVENT_BUTTON_NUMBER,
-                                btn_num,
-                            );
-                        }
                         event.post(CGEventTapLocation::HID);
                     }
                     PointerEvent::Axis {
@@ -421,10 +416,7 @@ impl Emulation for MacOSEmulation {
                             return Ok(());
                         }
                     };
-                    let is_modifier = update_modifiers(&self.modifier_state, key, state);
-                    if is_modifier {
-                        modifier_event(self.event_source.clone(), self.modifier_state.get());
-                    }
+                    update_modifiers(&self.modifier_state, key, state);
                     match state {
                         // pressed
                         1 => self.spawn_repeat_task(code).await,
@@ -453,6 +445,21 @@ impl Emulation for MacOSEmulation {
     async fn terminate(&mut self) {}
 }
 
+trait ButtonEq {
+    fn eq(&self, other: &Self) -> bool;
+}
+
+impl ButtonEq for CGMouseButton {
+    fn eq(&self, other: &Self) -> bool {
+        matches!(
+            (self, other),
+            (CGMouseButton::Left, CGMouseButton::Left)
+                | (CGMouseButton::Right, CGMouseButton::Right)
+                | (CGMouseButton::Center, CGMouseButton::Center)
+        )
+    }
+}
+
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
     if let Ok(key) = scancode::Linux::try_from(key) {
         let mask = match key {

input-emulation/src/xdg_desktop_portal.rs

@@ -1,10 +1,7 @@
 use ashpd::{
     desktop::{
         PersistMode, Session,
-        remote_desktop::{
-            Axis, DeviceType, KeyState, NotifyPointerAxisOptions, RemoteDesktop,
-            SelectDevicesOptions,
-        },
+        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
     },
     zbus::AsyncDrop,
 };
@@ -32,19 +29,20 @@ impl DesktopPortalEmulation {
 
         // retry when user presses the cancel button
         log::debug!("creating session ...");
-        let session = proxy.create_session(Default::default()).await?;
+        let session = proxy.create_session().await?;
 
         log::debug!("selecting devices ...");
-        let options = SelectDevicesOptions::default()
-            .set_devices(DeviceType::Keyboard | DeviceType::Pointer)
-            .set_persist_mode(PersistMode::ExplicitlyRevoked);
-        proxy.select_devices(&session, options).await?;
+        proxy
+            .select_devices(
+                &session,
+                DeviceType::Keyboard | DeviceType::Pointer,
+                None,
+                PersistMode::ExplicitlyRevoked,
+            )
+            .await?;
 
         log::info!("requesting permission for input emulation");
-        let _devices = proxy
-            .start(&session, None, Default::default())
-            .await?
-            .response()?;
+        let _devices = proxy.start(&session, None).await?.response()?;
 
         log::debug!("started session");
         let session = session;
@@ -64,7 +62,7 @@ impl Emulation for DesktopPortalEmulation {
             Pointer(p) => match p {
                 PointerEvent::Motion { time: _, dx, dy } => {
                     self.proxy
-                        .notify_pointer_motion(&self.session, dx, dy, Default::default())
+                        .notify_pointer_motion(&self.session, dx, dy)
                         .await?;
                 }
                 PointerEvent::Button {
@@ -77,12 +75,7 @@ impl Emulation for DesktopPortalEmulation {
                         _ => KeyState::Pressed,
                     };
                     self.proxy
-                        .notify_pointer_button(
-                            &self.session,
-                            button as i32,
-                            state,
-                            Default::default(),
-                        )
+                        .notify_pointer_button(&self.session, button as i32, state)
                         .await?;
                 }
                 PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -91,12 +84,7 @@ impl Emulation for DesktopPortalEmulation {
                         _ => Axis::Horizontal,
                     };
                     self.proxy
-                        .notify_pointer_axis_discrete(
-                            &self.session,
-                            axis,
-                            value / 120,
-                            Default::default(),
-                        )
+                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
                         .await?;
                 }
                 PointerEvent::Axis {
@@ -113,12 +101,7 @@ impl Emulation for DesktopPortalEmulation {
                         Axis::Horizontal => (value, 0.),
                     };
                     self.proxy
-                        .notify_pointer_axis(
-                            &self.session,
-                            dx,
-                            dy,
-                            NotifyPointerAxisOptions::default().set_finish(true),
-                        )
+                        .notify_pointer_axis(&self.session, dx, dy, true)
                         .await?;
                 }
             },
@@ -134,12 +117,7 @@ impl Emulation for DesktopPortalEmulation {
                             _ => KeyState::Pressed,
                         };
                         self.proxy
-                            .notify_keyboard_keycode(
-                                &self.session,
-                                key as i32,
-                                state,
-                                Default::default(),
-                            )
+                            .notify_keyboard_keycode(&self.session, key as i32, state)
                             .await?;
                     }
                     KeyboardEvent::Modifiers { .. } => {

lan-mouse-gtk/Cargo.toml

@@ -8,20 +8,14 @@ repository = "https://github.com/feschber/lan-mouse"
 
 [dependencies]
 gtk = { package = "gtk4", version = "0.9.0", features = ["v4_2"] }
+gdk4_wayland = { package = "gdk4-wayland", version="0.9.6" }
 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.2.0" }
 thiserror = "2.0.0"
-
-[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-gdk4_wayland = { package = "gdk4-wayland", version="0.9.6", optional=true }
+wayland-client = "0.31.12"
 
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
-
-
-[features]
-default = ["wayland_window_identifier"]
-wayland_window_identifier = ["dep:gdk4_wayland"]

lan-mouse-gtk/src/lib.rs

@@ -19,7 +19,6 @@ use gtk::{gio, glib, prelude::ApplicationExt};
 use self::client_object::ClientObject;
 use self::key_object::KeyObject;
 
-#[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
 use gdk4_wayland::WaylandToplevel;
 
 use thiserror::Error;
@@ -129,7 +128,6 @@ fn build_ui(app: &Application) {
 
     // export TopLevel handle and send it to the service so that it can put the InpuCapture / RemoteDesktop
     // windows on top of it using xdg-foreign.
-    #[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
     window.connect_show(|window| {
         // needs the surface so we have to present first!
         if let Some(surface) = window.surface() {

nix/default.nix

@@ -1,40 +1,34 @@
 {
-  stdenv,
   rustPlatform,
   lib,
-  pkg-config,
-  libX11,
-  gtk4,
-  libadwaita,
-  libXtst,
-  wrapGAppsHook4,
-  librsvg,
-  git,
-}:
-let
-  cargoToml = fromTOML (builtins.readFile ../Cargo.toml);
+  pkgs,
+}: let
+  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
   pname = cargoToml.package.name;
   version = cargoToml.package.version;
 in
 rustPlatform.buildRustPackage {
-  inherit pname;
-  inherit version;
+  pname = pname;
+  version = version;
 
-  nativeBuildInputs = [
-    pkg-config
-    wrapGAppsHook4
+  nativeBuildInputs = with pkgs; [
     git
+    pkg-config
+    cmake
+    makeWrapper
+    buildPackages.gtk4
   ];
 
-  buildInputs = [
+  buildInputs = with pkgs; [
+    xorg.libX11
     gtk4
     libadwaita
-    librsvg
-  ]
-  ++ lib.optionals stdenv.isLinux [
-    libX11
-    libXtst
-  ];
+    xorg.libXtst
+  ] ++ lib.optionals stdenv.isDarwin
+  (with darwin.apple_sdk_11_0.frameworks; [
+    CoreGraphics
+    ApplicationServices
+  ]);
 
   src = builtins.path {
     name = pname;
@@ -46,7 +40,11 @@ rustPlatform.buildRustPackage {
   # Set Environment Variables
   RUST_BACKTRACE = "full";
 
+  # Needed to enable support for SVG icons in GTK
   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
   '';

scripts/makeicns.sh

@@ -29,13 +29,13 @@ iconset="${3:-./target/icon.iconset}"
 set -u
 
 mkdir -p "$iconset"
-magick "$svg" -background none -resize 1024x1024 "$iconset"/icon_512x512@2x.png
-magick "$svg" -background none -resize 512x512 "$iconset"/icon_512x512.png
-magick "$svg" -background none -resize 256x256 "$iconset"/icon_256x256.png
-magick "$svg" -background none -resize 128x128 "$iconset"/icon_128x128.png
-magick "$svg" -background none -resize 64x64 "$iconset"/icon_32x32@2x.png
-magick "$svg" -background none -resize 32x32 "$iconset"/icon_32x32.png
-magick "$svg" -background none -resize 16x16 "$iconset"/icon_16x16.png
+magick convert -background none -resize 1024x1024 "$svg" "$iconset"/icon_512x512@2x.png
+magick convert -background none -resize 512x512 "$svg" "$iconset"/icon_512x512.png
+magick convert -background none -resize 256x256 "$svg" "$iconset"/icon_256x256.png
+magick convert -background none -resize 128x128 "$svg" "$iconset"/icon_128x128.png
+magick convert -background none -resize 64x64 "$svg" "$iconset"/icon_32x32@2x.png
+magick convert -background none -resize 32x32 "$svg" "$iconset"/icon_32x32.png
+magick convert -background none -resize 16x16 "$svg" "$iconset"/icon_16x16.png
 cp "$iconset"/icon_512x512.png "$iconset"/icon_256x256@2x.png
 cp "$iconset"/icon_256x256.png "$iconset"/icon_128x128@2x.png
 cp "$iconset"/icon_32x32.png "$iconset"/icon_16x16@2x.png

src/config.rs

@@ -432,7 +432,7 @@ impl Config {
             return;
         }
         if self.config_toml.is_none() {
-            self.config_toml = Some(Default::default());
+            self.config_toml = Default::default();
         }
         self.config_toml
             .as_mut()