fix ashpd?!

.github/workflows/cachix.yml

@@ -7,7 +7,7 @@ jobs:
       matrix:
        os: 
         - ubuntu-latest
-        - macos-15-intel
+        - macos-13
         - macos-14
     name: "Build"
     runs-on: ${{ matrix.os }} 
@@ -31,7 +31,7 @@ jobs:
       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'
+      if: matrix.os == 'macos-13'
       run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
 
     - name: Build lan-mouse (aarch64-darwin)

.github/workflows/pre-release.yml

@@ -80,7 +80,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-15-intel
+    runs-on: macos-13
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
@@ -94,9 +94,7 @@ jobs:
     - 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"
+      run: cargo bundle --release
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -122,9 +120,7 @@ jobs:
     - 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"
+      run: cargo bundle --release
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.github/workflows/rust.yml

@@ -10,87 +10,145 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  fmt:
-    name: Formatting
+  build-linux:
+
     runs-on: ubuntu-latest
+
     steps:
-      - uses: actions/checkout@v4
-      - name: cargo fmt
-        run: cargo fmt --check
+    - 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: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse
+        path: target/debug/lan-mouse
+
+  build-windows:
+
+    runs-on: windows-latest
 
-  ci:
-    name: ${{ matrix.job }} ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
-          - macos-15-intel
-        job:
-          - build
-          - check
-          - clippy
-          - test
     steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-      - name: Install Linux deps
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev
-      - name: Install macOS dependencies
-        if: runner.os == 'macOS'
-        run: brew install gtk4 libadwaita imagemagick
-      - name: Install Windows Dependencies - create gtk dir
-        if: runner.os == 'Windows'
-        run: mkdir C:\gtk-build\gtk\x64\release
-      - name: Install Windows Dependencies - install gtk from cache
-        uses: actions/cache@v3
-        if: runner.os == 'Windows'
-        id: cache
-        with:
-          path: c:/gtk-build/gtk/x64/release/**
-          key: gtk-windows-build
-          restore-keys: gtk-windows-build
-      - name: Install Windows Dependencies - update PATH
-        if: runner.os == 'Windows'
-        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 Windows dependencies - build gtk
-        if: runner.os == 'Windows' && 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
-          gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
-      - name: cargo build
-        if: matrix.job == 'build'
-        run: cargo check --workspace --all-targets --all-features
+    - uses: actions/checkout@v4
+    - 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"
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Copy Gtk Dlls
+      run: Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "target\\debug"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-windows
+        path: |
+          target/debug/lan-mouse.exe
+          target/debug/*.dll
 
-      - name: cargo check
-        if: matrix.job == 'check'
-        run: cargo check --workspace --all-targets --all-features
+  build-macos:
+    runs-on: macos-13
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle
+    - name: Zip bundle
+      run: |
+        cd target/debug/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)
+        path: target/debug/bundle/osx/Lan Mouse macOS (Intel).zip
 
-      - name: cargo test
-        if: matrix.job == 'test'
-        run: cargo test --workspace --all-features
-
-      - name: cargo clippy
-        if: matrix.job == 'clippy'
-        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
-
-      - uses: clechasseur/rs-clippy-check@v4
-        if: matrix.job == 'clippy'
-        with:
-          args: --workspace --all-targets --all-features
+  build-macos-aarch64:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle
+    - name: Zip bundle
+      run: |
+        cd target/debug/bundle/osx
+        zip -r "Lan Mouse macOS (ARM).zip" "Lan Mouse.app"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: Lan Mouse macOS (ARM)
+        path: target/debug/bundle/osx/Lan Mouse macOS (ARM).zip

.github/workflows/tagged-release.yml

@@ -76,7 +76,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-15-intel
+    runs-on: macos-13
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
@@ -90,9 +90,7 @@ jobs:
     - 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"
+      run: cargo bundle --release
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -118,9 +116,7 @@ jobs:
     - 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"
+      run: cargo bundle --release
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.gitignore

@@ -8,7 +8,3 @@ result
 *.pem
 *.csr
 extfile.conf
-
-# flatpak files
-.flatpak-builder
-repo

.rustfmt.toml

@@ -1,4 +0,0 @@
-style_edition = "2024"
-
-max_width = 100
-tab_spaces = 4

Cargo.lock

@@ -1872,7 +1872,6 @@ dependencies = [
  "tokio",
  "tokio-util",
  "toml",
- "toml_edit",
  "webrtc-dtls",
  "webrtc-util",
 ]

Cargo.toml

@@ -38,7 +38,6 @@ shadow-rs = { version = "1.2.0", features = ["metadata"] }
 
 hickory-resolver = "0.25.2"
 toml = "0.8"
-toml_edit = { version = "0.22", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
 env_logger = "0.11.3"

README.md

@@ -81,37 +81,15 @@ paru -S lan-mouse-git
 - flake: [README.md](./nix/README.md)
 </details>
 
-<details>
-    <summary>Fedora</summary>
-You can install Lan Mouse from the [Terra Repository](https://terra.fyralabs.com).
-
-
-After enabling Terra:
-
-```sh
-dnf install lan-mouse
-```
-</details>
-
-<details>
-    <summary>MacOS</summary>
-
-- Download the package for your Mac (Intel or ARM) from the releases page
-- Unzip it
-- Remove the quarantine with `xattr -rd com.apple.quarantine "Lan Mouse.app"`
-- Launch the app
-- Grant accessibility permissions in System Preferences
-
-</details>
 
 
 <details>
     <summary>Manual Installation</summary>
 
-First make sure to [install the necessary dependencies](#installing-dependencies-for-development--compiling-from-source).
+First make sure to [install the necessary dependencies](#installing-dependencies).
 
 Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
-For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies-for-development--compiling-from-source).
+For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
 
 Alternatively, the `lan-mouse` binary can be compiled from source (see below).
 
@@ -183,15 +161,7 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
     <summary>MacOS</summary>
 
 ```sh
-# Install dependencies
-brew install libadwaita pkg-config imagemagick
-cargo install cargo-bundle
-# Create the macOS icon file
-scripts/makeicns.sh
-# Create the .app bundle
-cargo bundle
-# Copy all dynamic libraries into the bundle, and update the bundle to find them there
-scripts/copy-macos-dylib.sh
+brew install libadwaita pkg-config
 ```
 </details>
 
@@ -321,9 +291,6 @@ To do so, use the `daemon` subcommand:
 ```sh
 lan-mouse daemon
 ```
-</details>
-
-## Systemd Service
 
 In order to start lan-mouse with a graphical session automatically,
 the [systemd-service](service/lan-mouse.service) can be used:
@@ -335,9 +302,7 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
-> [!Important]
-> Make sure to point `ExecStart=/usr/bin/lan-mouse daemon` to the actual `lan-mouse` binary (in case it is not under `/usr/bin`, e.g. when installed manually.
-
+</details>
 
 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.

build-aux/de.feschber.LanMouse.yml

@@ -1,50 +0,0 @@
-# yaml-language-server: $schema=https://raw.githubusercontent.com/flatpak/flatpak-builder/refs/heads/main/data/flatpak-manifest.schema.json
-app-id: de.feschber.LanMouse
-runtime: org.gnome.Platform
-runtime-version: "48"
-sdk: org.gnome.Sdk
-sdk-extensions:
-  - org.freedesktop.Sdk.Extension.rust-stable
-  - org.freedesktop.Sdk.Extension.llvm20
-command: /app/bin/lan-mouse
-build-options:
-  append-path: "/usr/lib/sdk/rust-stable/bin:/usr/lib/sdk/llvm20/bin"
-  env:
-    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER": "clang"
-    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS": "-C link-arg=-fuse-ld=/usr/lib/sdk/rust-stable/bin/mold"
-    "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER": "clang"
-    "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUSTFLAGS": "-C link-arg=-fuse-ld=/usr/lib/sdk/rust-stable/bin/mold"
-    build-args:
-      "--share=network"
-    prepend-ld-library-path:
-      "/usr/lib/sdk/llvm19/lib"
-
-finish-args:
-  - "--socket=wayland"
-  - "--socket=fallback-x11"
-  - "--device=dri"
-  - "--socket=session-bus"
-  - "--share=network"
-  - "--filesystem=xdg-config"
-  - "--env=RUST_BACKTRACE=1"
-  - "--env=RUST_LOG=lan-mouse=debug"
-  - "--env=GTK_PATH=/app/lib/gtk-4.0"
-
-modules:
-  - name: lan-mouse
-    buildsystem: simple
-    build-options:
-      build-args:
-        - "--share=network"
-      append-path: /usr/lib/sdk/rust-stable/bin
-      env:
-        CARGO_HOME: /run/build/lan-mouse/cargo
-    build-commands:
-      - cargo fetch --manifest-path Cargo.toml --verbose
-      - cargo build
-      - install -Dm0755 target/debug/lan-mouse /app/bin/lan-mouse
-      - install -Dm0644 lan-mouse-gtk/resources/de.feschber.LanMouse.svg ${FLATPAK_DEST}/share/icons/hicolor/scalable/apps/${FLATPAK_ID}.svg
-      - install -Dm0644 de.feschber.LanMouse.desktop ${FLATPAK_DEST}/share/applications/${FLATPAK_ID}.desktop
-    sources:
-      - type: dir
-        path: ..

de.feschber.LanMouse.yml

@@ -0,0 +1,14 @@
+app-id: de.feschber.LanMouse
+runtime: org.freedesktop.Platform
+runtime-version: '22.08'
+sdk: org.freedesktop.Sdk
+command: target/release/lan-mouse
+modules:
+  - name: hello
+    buildsystem: simple
+    build-commands:
+      - cargo build --release
+      - install -D lan-mouse /app/bin/lan-mouse
+    sources:
+      - type: file
+        path: target/release/lan-mouse

dylibs/.gitignore

@@ -1 +0,0 @@
-*

input-capture/Cargo.toml

@@ -23,7 +23,6 @@ tokio = { version = "1.32.0", features = [
     "rt",
     "sync",
     "signal",
-    "time",
 ] }
 once_cell = "1.19.0"
 async-trait = "0.1.81"

input-capture/src/dummy.rs

@@ -1,6 +1,6 @@
 use std::f64::consts::PI;
 use std::pin::Pin;
-use std::task::{Context, Poll, ready};
+use std::task::{ready, Context, Poll};
 use std::time::Duration;
 
 use async_trait::async_trait;

input-capture/src/error.rs

@@ -12,9 +12,9 @@ pub enum InputCaptureError {
 use std::io;
 #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
 use wayland_client::{
-    ConnectError, DispatchError,
     backend::WaylandError,
     globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
 };
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]

input-capture/src/layer_shell.rs

@@ -7,7 +7,7 @@ use std::{
     io::{self, ErrorKind},
     os::fd::{AsFd, RawFd},
     pin::Pin,
-    task::{Context, Poll, ready},
+    task::{ready, Context, Poll},
 };
 use tokio::io::unix::AsyncFd;
 
@@ -45,10 +45,9 @@ use wayland_protocols_wlr::layer_shell::v1::client::{
 };
 
 use wayland_client::{
-    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
     backend::{ReadEventsGuard, WaylandError},
     delegate_noop,
-    globals::{Global, GlobalList, GlobalListContents, registry_queue_init},
+    globals::{registry_queue_init, Global, GlobalList, GlobalListContents},
     protocol::{
         wl_buffer, wl_compositor,
         wl_keyboard::{self, WlKeyboard},
@@ -59,6 +58,7 @@ use wayland_client::{
         wl_seat, wl_shm, wl_shm_pool,
         wl_surface::WlSurface,
     },
+    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
 
 use input_event::{Event, KeyboardEvent, PointerEvent};
@@ -66,8 +66,8 @@ use input_event::{Event, KeyboardEvent, PointerEvent};
 use crate::{CaptureError, CaptureEvent};
 
 use super::{
-    Capture, Position,
     error::{LayerShellCaptureCreationError, WaylandBindError},
+    Capture, Position,
 };
 
 struct Globals {

input-capture/src/lib.rs

@@ -2,14 +2,14 @@ use std::{
     collections::{HashMap, HashSet, VecDeque},
     fmt::Display,
     mem::swap,
-    task::{Poll, ready},
+    task::{ready, Poll},
 };
 
 use async_trait::async_trait;
 use futures::StreamExt;
 use futures_core::Stream;
 
-use input_event::{Event, KeyboardEvent, scancode};
+use input_event::{scancode, Event, KeyboardEvent};
 
 pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
 

input-capture/src/libei.rs

@@ -1,10 +1,10 @@
 use ashpd::{
     desktop::{
-        Session,
         input_capture::{
             Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
             Zones,
         },
+        Session,
     },
     enumflags2::BitFlags,
 };
@@ -28,8 +28,8 @@ use std::{
 };
 use tokio::{
     sync::{
-        Notify,
         mpsc::{self, Receiver, Sender},
+        Notify,
     },
     task::JoinHandle,
 };
@@ -42,8 +42,8 @@ use input_event::Event;
 use crate::CaptureEvent;
 
 use super::{
-    Capture as LanMouseInputCapture, Position,
     error::{CaptureError, LibeiCaptureCreationError},
+    Capture as LanMouseInputCapture, Position,
 };
 
 /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that

input-capture/src/macos.rs

@@ -1,40 +1,31 @@
-use super::{Capture, CaptureError, CaptureEvent, Position, error::MacosCaptureCreationError};
+use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
 use async_trait::async_trait;
 use bitflags::bitflags;
-use core_foundation::{
-    base::{CFRelease, kCFAllocatorDefault},
-    date::CFTimeInterval,
-    number::{CFBooleanRef, kCFBooleanTrue},
-    runloop::{CFRunLoop, CFRunLoopSource, kCFRunLoopCommonModes},
-    string::{CFStringCreateWithCString, CFStringRef, kCFStringEncodingUTF8},
-};
-use core_graphics::{
-    base::{CGError, kCGErrorSuccess},
-    display::{CGDisplay, CGPoint},
-    event::{
-        CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions,
-        CGEventTapPlacement, CGEventTapProxy, CGEventType, CallbackResult, EventField,
-    },
-    event_source::{CGEventSource, CGEventSourceStateID},
+use core_foundation::base::{kCFAllocatorDefault, CFRelease};
+use core_foundation::date::CFTimeInterval;
+use core_foundation::number::{kCFBooleanTrue, CFBooleanRef};
+use core_foundation::runloop::{kCFRunLoopCommonModes, CFRunLoop, CFRunLoopSource};
+use core_foundation::string::{kCFStringEncodingUTF8, CFStringCreateWithCString, CFStringRef};
+use core_graphics::base::{kCGErrorSuccess, CGError};
+use core_graphics::display::{CGDisplay, CGPoint};
+use core_graphics::event::{
+    CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
+    CGEventTapProxy, CGEventType, CallbackResult, EventField,
 };
+use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
-use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
-use std::{
-    collections::HashSet,
-    ffi::{CString, c_char},
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll, ready},
-    thread::{self},
-};
-use tokio::sync::{
-    Mutex,
-    mpsc::{self, Receiver, Sender},
-    oneshot,
-};
+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::{self, Receiver, Sender};
+use tokio::sync::{oneshot, Mutex};
 
 #[derive(Debug, Default)]
 struct Bounds {
@@ -46,16 +37,9 @@ struct Bounds {
 
 #[derive(Debug)]
 struct InputCaptureState {
-    /// active capture positions
     active_clients: Lazy<HashSet<Position>>,
-    /// the currently entered capture position, if any
     current_pos: Option<Position>,
-    /// position where the cursor was captured
-    enter_position: Option<CGPoint>,
-    /// bounds of the input capture area
     bounds: Bounds,
-    /// current state of modifier keys
-    modifier_state: XMods,
 }
 
 #[derive(Debug)]
@@ -72,9 +56,7 @@ impl InputCaptureState {
         let mut res = Self {
             active_clients: Lazy::new(HashSet::new),
             current_pos: None,
-            enter_position: None,
             bounds: Bounds::default(),
-            modifier_state: Default::default(),
         };
         res.update_bounds()?;
         Ok(res)
@@ -114,34 +96,45 @@ impl InputCaptureState {
         Ok(())
     }
 
-    /// start the input capture by
-    fn start_capture(&mut self, event: &CGEvent, position: Position) -> Result<(), CaptureError> {
-        let mut location = event.location();
-        let edge_offset = 1.0;
-        // move cursor location to display bounds
-        match position {
-            Position::Left => location.x = self.bounds.xmin + edge_offset,
-            Position::Right => location.x = self.bounds.xmax - edge_offset,
-            Position::Top => location.y = self.bounds.ymin + edge_offset,
-            Position::Bottom => location.y = self.bounds.ymax - edge_offset,
-        };
-        self.enter_position = Some(location);
-        self.reset_cursor()
-    }
+    // We can't disable mouse movement when in a client so we need to reset the cursor position
+    // 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_pos {
+            let location = event.location();
+            let edge_offset = 1.0;
 
-    /// resets the cursor to the position, where the capture started
-    fn reset_cursor(&mut self) -> Result<(), CaptureError> {
-        let pos = self.enter_position.expect("capture active");
-        log::trace!("Resetting cursor position to: {}, {}", pos.x, pos.y);
-        CGDisplay::warp_mouse_cursor_position(pos).map_err(CaptureError::WarpCursor)
-    }
+            // After the cursor is warped no event is produced but the next event
+            // will carry the delta from the warp so only half the delta is needed to move the cursor
+            let delta_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y) / 2.0;
+            let delta_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X) / 2.0;
 
-    fn hide_cursor(&self) -> Result<(), CaptureError> {
-        CGDisplay::hide_cursor(&CGDisplay::main()).map_err(CaptureError::CoreGraphics)
-    }
+            let mut new_x = location.x + delta_x;
+            let mut new_y = location.y + delta_y;
 
-    fn show_cursor(&self) -> Result<(), CaptureError> {
-        CGDisplay::show_cursor(&CGDisplay::main()).map_err(CaptureError::CoreGraphics)
+            match pos {
+                Position::Left => {
+                    new_x = self.bounds.xmin + edge_offset;
+                }
+                Position::Right => {
+                    new_x = self.bounds.xmax - edge_offset;
+                }
+                Position::Top => {
+                    new_y = self.bounds.ymin + edge_offset;
+                }
+                Position::Bottom => {
+                    new_y = self.bounds.ymax - edge_offset;
+                }
+            }
+            let new_pos = CGPoint::new(new_x, new_y);
+
+            log::trace!("Resetting cursor position to: {new_x}, {new_y}");
+
+            return CGDisplay::warp_mouse_cursor_position(new_pos)
+                .map_err(CaptureError::WarpCursor);
+        }
+
+        Err(CaptureError::ResetMouseWithoutClient)
     }
 
     async fn handle_producer_event(
@@ -152,13 +145,15 @@ impl InputCaptureState {
         match producer_event {
             ProducerEvent::Release => {
                 if self.current_pos.is_some() {
-                    self.show_cursor()?;
+                    CGDisplay::show_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
                     self.current_pos = None;
                 }
             }
             ProducerEvent::Grab(pos) => {
                 if self.current_pos.is_none() {
-                    self.hide_cursor()?;
+                    CGDisplay::hide_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
                     self.current_pos = Some(pos);
                 }
             }
@@ -168,7 +163,8 @@ impl InputCaptureState {
             ProducerEvent::Destroy(p) => {
                 if let Some(current) = self.current_pos {
                     if current == p {
-                        self.show_cursor()?;
+                        CGDisplay::show_cursor(&CGDisplay::main())
+                            .map_err(CaptureError::CoreGraphics)?;
                         self.current_pos = None;
                     };
                 }
@@ -184,7 +180,6 @@ fn get_events(
     ev_type: &CGEventType,
     ev: &CGEvent,
     result: &mut Vec<CaptureEvent>,
-    modifier_state: &mut XMods,
 ) -> Result<(), CaptureError> {
     fn map_pointer_event(ev: &CGEvent) -> PointerEvent {
         PointerEvent::Motion {
@@ -220,42 +215,29 @@ fn get_events(
             })));
         }
         CGEventType::FlagsChanged => {
-            let mut depressed = XMods::empty();
+            let mut mods = XMods::empty();
             let mut mods_locked = XMods::empty();
             let cg_flags = ev.get_flags();
 
             if cg_flags.contains(CGEventFlags::CGEventFlagShift) {
-                depressed |= XMods::ShiftMask;
+                mods |= XMods::ShiftMask;
             }
             if cg_flags.contains(CGEventFlags::CGEventFlagControl) {
-                depressed |= XMods::ControlMask;
+                mods |= XMods::ControlMask;
             }
             if cg_flags.contains(CGEventFlags::CGEventFlagAlternate) {
-                depressed |= XMods::Mod1Mask;
+                mods |= XMods::Mod1Mask;
             }
             if cg_flags.contains(CGEventFlags::CGEventFlagCommand) {
-                depressed |= XMods::Mod4Mask;
+                mods |= XMods::Mod4Mask;
             }
             if cg_flags.contains(CGEventFlags::CGEventFlagAlphaShift) {
-                depressed |= XMods::LockMask;
+                mods |= XMods::LockMask;
                 mods_locked |= XMods::LockMask;
             }
 
-            // check if pressed or released
-            let state = if depressed > *modifier_state { 1 } else { 0 };
-            *modifier_state = depressed;
-
-            if let Ok(key) = map_key(ev) {
-                let key_event = CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
-                    time: 0,
-                    key,
-                    state,
-                }));
-                result.push(key_event);
-            }
-
             let modifier_event = KeyboardEvent::Modifiers {
-                depressed: depressed.bits(),
+                depressed: mods.bits(),
                 latched: 0,
                 locked: mods_locked.bits(),
                 group: 0,
@@ -318,47 +300,21 @@ fn get_events(
             })))
         }
         CGEventType::ScrollWheel => {
-            if ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_IS_CONTINUOUS) != 0 {
-                let v =
-                    ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
-                let h =
-                    ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
-                if v != 0 {
-                    result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
-                        time: 0,
-                        axis: 0, // Vertical
-                        value: v as f64,
-                    })));
-                }
-                if h != 0 {
-                    result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
-                        time: 0,
-                        axis: 1, // Horizontal
-                        value: h as f64,
-                    })));
-                }
-            } else {
-                // line based scrolling
-                const LINES_PER_STEP: i32 = 3;
-                const V120_STEPS_PER_LINE: i32 = 120 / LINES_PER_STEP;
-                let v = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_1);
-                let h = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_2);
-                if v != 0 {
-                    result.push(CaptureEvent::Input(Event::Pointer(
-                        PointerEvent::AxisDiscrete120 {
-                            axis: 0, // Vertical
-                            value: V120_STEPS_PER_LINE * v as i32,
-                        },
-                    )));
-                }
-                if h != 0 {
-                    result.push(CaptureEvent::Input(Event::Pointer(
-                        PointerEvent::AxisDiscrete120 {
-                            axis: 1, // Horizontal
-                            value: V120_STEPS_PER_LINE * h as i32,
-                        },
-                    )));
-                }
+            let v = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
+            let h = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
+            if v != 0 {
+                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
+                    time: 0,
+                    axis: 0, // Vertical
+                    value: v as f64,
+                })));
+            }
+            if h != 0 {
+                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
+                    time: 0,
+                    axis: 1, // Horizontal
+                    value: h as f64,
+                })));
             }
         }
         _ => (),
@@ -392,7 +348,7 @@ fn create_event_tap<'a>(
         move |_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 capture_position = None;
+            let mut pos = None;
             let mut res_events = vec![];
 
             if matches!(
@@ -409,34 +365,22 @@ fn create_event_tap<'a>(
 
             // Are we in a client?
             if let Some(current_pos) = state.current_pos {
-                capture_position = Some(current_pos);
-                get_events(
-                    &event_type,
-                    cg_ev,
-                    &mut res_events,
-                    &mut state.modifier_state,
-                )
-                .unwrap_or_else(|e| {
+                pos = Some(current_pos);
+                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
                     log::error!("Failed to get events: {e}");
                 });
 
                 // Keep (hidden) cursor at the edge of the screen
-                if matches!(
-                    event_type,
-                    CGEventType::MouseMoved
-                        | CGEventType::LeftMouseDragged
-                        | CGEventType::RightMouseDragged
-                        | CGEventType::OtherMouseDragged
-                ) {
-                    state.reset_cursor().unwrap_or_else(|e| log::warn!("{e}"));
+                if matches!(event_type, CGEventType::MouseMoved) {
+                    state.reset_mouse_position(cg_ev).unwrap_or_else(|e| {
+                        log::error!("Failed to reset mouse position: {e}");
+                    })
                 }
-            } else if matches!(event_type, CGEventType::MouseMoved) {
-                // Did we cross a barrier?
+            }
+            // Did we cross a barrier?
+            else if matches!(event_type, CGEventType::MouseMoved) {
                 if let Some(new_pos) = state.crossed(cg_ev) {
-                    capture_position = Some(new_pos);
-                    state
-                        .start_capture(cg_ev, new_pos)
-                        .unwrap_or_else(|e| log::warn!("{e}"));
+                    pos = Some(new_pos);
                     res_events.push(CaptureEvent::Begin);
                     notify_tx
                         .blocking_send(ProducerEvent::Grab(new_pos))
@@ -444,7 +388,7 @@ fn create_event_tap<'a>(
                 }
             }
 
-            if let Some(pos) = capture_position {
+            if let Some(pos) = pos {
                 res_events.iter().for_each(|e| {
                     // error must be ignored, since the event channel
                     // may already be closed when the InputCapture instance is dropped.
@@ -453,10 +397,8 @@ fn create_event_tap<'a>(
                 // Returning Drop should stop the event from being processed
                 // but core fundation still returns the event
                 cg_ev.set_type(CGEventType::Null);
-                CallbackResult::Drop
-            } else {
-                CallbackResult::Keep
             }
+            CallbackResult::Replace(cg_ev.to_owned())
         };
 
     let tap = CGEventTap::new(
@@ -551,7 +493,10 @@ impl MacOSInputCapture {
                             log::error!("Failed to handle producer event: {e}");
                         })
                     }
-                    _ = &mut tap_exit_rx => break,
+
+                    _ = &mut tap_exit_rx => {
+                        break;
+                    }
                 }
             }
             // show cursor
@@ -646,7 +591,6 @@ unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
     let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
         .map_err(|_| MacosCaptureCreationError::EventSourceCreation)?;
     CGEventSourceSetLocalEventsSuppressionInterval(event_source, 0.05);
-    // FIXME Memory Leak
 
     // This is a private settings that allows the cursor to be hidden while in the background.
     // It is used by Barrier and other apps.

input-capture/src/windows.rs

@@ -5,7 +5,7 @@ use futures::Stream;
 use std::pin::Pin;
 
 use std::task::ready;
-use tokio::sync::mpsc::{Receiver, channel};
+use tokio::sync::mpsc::{channel, Receiver};
 
 use super::{Capture, CaptureError, CaptureEvent, Position};
 

input-capture/src/windows/event_thread.rs

@@ -6,32 +6,33 @@ use std::default::Default;
 use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
-use tokio::sync::mpsc::Sender;
 use tokio::sync::mpsc::error::TrySendError;
+use tokio::sync::mpsc::Sender;
+use windows::core::{w, PCWSTR};
 use windows::Win32::Foundation::{FALSE, HWND, LPARAM, LRESULT, RECT, WPARAM};
 use windows::Win32::Graphics::Gdi::{
-    DEVMODEW, DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, DISPLAY_DEVICEW, ENUM_CURRENT_SETTINGS,
-    EnumDisplayDevicesW, EnumDisplaySettingsW,
+    EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
+    DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
 };
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
 use windows::Win32::System::Threading::GetCurrentThreadId;
-use windows::core::{PCWSTR, w};
 
 use windows::Win32::UI::WindowsAndMessaging::{
-    CallNextHookEx, CreateWindowExW, DispatchMessageW, EDD_GET_DEVICE_INTERFACE_NAME, GetMessageW,
-    HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, PostThreadMessageW,
-    RegisterClassW, SetWindowsHookExW, TranslateMessage, WH_KEYBOARD_LL, WH_MOUSE_LL, WINDOW_STYLE,
-    WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN,
-    WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN, WM_RBUTTONUP,
-    WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW, WNDPROC,
+    CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HOOKPROC,
+    KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL, WH_MOUSE_LL,
+    WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN, WM_LBUTTONUP,
+    WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
+    WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
+    WNDPROC,
 };
 
 use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
     scancode::{self, Linux},
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
-use super::{CaptureEvent, Position, display_util};
+use super::{display_util, CaptureEvent, Position};
 
 pub(crate) struct EventThread {
     request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,

input-capture/src/x11.rs

@@ -3,7 +3,7 @@ use std::task::Poll;
 use async_trait::async_trait;
 use futures_core::Stream;
 
-use super::{Capture, CaptureError, CaptureEvent, Position, error::X11InputCaptureCreationError};
+use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
 
 pub struct X11InputCapture {}
 

input-emulation/Cargo.toml

@@ -21,7 +21,6 @@ tokio = { version = "1.32.0", features = [
     "rt",
     "sync",
     "signal",
-    "time"
 ] }
 once_cell = "1.19.0"
 

input-emulation/src/error.rs

@@ -11,15 +11,15 @@ pub enum InputEmulationError {
     any(feature = "remote_desktop_portal", feature = "libei"),
     not(target_os = "macos")
 ))]
-use ashpd::{Error::Response, desktop::ResponseError};
+use ashpd::{desktop::ResponseError, Error::Response};
 use std::io;
 use thiserror::Error;
 
 #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
 use wayland_client::{
-    ConnectError, DispatchError,
     backend::WaylandError,
     globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
 };
 
 #[derive(Debug, Error)]

input-emulation/src/libei.rs

@@ -1,25 +1,25 @@
-use futures::{StreamExt, future};
+use futures::{future, StreamExt};
 use std::{
     io,
     os::{fd::OwnedFd, unix::net::UnixStream},
     sync::{
-        Arc, Mutex, RwLock,
         atomic::{AtomicBool, Ordering},
+        Arc, Mutex, RwLock,
     },
     time::{SystemTime, UNIX_EPOCH},
 };
 use tokio::task::JoinHandle;
 
 use ashpd::desktop::{
-    PersistMode, Session,
     remote_desktop::{DeviceType, RemoteDesktop},
+    PersistMode, Session,
 };
 use async_trait::async_trait;
 
 use reis::{
     ei::{
-        self, Button, Keyboard, Pointer, Scroll, button::ButtonState, handshake::ContextType,
-        keyboard::KeyState,
+        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
+        Pointer, Scroll,
     },
     event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
     tokio::EiConvertEventStream,
@@ -29,7 +29,7 @@ use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use crate::error::EmulationError;
 
-use super::{Emulation, EmulationHandle, error::LibeiEmulationCreationError};
+use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
 
 #[derive(Clone, Default)]
 struct Devices {
@@ -50,8 +50,8 @@ pub(crate) struct LibeiEmulation<'a> {
     session: Session<'a, RemoteDesktop<'a>>,
 }
 
-async fn get_ei_fd<'a>()
--> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
+async fn get_ei_fd<'a>(
+) -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
     let remote_desktop = RemoteDesktop::new().await?;
 
     log::debug!("creating session ...");

input-emulation/src/macos.rs

@@ -1,4 +1,4 @@
-use super::{Emulation, EmulationHandle, error::EmulationError};
+use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
 use bitflags::bitflags;
 use core_graphics::base::CGFloat;
@@ -10,37 +10,25 @@ use core_graphics::event::{
     ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent, scancode};
+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, Instant};
+use std::time::Duration;
 use tokio::{sync::Notify, task::JoinHandle};
 
 use super::error::MacOSEmulationCreationError;
 
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
-const DOUBLE_CLICK_INTERVAL: Duration = Duration::from_millis(500);
 
 pub(crate) struct MacOSEmulation {
-    /// global event source for all events
     event_source: CGEventSource,
-    /// task handle for key repeats
     repeat_task: Option<JoinHandle<()>>,
-    /// 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
-    button_click_state: i64,
-    /// current modifier state
     modifier_state: Rc<Cell<XMods>>,
-    /// notify to cancel key repeats
     notify_repeat_task: Arc<Notify>,
 }
 
@@ -86,9 +74,6 @@ impl MacOSEmulation {
         Ok(Self {
             event_source,
             button_state,
-            previous_button: None,
-            previous_button_click: None,
-            button_click_state: 0,
             repeat_task: None,
             notify_repeat_task: Arc::new(Notify::new()),
             modifier_state: Rc::new(Cell::new(XMods::empty())),
@@ -104,9 +89,6 @@ impl MacOSEmulation {
         // there can only be one repeating key and it's
         // always the last to be pressed
         self.cancel_repeat_task().await;
-        // initial key event
-        key_event(self.event_source.clone(), key, 1, self.modifier_state.get());
-        // repeat task
         let event_source = self.event_source.clone();
         let notify = self.notify_repeat_task.clone();
         let modifiers = self.modifier_state.clone();
@@ -242,167 +224,150 @@ impl Emulation for MacOSEmulation {
         event: Event,
         _handle: EmulationHandle,
     ) -> Result<(), EmulationError> {
-        log::trace!("{event:?}");
         match event {
-            Event::Pointer(pointer_event) => {
-                match pointer_event {
-                    PointerEvent::Motion { time: _, dx, dy } => {
-                        let mut mouse_location = match self.get_mouse_location() {
-                            Some(l) => l,
-                            None => {
-                                log::warn!("could not get mouse location!");
-                                return Ok(());
-                            }
-                        };
-
-                        let (new_mouse_x, new_mouse_y) =
-                            clamp_to_screen_space(mouse_location.x, mouse_location.y, dx, dy);
-
-                        mouse_location.x = new_mouse_x;
-                        mouse_location.y = new_mouse_y;
-
-                        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,
-                            mouse_location,
-                            CGMouseButton::Left,
-                        ) {
-                            Ok(e) => e,
-                            Err(_) => {
-                                log::warn!("mouse event creation failed!");
-                                return Ok(());
-                            }
-                        };
-                        event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_X, dx as i64);
-                        event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_Y, dy as i64);
-                        event.post(CGEventTapLocation::HID);
-                    }
-                    PointerEvent::Button {
-                        time: _,
-                        button,
-                        state,
-                    } => {
-                        let (event_type, mouse_button) = match (button, state) {
-                            (BTN_LEFT, 1) => (CGEventType::LeftMouseDown, CGMouseButton::Left),
-                            (BTN_LEFT, 0) => (CGEventType::LeftMouseUp, CGMouseButton::Left),
-                            (BTN_RIGHT, 1) => (CGEventType::RightMouseDown, CGMouseButton::Right),
-                            (BTN_RIGHT, 0) => (CGEventType::RightMouseUp, CGMouseButton::Right),
-                            (BTN_MIDDLE, 1) => (CGEventType::OtherMouseDown, CGMouseButton::Center),
-                            (BTN_MIDDLE, 0) => (CGEventType::OtherMouseUp, CGMouseButton::Center),
-                            _ => {
-                                log::warn!("invalid button event: {button},{state}");
-                                return Ok(());
-                            }
-                        };
-                        // store button state
-                        self.button_state[mouse_button] = state == 1;
-
-                        // update previous button state
-                        if state == 1 {
-                            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)
-                            {
-                                self.button_click_state += 1;
-                            } else {
-                                self.button_click_state = 1;
-                            }
-                            self.previous_button = Some(mouse_button);
-                            self.previous_button_click = Some(Instant::now());
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion { time: _, dx, dy } => {
+                    let mut mouse_location = match self.get_mouse_location() {
+                        Some(l) => l,
+                        None => {
+                            log::warn!("could not get mouse location!");
+                            return Ok(());
                         }
+                    };
 
-                        log::debug!("click_state: {}", self.button_click_state);
-                        let location = self.get_mouse_location().unwrap();
-                        let event = match CGEvent::new_mouse_event(
-                            self.event_source.clone(),
-                            event_type,
-                            location,
-                            mouse_button,
-                        ) {
-                            Ok(e) => e,
-                            Err(()) => {
-                                log::warn!("mouse event creation failed!");
-                                return Ok(());
-                            }
-                        };
-                        event.set_integer_value_field(
-                            EventField::MOUSE_EVENT_CLICK_STATE,
-                            self.button_click_state,
-                        );
-                        event.post(CGEventTapLocation::HID);
-                    }
-                    PointerEvent::Axis {
-                        time: _,
-                        axis,
-                        value,
-                    } => {
-                        let value = value as i32;
-                        let (count, wheel1, wheel2, wheel3) = match axis {
-                            0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
-                            1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
-                            _ => {
-                                log::warn!("invalid scroll event: {axis}, {value}");
-                                return Ok(());
-                            }
-                        };
-                        let event = match CGEvent::new_scroll_event(
-                            self.event_source.clone(),
-                            ScrollEventUnit::PIXEL,
-                            count,
-                            wheel1,
-                            wheel2,
-                            wheel3,
-                        ) {
-                            Ok(e) => e,
-                            Err(()) => {
-                                log::warn!("scroll event creation failed!");
-                                return Ok(());
-                            }
-                        };
-                        event.post(CGEventTapLocation::HID);
-                    }
-                    PointerEvent::AxisDiscrete120 { axis, value } => {
-                        const LINES_PER_STEP: i32 = 3;
-                        let (count, wheel1, wheel2, wheel3) = match axis {
-                            0 => (1, value / (120 / LINES_PER_STEP), 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
-                            1 => (2, 0, value / (120 / LINES_PER_STEP), 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
-                            _ => {
-                                log::warn!("invalid scroll event: {axis}, {value}");
-                                return Ok(());
-                            }
-                        };
-                        let event = match CGEvent::new_scroll_event(
-                            self.event_source.clone(),
-                            ScrollEventUnit::LINE,
-                            count,
-                            wheel1,
-                            wheel2,
-                            wheel3,
-                        ) {
-                            Ok(e) => e,
-                            Err(()) => {
-                                log::warn!("scroll event creation failed!");
-                                return Ok(());
-                            }
-                        };
-                        event.post(CGEventTapLocation::HID);
-                    }
-                }
+                    let (new_mouse_x, new_mouse_y) =
+                        clamp_to_screen_space(mouse_location.x, mouse_location.y, dx, dy);
 
-                // reset button click state in case it's not a button event
-                if !matches!(pointer_event, PointerEvent::Button { .. }) {
-                    self.button_click_state = 0;
+                    mouse_location.x = new_mouse_x;
+                    mouse_location.y = new_mouse_y;
+
+                    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,
+                        mouse_location,
+                        CGMouseButton::Left,
+                    ) {
+                        Ok(e) => e,
+                        Err(_) => {
+                            log::warn!("mouse event creation failed!");
+                            return Ok(());
+                        }
+                    };
+                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_X, dx as i64);
+                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_Y, dy as i64);
+                    event.post(CGEventTapLocation::HID);
                 }
-            }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let (event_type, mouse_button) = match (button, state) {
+                        (b, 1) if b == input_event::BTN_LEFT => {
+                            (CGEventType::LeftMouseDown, CGMouseButton::Left)
+                        }
+                        (b, 0) if b == input_event::BTN_LEFT => {
+                            (CGEventType::LeftMouseUp, CGMouseButton::Left)
+                        }
+                        (b, 1) if b == input_event::BTN_RIGHT => {
+                            (CGEventType::RightMouseDown, CGMouseButton::Right)
+                        }
+                        (b, 0) if b == input_event::BTN_RIGHT => {
+                            (CGEventType::RightMouseUp, CGMouseButton::Right)
+                        }
+                        (b, 1) if b == input_event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseDown, CGMouseButton::Center)
+                        }
+                        (b, 0) if b == input_event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseUp, CGMouseButton::Center)
+                        }
+                        _ => {
+                            log::warn!("invalid button event: {button},{state}");
+                            return Ok(());
+                        }
+                    };
+                    // store button state
+                    self.button_state[mouse_button] = state == 1;
+
+                    let location = self.get_mouse_location().unwrap();
+                    let event = match CGEvent::new_mouse_event(
+                        self.event_source.clone(),
+                        event_type,
+                        location,
+                        mouse_button,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("mouse event creation failed!");
+                            return Ok(());
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let value = value as i32;
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return Ok(());
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::PIXEL,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return Ok(());
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return Ok(());
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::PIXEL,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return Ok(());
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+            },
             Event::Keyboard(keyboard_event) => match keyboard_event {
                 KeyboardEvent::Key {
                     time: _,
@@ -416,12 +381,18 @@ impl Emulation for MacOSEmulation {
                             return Ok(());
                         }
                     };
-                    update_modifiers(&self.modifier_state, key, state);
                     match state {
                         // pressed
                         1 => self.spawn_repeat_task(code).await,
                         _ => self.cancel_repeat_task().await,
                     }
+                    update_modifiers(&self.modifier_state, key, state);
+                    key_event(
+                        self.event_source.clone(),
+                        code,
+                        state,
+                        self.modifier_state.get(),
+                    );
                 }
                 KeyboardEvent::Modifiers {
                     depressed,
@@ -445,21 +416,6 @@ 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/windows.rs

@@ -1,22 +1,22 @@
 use super::error::{EmulationError, WindowsEmulationCreationError};
 use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
-    scancode,
+    scancode, Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE,
+    BTN_RIGHT,
 };
 
 use async_trait::async_trait;
 use std::ops::BitOrAssign;
 use std::time::Duration;
 use tokio::task::AbortHandle;
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    SendInput, INPUT_0, KEYEVENTF_EXTENDEDKEY, MOUSEEVENTF_XDOWN, MOUSEEVENTF_XUP,
+};
 use windows::Win32::UI::Input::KeyboardAndMouse::{
     INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
     MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEDOWN,
     MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP,
     MOUSEEVENTF_WHEEL, MOUSEINPUT,
 };
-use windows::Win32::UI::Input::KeyboardAndMouse::{
-    INPUT_0, KEYEVENTF_EXTENDEDKEY, MOUSEEVENTF_XDOWN, MOUSEEVENTF_XUP, SendInput,
-};
 use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
 
 use super::{Emulation, EmulationHandle};

input-emulation/src/wlroots.rs

@@ -1,6 +1,6 @@
 use crate::error::EmulationError;
 
-use super::{Emulation, error::WlrootsEmulationCreationError};
+use super::{error::WlrootsEmulationCreationError, Emulation};
 use async_trait::async_trait;
 use bitflags::bitflags;
 use std::collections::HashMap;
@@ -8,11 +8,11 @@ use std::io;
 use std::os::fd::{AsFd, OwnedFd};
 use std::sync::{Arc, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
-use wayland_client::WEnum;
 use wayland_client::backend::WaylandError;
+use wayland_client::WEnum;
 
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
-use wayland_client::protocol::wl_pointer::{Axis, AxisSource, ButtonState};
+use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
     zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
@@ -25,15 +25,16 @@ use wayland_protocols_misc::zwp_virtual_keyboard_v1::client::{
 };
 
 use wayland_client::{
-    Connection, Dispatch, EventQueue, QueueHandle, delegate_noop,
-    globals::{GlobalListContents, registry_queue_init},
+    delegate_noop,
+    globals::{registry_queue_init, GlobalListContents},
     protocol::{wl_registry, wl_seat},
+    Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use input_event::{Event, KeyboardEvent, PointerEvent, scancode};
+use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
 
-use super::EmulationHandle;
 use super::error::WaylandBindError;
+use super::EmulationHandle;
 
 struct State {
     keymap: Option<(u32, OwnedFd, u32)>,
@@ -209,8 +210,7 @@ impl VirtualInput {
                     PointerEvent::AxisDiscrete120 { axis, value } => {
                         let axis: Axis = (axis as u32).try_into()?;
                         self.pointer
-                            .axis_discrete(now, axis, value as f64 / 8., value / 120);
-                        self.pointer.axis_source(AxisSource::Wheel);
+                            .axis_discrete(now, axis, value as f64 / 6., value / 120);
                         self.pointer.frame();
                     }
                 }

input-emulation/src/x11.rs

@@ -6,12 +6,12 @@ use x11::{
 };
 
 use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
 use crate::error::EmulationError;
 
-use super::{Emulation, EmulationHandle, error::X11EmulationCreationError};
+use super::{error::X11EmulationCreationError, Emulation, EmulationHandle};
 
 pub(crate) struct X11Emulation {
     display: *mut xlib::Display,

input-emulation/src/xdg_desktop_portal.rs

@@ -1,7 +1,7 @@
 use ashpd::{
     desktop::{
-        PersistMode, Session,
         remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
+        PersistMode, Session,
     },
     zbus::AsyncDrop,
 };
@@ -15,7 +15,7 @@ use input_event::{
 
 use crate::error::EmulationError;
 
-use super::{Emulation, EmulationHandle, error::XdpEmulationCreationError};
+use super::{error::XdpEmulationCreationError, Emulation, EmulationHandle};
 
 pub(crate) struct DesktopPortalEmulation<'a> {
     proxy: RemoteDesktop<'a>,

lan-mouse-cli/src/lib.rs

@@ -5,8 +5,8 @@ use std::{net::IpAddr, time::Duration};
 use thiserror::Error;
 
 use lan_mouse_ipc::{
-    ClientHandle, ConnectionError, FrontendEvent, FrontendRequest, IpcError, Position,
-    connect_async,
+    connect_async, ClientHandle, ConnectionError, FrontendEvent, FrontendRequest, IpcError,
+    Position,
 };
 
 #[derive(Debug, Error)]
@@ -71,8 +71,6 @@ enum CliSubcommand {
     },
     /// deauthorize a public key
     RemoveAuthorizedKey { sha256_fingerprint: String },
-    /// save configuration to file
-    SaveConfig,
 }
 
 pub async fn run(args: CliArgs) -> Result<(), CliError> {
@@ -164,7 +162,6 @@ async fn execute(cmd: CliSubcommand) -> Result<(), CliError> {
             tx.request(FrontendRequest::RemoveAuthorizedKey(sha256_fingerprint))
                 .await?
         }
-        CliSubcommand::SaveConfig => tx.request(FrontendRequest::SaveConfiguration).await?,
     }
     Ok(())
 }

lan-mouse-gtk/src/authorization_window/imp.rs

@@ -4,9 +4,8 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::subclass::InitializingObject;
 use gtk::{
-    Button, CompositeTemplate, Label,
     glib::{self, subclass::Signal},
-    template_callbacks,
+    template_callbacks, Button, CompositeTemplate, Label,
 };
 
 #[derive(CompositeTemplate, Default)]

lan-mouse-gtk/src/client_row.rs

@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};
 
-use lan_mouse_ipc::{DEFAULT_PORT, Position};
+use lan_mouse_ipc::{Position, DEFAULT_PORT};
 
 use super::ClientObject;
 

lan-mouse-gtk/src/client_row/imp.rs

@@ -1,11 +1,11 @@
 use std::cell::RefCell;
 
 use adw::subclass::prelude::*;
-use adw::{ActionRow, ComboRow, prelude::*};
-use glib::{Binding, subclass::InitializingObject};
+use adw::{prelude::*, ActionRow, ComboRow};
+use glib::{subclass::InitializingObject, Binding};
 use gtk::glib::subclass::Signal;
-use gtk::glib::{SignalHandlerId, clone};
-use gtk::{Button, CompositeTemplate, Entry, Switch, glib};
+use gtk::glib::{clone, SignalHandlerId};
+use gtk::{glib, Button, CompositeTemplate, Entry, Switch};
 use lan_mouse_ipc::Position;
 use std::sync::OnceLock;
 

lan-mouse-gtk/src/fingerprint_window/imp.rs

@@ -4,9 +4,8 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::subclass::InitializingObject;
 use gtk::{
-    Button, CompositeTemplate, Text,
     glib::{self, subclass::Signal},
-    template_callbacks,
+    template_callbacks, Button, CompositeTemplate, Text,
 };
 
 #[derive(CompositeTemplate, Default)]
@@ -52,11 +51,9 @@ impl ObjectImpl for FingerprintWindow {
     fn signals() -> &'static [Signal] {
         static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
         SIGNALS.get_or_init(|| {
-            vec![
-                Signal::builder("confirm-clicked")
-                    .param_types([String::static_type(), String::static_type()])
-                    .build(),
-            ]
+            vec![Signal::builder("confirm-clicked")
+                .param_types([String::static_type(), String::static_type()])
+                .build()]
         })
     }
 }

lan-mouse-gtk/src/key_row/imp.rs

@@ -1,11 +1,11 @@
 use std::cell::RefCell;
 
 use adw::subclass::prelude::*;
-use adw::{ActionRow, prelude::*};
-use glib::{Binding, subclass::InitializingObject};
+use adw::{prelude::*, ActionRow};
+use glib::{subclass::InitializingObject, Binding};
 use gtk::glib::clone;
 use gtk::glib::subclass::Signal;
-use gtk::{Button, CompositeTemplate, glib};
+use gtk::{glib, Button, CompositeTemplate};
 use std::sync::OnceLock;
 
 #[derive(CompositeTemplate, Default)]

lan-mouse-gtk/src/lib.rs

@@ -13,7 +13,7 @@ use window::Window;
 use lan_mouse_ipc::FrontendEvent;
 
 use adw::Application;
-use gtk::{IconTheme, gdk::Display, glib::clone, prelude::*};
+use gtk::{gdk::Display, glib::clone, prelude::*, IconTheme};
 use gtk::{gio, glib, prelude::ApplicationExt};
 
 use self::client_object::ClientObject;

lan-mouse-gtk/src/window.rs

@@ -4,15 +4,16 @@ use std::collections::HashMap;
 
 use adw::prelude::*;
 use adw::subclass::prelude::*;
-use glib::{Object, clone};
+use glib::{clone, Object};
 use gtk::{
-    NoSelection, gio,
+    gio,
     glib::{self, closure_local},
+    NoSelection,
 };
 
 use lan_mouse_ipc::{
-    ClientConfig, ClientHandle, ClientState, DEFAULT_PORT, FrontendRequest, FrontendRequestWriter,
-    Position,
+    ClientConfig, ClientHandle, ClientState, FrontendRequest, FrontendRequestWriter, Position,
+    DEFAULT_PORT,
 };
 
 use crate::{
@@ -473,9 +474,6 @@ impl Window {
     }
 
     pub(super) fn request_authorization(&self, fingerprint: &str) {
-        if let Some(w) = self.imp().authorization_window.borrow_mut().take() {
-            w.close();
-        }
         let window = AuthorizationWindow::new(fingerprint);
         window.set_transient_for(Some(self));
         window.connect_closure(
@@ -498,6 +496,5 @@ impl Window {
             }),
         );
         window.present();
-        self.imp().authorization_window.replace(Some(window));
     }
 }

lan-mouse-gtk/src/window/imp.rs

@@ -1,14 +1,12 @@
 use std::cell::{Cell, RefCell};
 
 use adw::subclass::prelude::*;
-use adw::{ActionRow, PreferencesGroup, ToastOverlay, prelude::*};
+use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
-use gtk::{Button, CompositeTemplate, Entry, Image, Label, ListBox, gdk, gio, glib};
+use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Image, Label, ListBox};
 
-use lan_mouse_ipc::{DEFAULT_PORT, FrontendRequestWriter};
-
-use crate::authorization_window::AuthorizationWindow;
+use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
 
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
@@ -51,7 +49,6 @@ pub struct Window {
     pub port: Cell<u16>,
     pub capture_active: Cell<bool>,
     pub emulation_active: Cell<bool>,
-    pub authorization_window: RefCell<Option<AuthorizationWindow>>,
 }
 
 #[glib::object_subclass]

lan-mouse-ipc/Cargo.toml

@@ -12,5 +12,5 @@ log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
 thiserror = "2.0.0"
-tokio = { version = "1.32.0", features = ["macros", "net", "io-util", "time"] }
+tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }

lan-mouse-ipc/src/connect.rs

@@ -1,7 +1,7 @@
 use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
 use std::{
     cmp::min,
-    io::{self, BufReader, LineWriter, Lines, prelude::*},
+    io::{self, prelude::*, BufReader, LineWriter, Lines},
     thread,
     time::Duration,
 };

lan-mouse-ipc/src/connect_async.rs

@@ -1,7 +1,7 @@
 use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
 use std::{
     cmp::min,
-    task::{Poll, ready},
+    task::{ready, Poll},
     time::Duration,
 };
 

lan-mouse-ipc/src/lib.rs

@@ -20,8 +20,8 @@ mod connect;
 mod connect_async;
 mod listen;
 
-pub use connect::{FrontendEventReader, FrontendRequestWriter, connect};
-pub use connect_async::{AsyncFrontendEventReader, AsyncFrontendRequestWriter, connect_async};
+pub use connect::{connect, FrontendEventReader, FrontendRequestWriter};
+pub use connect_async::{connect_async, AsyncFrontendEventReader, AsyncFrontendRequestWriter};
 pub use listen::AsyncFrontendListener;
 
 #[derive(Debug, Error)]
@@ -253,8 +253,6 @@ pub enum FrontendRequest {
     RemoveAuthorizedKey(String),
     /// change the hook command
     UpdateEnterHook(u64, Option<String>),
-    /// save config file
-    SaveConfiguration,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]

lan-mouse-ipc/src/listen.rs

@@ -1,4 +1,4 @@
-use futures::{Stream, StreamExt, stream::SelectAll};
+use futures::{stream::SelectAll, Stream, StreamExt};
 #[cfg(unix)]
 use std::path::PathBuf;
 use std::{
@@ -63,7 +63,7 @@ impl AsyncFrontendListener {
                 Ok(ls) => ls,
                 // some other lan-mouse instance has bound the socket in the meantime
                 Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                    return Err(IpcListenerCreationError::AlreadyRunning);
+                    return Err(IpcListenerCreationError::AlreadyRunning)
                 }
                 Err(e) => return Err(IpcListenerCreationError::Bind(e)),
             };
@@ -75,7 +75,7 @@ impl AsyncFrontendListener {
             Ok(ls) => ls,
             // some other lan-mouse instance has bound the socket in the meantime
             Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                return Err(IpcListenerCreationError::AlreadyRunning);
+                return Err(IpcListenerCreationError::AlreadyRunning)
             }
             Err(e) => return Err(IpcListenerCreationError::Bind(e)),
         };

nix/README.md

@@ -1,18 +1,18 @@
 # Nix Flake Usage
 
-## Run
+## run
 
 ```bash
 nix run github:feschber/lan-mouse
 
-# With params
+# with params
 nix run github:feschber/lan-mouse -- --help
 
 ```
 
-## Home-manager module
+## home-manager module
 
-Add input:
+add input
 
 ```nix
 inputs = {
@@ -20,27 +20,14 @@ inputs = {
 }
 ```
 
-Optional: add [our binary cache](https://app.cachix.org/cache/lan-mouse) to allow a faster package install.
-
-```nix
-nixConfig = {
-    extra-substituters = [
-        "https://lan-mouse.cachix.org/"
-    ];
-    extra-trusted-public-keys = [
-      "lan-mouse.cachix.org-1:KlE2AEZUgkzNKM7BIzMQo8w9yJYqUpor1CAUNRY6OyM="
-    ];
-};
-```
-
-Enable lan-mouse:
+enable lan-mouse
 
 ``` nix
 {
   inputs,
   ...
 }: {
-  # Add the Home Manager module
+  # add the home manager module
   imports = [inputs.lan-mouse.homeManagerModules.default];
 
   programs.lan-mouse = {

scripts/copy-macos-dylib.sh

@@ -1,93 +0,0 @@
-#!/bin/sh
-set -eu
-
-homebrew_path=""
-exec_path="target/debug/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-
-usage() {
-    cat <<EOF
-$0: Copy all Homebrew libraries into the macOS app bundle.
-USAGE: $0 [-h] [-b homebrew_path] [exec_path]
-
-OPTIONS:
-  -h, --help    Show this help message and exit
-  -b            Path to Homebrew installation (default: $homebrew_path)
-  exec_path     Path to the main executable in the app bundle
-                (default: get from `brew --prefix`)
-
-When macOS apps are linked to dynamic libraries (.dylib files),
-the fully qualified path to the library is embedded in the binary.
-If the libraries come from Homebrew, that means that Homebrew must be present
-and the libraries must be installed in the same location on the user's machine.
-
-This script copies all of the Homebrew libraries that an executable links to into the app bundle
-and tells all the binaries in the bundle to look for them there.
-EOF
-}
-
-# Gather command-line arguments
-while test $# -gt 0; do
-    case "$1" in
-        -h | --help ) usage; exit 0;;
-        -b | --homebrew ) homebrew_path="$1"; shift 2;;
-        * ) exec_path="$1"; shift;;
-    esac
-done
-
-if [ -z "$homebrew_path" ]; then
-    homebrew_path="$(brew --prefix)"
-fi
-
-# Path to the .app bundle
-bundle_path=$(dirname "$(dirname "$(dirname "$exec_path")")")
-# Path to the Frameworks directory
-fwks_path="$bundle_path/Contents/Frameworks"
-mkdir -p "$fwks_path"
-
-# Copy and fix references for a binary (executable or dylib)
-#
-# This function will:
-# - Copy any referenced dylibs from /opt/homebrew to the Frameworks directory
-# - Update the binary to reference the local copy instead
-# - Add the Frameworks directory to the binary's RPATH
-# - Recursively process the copied dylibs
-fix_references() {
-  local bin="$1"
-
-  # Get all Homebrew libraries referenced by the binary
-  libs=$(otool -L "$bin" | awk -v homebrew="$homebrew_path" '$0 ~ homebrew {print $1}')
-
-  echo "$libs" | while IFS= read -r old_path; do
-    local base_name="$(basename "$old_path")"
-    local dest="$fwks_path/$base_name"
-
-    if [ ! -e "$dest" ]; then
-      echo "Copying $old_path -> $dest"
-      cp -f "$old_path" "$dest"
-      # Ensure the copied dylib is writable so that xattr -rd /path/to/Lan\ Mouse.app works.
-      chmod 644 "$dest"
-
-      echo "Updating $dest to have install_name of @rpath/$base_name..."
-      install_name_tool -id "@rpath/$base_name" "$dest"
-
-      # Recursively process this dylib
-      fix_references "$dest"
-    fi
-
-    echo "Updating $bin to reference @rpath/$base_name..."
-    install_name_tool -change "$old_path" "@rpath/$base_name" "$bin"
-  done
-}
-
-fix_references "$exec_path"
-
-# Ensure the main executable has our Frameworks path in its RPATH
-if ! otool -l "$exec_path" | grep -q "@executable_path/../Frameworks"; then
-  echo "Adding RPATH to $exec_path"
-  install_name_tool -add_rpath "@executable_path/../Frameworks" "$exec_path"
-fi
-
-# Se-sign the .app
-codesign --force --deep --sign - "$bundle_path"
-
-echo "Done!"

src/capture.rs

@@ -10,8 +10,8 @@ use input_capture::{
 };
 use input_event::scancode;
 use lan_mouse_proto::ProtoEvent;
-use local_channel::mpsc::{Receiver, Sender, channel};
-use tokio::task::{JoinHandle, spawn_local};
+use local_channel::mpsc::{channel, Receiver, Sender};
+use tokio::task::{spawn_local, JoinHandle};
 use tokio_util::sync::CancellationToken;
 
 use crate::connect::LanMouseConnection;
@@ -362,13 +362,7 @@ impl CaptureTask {
     }
 
     async fn release_capture(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
-        // If we have an active client, notify them we're leaving
-        if let Some(handle) = self.active_client.take() {
-            log::info!("sending Leave event to client {handle}");
-            if let Err(e) = self.conn.send(ProtoEvent::Leave(0), handle).await {
-                log::warn!("failed to send Leave to client {handle}: {e}");
-            }
-        }
+        self.active_client.take();
         capture.release().await
     }
 }

src/client.rs

@@ -15,15 +15,6 @@ pub struct ClientManager {
 }
 
 impl ClientManager {
-    /// get all clients
-    pub fn clients(&self) -> Vec<(ClientConfig, ClientState)> {
-        self.clients
-            .borrow()
-            .iter()
-            .map(|(_, c)| c.clone())
-            .collect::<Vec<_>>()
-    }
-
     /// add a new client to this manager
     pub fn add_client(&self) -> ClientHandle {
         self.clients.borrow_mut().insert(Default::default()) as ClientHandle

src/config.rs

@@ -5,17 +5,15 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env::{self, VarError};
 use std::fmt::Display;
-use std::fs::{self, File};
-use std::io::Write;
+use std::fs;
 use std::net::IpAddr;
 use std::path::{Path, PathBuf};
 use std::{collections::HashSet, io};
 use thiserror::Error;
 use toml;
-use toml_edit::{self, DocumentMut};
 
 use lan_mouse_cli::CliArgs;
-use lan_mouse_ipc::{DEFAULT_PORT, Position};
+use lan_mouse_ipc::{Position, DEFAULT_PORT};
 
 use input_event::scancode::{
     self,
@@ -46,7 +44,7 @@ fn default_path() -> Result<PathBuf, VarError> {
     Ok(PathBuf::from(default_path))
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+#[derive(Serialize, Deserialize, Debug)]
 struct ConfigToml {
     capture_backend: Option<CaptureBackend>,
     emulation_backend: Option<EmulationBackend>,
@@ -276,33 +274,6 @@ impl From<TomlClient> for ConfigClient {
     }
 }
 
-impl From<ConfigClient> for TomlClient {
-    fn from(client: ConfigClient) -> Self {
-        let hostname = client.hostname;
-        let host_name = None;
-        let mut ips = client.ips.into_iter().collect::<Vec<_>>();
-        ips.sort();
-        let ips = Some(ips);
-        let port = if client.port == DEFAULT_PORT {
-            None
-        } else {
-            Some(client.port)
-        };
-        let position = Some(client.pos);
-        let activate_on_startup = if client.active { Some(true) } else { None };
-        let enter_hook = client.enter_hook;
-        Self {
-            hostname,
-            host_name,
-            ips,
-            port,
-            position,
-            activate_on_startup,
-            enter_hook,
-        }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum ConfigError {
     #[error(transparent)]
@@ -413,66 +384,4 @@ impl Config {
             .and_then(|c| c.release_bind.clone())
             .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
     }
-
-    /// set configured clients
-    pub fn set_clients(&mut self, clients: Vec<ConfigClient>) {
-        if clients.is_empty() {
-            return;
-        }
-        if self.config_toml.is_none() {
-            self.config_toml = Some(Default::default());
-        }
-        self.config_toml.as_mut().expect("config").clients =
-            Some(clients.into_iter().map(|c| c.into()).collect::<Vec<_>>());
-    }
-
-    /// set authorized keys
-    pub fn set_authorized_keys(&mut self, fingerprints: HashMap<String, String>) {
-        if fingerprints.is_empty() {
-            return;
-        }
-        if self.config_toml.is_none() {
-            self.config_toml = Default::default();
-        }
-        self.config_toml
-            .as_mut()
-            .expect("config")
-            .authorized_fingerprints = Some(fingerprints);
-    }
-
-    pub fn write_back(&self) -> Result<(), io::Error> {
-        log::info!("writing config to {:?}", &self.config_path);
-        /* load the current configuration file */
-        let current_config = match fs::read_to_string(&self.config_path) {
-            Ok(c) => c.parse::<DocumentMut>().unwrap_or_default(),
-            Err(e) => {
-                log::info!("{:?} {e} => creating new config", self.config_path());
-                Default::default()
-            }
-        };
-        let _current_config =
-            toml_edit::de::from_document::<ConfigToml>(current_config).unwrap_or_default();
-
-        /* the new config */
-        let new_config = self.config_toml.clone().unwrap_or_default();
-        // let new_config = toml_edit::ser::to_document::<ConfigToml>(&new_config).expect("fixme");
-        let new_config = toml_edit::ser::to_string_pretty(&new_config).expect("config");
-
-        /*
-         * TODO merge documents => eventually we might want to split this up into clients configured
-         * via the config file and clients managed through the GUI / frontend.
-         * The latter should be saved to $XDG_DATA_HOME instead of $XDG_CONFIG_HOME,
-         * and clients configured through .config could be made permanent.
-         * For now we just override the config file.
-         */
-
-        /* write new config to file */
-        if let Some(p) = self.config_path().parent() {
-            fs::create_dir_all(p)?;
-        }
-        let mut f = File::create(self.config_path())?;
-        f.write_all(new_config.as_bytes())?;
-
-        Ok(())
-    }
 }

src/connect.rs

@@ -1,7 +1,7 @@
 use crate::client::ClientManager;
 use lan_mouse_ipc::{ClientHandle, DEFAULT_PORT};
-use lan_mouse_proto::{MAX_EVENT_SIZE, ProtoEvent};
-use local_channel::mpsc::{Receiver, Sender, channel};
+use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
+use local_channel::mpsc::{channel, Receiver, Sender};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -15,7 +15,7 @@ use thiserror::Error;
 use tokio::{
     net::UdpSocket,
     sync::Mutex,
-    task::{JoinSet, spawn_local},
+    task::{spawn_local, JoinSet},
 };
 use webrtc_dtls::{
     config::{Config, ExtendedMasterSecretType},
@@ -223,18 +223,14 @@ async fn ping_pong(
 ) {
     loop {
         let (buf, len) = ProtoEvent::Ping.into();
-
-        // send 4 pings, at least one must be answered
-        for _ in 0..4 {
-            if let Err(e) = conn.send(&buf[..len]).await {
-                log::warn!("{addr}: send error `{e}`, closing connection");
-                let _ = conn.close().await;
-                break;
-            }
-            log::trace!("PING >->->->->- {addr}");
-
-            tokio::time::sleep(Duration::from_millis(500)).await;
+        if let Err(e) = conn.send(&buf[..len]).await {
+            log::warn!("{addr}: send error `{e}`, closing connection");
+            let _ = conn.close().await;
+            break;
         }
+        log::trace!("PING >->->->->- {addr}");
+
+        tokio::time::sleep(Duration::from_millis(500)).await;
 
         if !ping_response.borrow_mut().remove(&addr) {
             log::warn!("{addr} did not respond, closing connection");

src/dns.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, net::IpAddr};
 
-use local_channel::mpsc::{Receiver, Sender, channel};
-use tokio::task::{JoinHandle, spawn_local};
+use local_channel::mpsc::{channel, Receiver, Sender};
+use tokio::task::{spawn_local, JoinHandle};
 
 use hickory_resolver::{ResolveError, TokioResolver};
 use tokio_util::sync::CancellationToken;

src/emulation.rs

@@ -3,7 +3,7 @@ use futures::StreamExt;
 use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
 use input_event::Event;
 use lan_mouse_proto::{Position, ProtoEvent};
-use local_channel::mpsc::{Receiver, Sender, channel};
+use local_channel::mpsc::{channel, Receiver, Sender};
 use std::{
     cell::Cell,
     collections::HashMap,
@@ -13,7 +13,7 @@ use std::{
 };
 use tokio::{
     select,
-    task::{JoinHandle, spawn_local},
+    task::{spawn_local, JoinHandle},
 };
 
 /// emulation handling events received from a listener
@@ -128,7 +128,6 @@ impl ListenTask {
     async fn run(mut self) {
         let mut interval = tokio::time::interval(Duration::from_secs(5));
         let mut last_response = HashMap::new();
-        let mut rejected_connections = HashMap::new();
         loop {
             select! {
                 e = self.listener.next() => {match e {
@@ -157,10 +156,7 @@ impl ListenTask {
                         self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
                     }
                     Some(ListenEvent::Rejected { fingerprint }) => {
-                        if rejected_connections.insert(fingerprint.clone(), Instant::now())
-                            .is_none_or(|i| i.elapsed() >= Duration::from_secs(2)) {
-                                self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
-                            }
+                        self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
                     }
                     None => break
                 }}

src/listen.rs

@@ -1,6 +1,6 @@
 use futures::{Stream, StreamExt};
-use lan_mouse_proto::{MAX_EVENT_SIZE, ProtoEvent};
-use local_channel::mpsc::{Receiver, Sender, channel};
+use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
+use local_channel::mpsc::{channel, Receiver, Sender};
 use rustls::pki_types::CertificateDer;
 use std::{
     collections::{HashMap, VecDeque},
@@ -12,7 +12,7 @@ use std::{
 use thiserror::Error;
 use tokio::{
     sync::Mutex as AsyncMutex,
-    task::{JoinHandle, spawn_local},
+    task::{spawn_local, JoinHandle},
 };
 use webrtc_dtls::{
     config::{ClientAuthType::RequireAnyClientCert, Config, ExtendedMasterSecretType},
@@ -20,7 +20,7 @@ use webrtc_dtls::{
     crypto::Certificate,
     listener::listen,
 };
-use webrtc_util::{Conn, Error, conn::Listener};
+use webrtc_util::{conn::Listener, Conn, Error};
 
 use crate::crypto;
 

src/service.rs

@@ -1,7 +1,7 @@
 use crate::{
     capture::{Capture, CaptureType, ICaptureEvent},
     client::ClientManager,
-    config::{Config, ConfigClient},
+    config::Config,
     connect::LanMouseConnection,
     crypto,
     dns::{DnsEvent, DnsResolver},
@@ -39,8 +39,6 @@ pub enum ServiceError {
 }
 
 pub struct Service {
-    /// configuration
-    config: Config,
     /// input capture
     capture: Capture,
     /// input emulation
@@ -124,7 +122,6 @@ impl Service {
 
         let port = config.port();
         let service = Self {
-            config,
             capture,
             emulation,
             frontend_listener,
@@ -185,73 +182,24 @@ impl Service {
             Err(e) => return log::error!("error receiving request: {e}"),
         };
         match request {
-            FrontendRequest::Activate(handle, active) => {
-                self.set_client_active(handle, active);
-                self.save_config();
-            }
-            FrontendRequest::AuthorizeKey(desc, fp) => {
-                self.add_authorized_key(desc, fp);
-                self.save_config();
-            }
+            FrontendRequest::Activate(handle, active) => self.set_client_active(handle, active),
+            FrontendRequest::AuthorizeKey(desc, fp) => self.add_authorized_key(desc, fp),
             FrontendRequest::ChangePort(port) => self.change_port(port),
-            FrontendRequest::Create => {
-                self.add_client();
-                self.save_config();
-            }
-            FrontendRequest::Delete(handle) => {
-                self.remove_client(handle);
-                self.save_config();
-            }
+            FrontendRequest::Create => self.add_client(),
+            FrontendRequest::Delete(handle) => self.remove_client(handle),
             FrontendRequest::EnableCapture => self.capture.reenable(),
             FrontendRequest::EnableEmulation => self.emulation.reenable(),
             FrontendRequest::Enumerate() => self.enumerate(),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-                self.update_fix_ips(handle, fix_ips);
-                self.save_config();
-            }
-            FrontendRequest::UpdateHostname(handle, host) => {
-                self.update_hostname(handle, host);
-                self.save_config();
-            }
-            FrontendRequest::UpdatePort(handle, port) => {
-                self.update_port(handle, port);
-                self.save_config();
-            }
-            FrontendRequest::UpdatePosition(handle, pos) => {
-                self.update_pos(handle, pos);
-                self.save_config();
-            }
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+            FrontendRequest::UpdatePosition(handle, pos) => self.update_pos(handle, pos),
             FrontendRequest::ResolveDns(handle) => self.resolve(handle),
             FrontendRequest::Sync => self.sync_frontend(),
-            FrontendRequest::RemoveAuthorizedKey(key) => {
-                self.remove_authorized_key(key);
-                self.save_config();
-            }
+            FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
             FrontendRequest::UpdateEnterHook(handle, enter_hook) => {
                 self.update_enter_hook(handle, enter_hook)
             }
-            FrontendRequest::SaveConfiguration => self.save_config(),
-        }
-    }
-
-    fn save_config(&mut self) {
-        let clients = self.client_manager.clients();
-        let clients = clients
-            .into_iter()
-            .map(|(c, s)| ConfigClient {
-                ips: HashSet::from_iter(c.fix_ips),
-                hostname: c.hostname,
-                port: c.port,
-                pos: c.pos,
-                active: s.active,
-                enter_hook: c.cmd,
-            })
-            .collect();
-        self.config.set_clients(clients);
-        let authorized_keys = self.authorized_keys.read().expect("lock").clone();
-        self.config.set_authorized_keys(authorized_keys);
-        if let Err(e) = self.config.write_back() {
-            log::warn!("failed to write config: {e}");
         }
     }