only alert on actual error

ask the user to accept unauthorized devices
2026-03-07 20:09:59 +03:00 · 2025-03-22 22:12:17 +01:00 · 2025-03-22 21:56:13 +01:00
34 changed files with 1227 additions and 1613 deletions
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -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
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -112,9 +112,7 @@ jobs:
    - name: Install cargo bundle
      run: cargo install cargo-bundle
    - name: Bundle
-      run: |
-        cargo bundle
-        scripts/copy-macos-dylib.sh
+      run: cargo bundle
    - name: Zip bundle
      run: |
        cd target/debug/bundle/osx
@@ -144,9 +142,7 @@ jobs:
    - name: Install cargo bundle
      run: cargo install cargo-bundle
    - name: Bundle
-      run: |
-        cargo bundle
-        scripts/copy-macos-dylib.sh
+      run: cargo bundle
    - name: Zip bundle
      run: |
        cd target/debug/bundle/osx
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -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
--- a/.gitignore
+++ b/.gitignore
@@ -8,7 +8,3 @@ result
 *.pem
 *.csr
 extfile.conf
-
-# flatpak files
-.flatpak-builder
-repo
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,7 @@ strip = true
 panic = "abort"

 [build-dependencies]
-shadow-rs = "1.2.0"
+shadow-rs = "0.38.0"

 [dependencies]
 input-event = { path = "input-event", version = "0.3.0" }
@@ -34,9 +34,9 @@ lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
 lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
 lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
-shadow-rs = { version = "1.2.0", features = ["metadata"] }
+shadow-rs = { version = "0.38.0", features = ["metadata"] }

-hickory-resolver = "0.25.2"
+hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
@@ -58,8 +58,8 @@ slab = "0.4.9"
 thiserror = "2.0.0"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
-webrtc-dtls = { version = "0.12.0", features = ["pem"] }
-webrtc-util = "0.11.0"
+webrtc-dtls = { version = "0.10.0", features = ["pem"] }
+webrtc-util = "0.9.0"
 rustls = { version = "0.23.12", default-features = false, features = [
    "std",
    "ring",
--- a/README.md
+++ b/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>

--- a/build-aux/de.feschber.LanMouse.yml
+++ b/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: ..
--- a/de.feschber.LanMouse.yml
+++ b/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
--- a/dylibs/.gitignore
+++ b/dylibs/.gitignore
@@ -1 +0,0 @@
-*
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1752687322,
-        "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
+        "lastModified": 1740560979,
+        "narHash": "sha256-Vr3Qi346M+8CjedtbyUevIGDZW8LcA1fTG0ugPY/Hic=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
+        "rev": "5135c59491985879812717f4c9fea69604e7f26f",
        "type": "github"
      },
      "original": {
@@ -29,11 +29,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1752806774,
-        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
+        "lastModified": 1740623427,
+        "narHash": "sha256-3SdPQrZoa4odlScFDUHd4CUPQ/R1gtH4Mq9u8CBiK8M=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
+        "rev": "d342e8b5fd88421ff982f383c853f0fc78a847ab",
        "type": "github"
      },
      "original": {
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -40,21 +40,21 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
+core-graphics = { version = "0.24.0", features = ["highsierra"] }
 core-foundation = "0.10.0"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
-keycode = "1.0.0"
+keycode = "0.4.0"
 bitflags = "2.6.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
--- a/input-capture/src/layer_shell.rs
+++ b/input-capture/src/layer_shell.rs
@@ -535,7 +535,7 @@ impl State {
    fn update_windows(&mut self) {
        log::info!("active outputs: ");
        for output in self.outputs.iter().filter(|o| o.info.is_some()) {
-            log::info!(" * {output}");
+            log::info!(" * {}", output);
        }

        self.active_windows.clear();
@@ -582,17 +582,17 @@ impl Inner {
        match self.queue.dispatch_pending(&mut self.state) {
            Ok(_) => {}
            Err(DispatchError::Backend(WaylandError::Io(e))) => {
-                log::error!("Wayland Error: {e}");
+                log::error!("Wayland Error: {}", e);
            }
            Err(DispatchError::Backend(e)) => {
-                panic!("backend error: {e}");
+                panic!("backend error: {}", e);
            }
            Err(DispatchError::BadMessage {
                sender_id,
                interface,
                opcode,
            }) => {
-                panic!("bad message {sender_id}, {interface} , {opcode}");
+                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
            }
        }
    }
@@ -813,7 +813,7 @@ impl Dispatch<WlPointer, ()> for State {
                    })),
                ));
            }
-            wl_pointer::Event::Frame => {
+            wl_pointer::Event::Frame {} => {
                // TODO properly handle frame events
                // we simply insert a frame event on the client side
                // after each event for now
@@ -974,7 +974,7 @@ impl Dispatch<ZxdgOutputV1, u32> for State {
            .find(|o| o.global.name == *name)
            .expect("output");

-        log::debug!("xdg_output {name} - {event:?}");
+        log::debug!("xdg_output {name} - {:?}", event);
        match event {
            zxdg_output_v1::Event::LogicalPosition { x, y } => {
                output.pending_info.position = (x, y);
@@ -1010,7 +1010,7 @@ impl Dispatch<WlOutput, u32> for State {
        _conn: &Connection,
        _qhandle: &QueueHandle<Self>,
    ) {
-        log::debug!("wl_output {name} - {event:?}");
+        log::debug!("wl_output {name} - {:?}", event);
        if let wl_output::Event::Done = event {
            state.update_output_info(*name);
        }
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -79,7 +79,7 @@ impl Display for Position {
            Position::Top => "top",
            Position::Bottom => "bottom",
        };
-        write!(f, "{pos}")
+        write!(f, "{}", pos)
    }
 }

--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -587,13 +587,9 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
        self.cancellation_token.cancel();
        let task = &mut self.capture_task;
        log::debug!("waiting for capture to terminate...");
-        let res = if !task.is_finished() {
-            task.await.expect("libei task panic")
-        } else {
-            Ok(())
-        };
-        self.terminated = true;
+        let res = task.await.expect("libei task panic");
        log::debug!("done!");
+        self.terminated = true;
        res
    }
 }
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -10,7 +10,7 @@ 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,
+    CGEventTapProxy, CGEventType, EventField,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
@@ -390,15 +390,15 @@ fn create_event_tap<'a>(

            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.
-                    let _ = event_tx.blocking_send((pos, *e));
+                    event_tx
+                        .blocking_send((pos, *e))
+                        .expect("Failed to send event");
                });
-                // Returning Drop should stop the event from being processed
+                // Returning None should stop the event from being processed
                // but core fundation still returns the event
                cg_ev.set_type(CGEventType::Null);
            }
-            CallbackResult::Replace(cg_ev.to_owned())
+            Some(cg_ev.to_owned())
        };

    let tap = CGEventTap::new(
@@ -411,7 +411,7 @@ fn create_event_tap<'a>(
    .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;

    let tap_source: CFRunLoopSource = tap
-        .mach_port()
+        .mach_port
        .create_runloop_source(0)
        .expect("Failed creating loop source");

@@ -426,8 +426,8 @@ fn event_tap_thread(
    client_state: Arc<Mutex<InputCaptureState>>,
    event_tx: Sender<(Position, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<CFRunLoop, MacosCaptureCreationError>>,
-    exit: oneshot::Sender<()>,
+    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
+    exit: oneshot::Sender<Result<(), &'static str>>,
 ) {
    let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
        Err(e) => {
@@ -435,22 +435,18 @@ fn event_tap_thread(
            return;
        }
        Ok(tap) => {
-            let run_loop = CFRunLoop::get_current();
-            ready.send(Ok(run_loop)).expect("channel closed");
+            ready.send(Ok(())).expect("channel closed");
            tap
        }
    };
-    log::debug!("running CFRunLoop...");
    CFRunLoop::run_current();
-    log::debug!("event tap thread exiting!...");

-    let _ = exit.send(());
+    let _ = exit.send(Err("tap thread exited"));
 }

 pub struct MacOSInputCapture {
    event_rx: Receiver<(Position, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    run_loop: CFRunLoop,
 }

 impl MacOSInputCapture {
@@ -479,44 +475,36 @@ impl MacOSInputCapture {
        });

        // wait for event tap creation result
-        let run_loop = ready_rx.recv().expect("channel closed")?;
+        ready_rx.recv().expect("channel closed")?;

        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
            loop {
                tokio::select! {
                    producer_event = notify_rx.recv() => {
-                        let Some(producer_event) = producer_event else {
-                            break;
-                        };
+                        let producer_event = producer_event.expect("channel closed");
                        let mut state = state.lock().await;
                        state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
                            log::error!("Failed to handle producer event: {e}");
                        })
                    }

-                    _ = &mut tap_exit_rx => {
-                        break;
+                    res = &mut tap_exit_rx => {
+                        if let Err(e) = res.expect("channel closed") {
+                            log::error!("Tap thread failed: {:?}", e);
+                            break;
+                        }
                    }
                }
            }
-            // show cursor
-            let _ = CGDisplay::show_cursor(&CGDisplay::main());
        });

        Ok(Self {
            event_rx,
            notify_tx,
-            run_loop,
        })
    }
 }

-impl Drop for MacOSInputCapture {
-    fn drop(&mut self) {
-        self.run_loop.stop();
-    }
-}
-
 #[async_trait]
 impl Capture for MacOSInputCapture {
    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
--- a/input-capture/src/windows/event_thread.rs
+++ b/input-capture/src/windows/event_thread.rs
@@ -9,7 +9,7 @@ use std::thread;
 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::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
 use windows::Win32::Graphics::Gdi::{
    EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
    DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
@@ -19,10 +19,10 @@ use windows::Win32::System::Threading::GetCurrentThreadId;

 use windows::Win32::UI::WindowsAndMessaging::{
    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,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
+    HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
+    WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
+    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
    WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
    WNDPROC,
 };
@@ -128,7 +128,7 @@ thread_local! {
 fn get_msg() -> Option<MSG> {
    unsafe {
        let mut msg = std::mem::zeroed();
-        let ret = GetMessageW(addr_of_mut!(msg), None, 0, 0);
+        let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
        match ret.0 {
            0 => None,
            x if x > 0 => Some(msg),
@@ -176,15 +176,14 @@ fn start_routine(

    /* register hooks */
    unsafe {
-        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, None, 0).unwrap();
-        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, None, 0).unwrap();
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
    }

    let instance = unsafe { GetModuleHandleW(None).unwrap() };
-    let instance = instance.into();
    let window_class: WNDCLASSW = WNDCLASSW {
        lpfnWndProc: window_proc,
-        hInstance: instance,
+        hInstance: instance.into(),
        lpszClassName: w!("lan-mouse-message-window-class"),
        ..Default::default()
    };
@@ -214,9 +213,9 @@ fn start_routine(
            0,
            0,
            0,
-            None,
-            None,
-            Some(instance),
+            HWND::default(),
+            HMENU::default(),
+            instance,
            None,
        )
        .expect("CreateWindowExW");
@@ -313,7 +312,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)

    /* no client was active */
    if !active {
-        return CallNextHookEx(None, ncode, wparam, lparam);
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
    }

    /* get active client if any */
@@ -338,7 +337,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
    /* get active client if any */
    let Some(client) = ACTIVE_CLIENT.get() else {
-        return CallNextHookEx(None, ncode, wparam, lparam);
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
    };

    /* convert to key event */
@@ -389,10 +388,7 @@ fn enumerate_displays(display_rects: &mut Vec<RECT>) {
            if ret == FALSE {
                break;
            }
-            if device
-                .StateFlags
-                .contains(DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
-            {
+            if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
                devices.push(device.DeviceName);
            }
        }
@@ -541,10 +537,6 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
                state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
            })
        }
-        WPARAM(p) if p == WM_MOUSEHWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
-            axis: 1, // Horizontal
-            value: mouse_low_level.mouseData as i32 >> 16,
-        }),
        w => {
            log::warn!("unknown mouse event: {w:?}");
            None
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -21,7 +21,6 @@ tokio = { version = "1.32.0", features = [
    "rt",
    "sync",
    "signal",
-    "time"
 ] }
 once_cell = "1.19.0"

@@ -40,18 +39,18 @@ wayland-protocols-misc = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
 bitflags = "2.6.0"
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
-keycode = "1.0.0"
+core-graphics = { version = "0.24.0", features = ["highsierra"] }
+keycode = "0.4.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -10,37 +10,25 @@ use core_graphics::event::{
    ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{scancode, Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
+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();
@@ -179,12 +161,12 @@ fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
    };

    if error != 0 {
-        log::warn!("error getting displays at point ({x}, {y}): {error}");
+        log::warn!("error getting displays at point ({}, {}): {}", x, y, error);
        return Option::None;
    }

    if display_count == 0 {
-        log::debug!("no displays found at point ({x}, {y})");
+        log::debug!("no displays found at point ({}, {})", x, y);
        return Option::None;
    }

@@ -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 {
--- a/input-emulation/src/wlroots.rs
+++ b/input-emulation/src/wlroots.rs
@@ -12,7 +12,7 @@ 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,
@@ -163,13 +163,13 @@ impl Emulation for WlrootsEmulation {
    async fn create(&mut self, handle: EmulationHandle) {
        self.state.add_client(handle);
        if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
        }
    }
    async fn destroy(&mut self, handle: EmulationHandle) {
        self.state.destroy_client(handle);
        if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
        }
    }
    async fn terminate(&mut self) {
@@ -210,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();
                    }
                }
@@ -222,7 +221,7 @@ impl VirtualInput {
                    self.keyboard.key(time, key, state as u32);
                    if let Ok(mut mods) = self.modifiers.lock() {
                        if mods.update_by_key_event(key, state) {
-                            log::trace!("Key triggers modifier change: {mods:?}");
+                            log::trace!("Key triggers modifier change: {:?}", mods);
                            self.keyboard.modifiers(
                                mods.mask_pressed().bits(),
                                0,
@@ -331,7 +330,7 @@ impl XMods {

    fn update_by_key_event(&mut self, key: u32, state: u8) -> bool {
        if let Ok(key) = scancode::Linux::try_from(key) {
-            log::trace!("Attempting to process modifier from: {key:#?}");
+            log::trace!("Attempting to process modifier from: {:#?}", key);
            let pressed_mask = match key {
                scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
                scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
@@ -349,7 +348,7 @@ impl XMods {

            // unchanged
            if pressed_mask.is_empty() && locked_mask.is_empty() {
-                log::trace!("{key:#?} is not a modifier key");
+                log::trace!("{:#?} is not a modifier key", key);
                return false;
            }
            match state {
--- a/input-emulation/src/x11.rs
+++ b/input-emulation/src/x11.rs
@@ -23,7 +23,7 @@ impl X11Emulation {
    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
        let display = unsafe {
            match xlib::XOpenDisplay(ptr::null()) {
-                d if std::ptr::eq(d, ptr::null_mut::<xlib::Display>()) => {
+                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
                    Err(X11EmulationCreationError::OpenDisplay)
                }
                display => Ok(display),
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -143,6 +143,7 @@ impl Emulation for DesktopPortalEmulation<'_> {

 impl AsyncDrop for DesktopPortalEmulation<'_> {
    #[doc = r" Perform the async cleanup."]
+    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    fn async_drop<'async_trait>(
        self,
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -14,7 +14,7 @@ serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0.0"

 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.5.0", optional = true }
+reis = { version = "0.4", optional = true }

 [features]
 default = ["libei"]
--- a/input-event/src/lib.rs
+++ b/input-event/src/lib.rs
@@ -112,8 +112,8 @@ impl Display for KeyboardEvent {
 impl Display for Event {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            Event::Pointer(p) => write!(f, "{p}"),
-            Event::Keyboard(k) => write!(f, "{k}"),
+            Event::Pointer(p) => write!(f, "{}", p),
+            Event::Keyboard(k) => write!(f, "{}", k),
        }
    }
 }
--- a/lan-mouse-gtk/src/key_row.rs
+++ b/lan-mouse-gtk/src/key_row.rs
@@ -8,7 +8,7 @@ use super::KeyObject;

 glib::wrapper! {
    pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
-    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ActionRow,
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
    @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
 }

--- a/lan-mouse-gtk/src/window.rs
+++ b/lan-mouse-gtk/src/window.rs
@@ -324,7 +324,7 @@ impl Window {

    pub(super) fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
        let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
            return;
        };
        row.set_hostname(client.hostname);
@@ -334,11 +334,11 @@ impl Window {

    pub(super) fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
        let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
            return;
        };
        let Some(client_object) = self.client_object_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
            return;
        };

@@ -474,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(
@@ -499,6 +496,5 @@ impl Window {
            }),
        );
        window.present();
-        self.imp().authorization_window.replace(Some(window));
    }
 }
--- a/lan-mouse-gtk/src/window/imp.rs
+++ b/lan-mouse-gtk/src/window/imp.rs
@@ -8,8 +8,6 @@ use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Image, Label, ListBo

 use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};

-use crate::authorization_window::AuthorizationWindow;
-
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
 pub struct Window {
@@ -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]
--- a/lan-mouse-ipc/src/listen.rs
+++ b/lan-mouse-ipc/src/listen.rs
@@ -45,7 +45,7 @@ impl AsyncFrontendListener {
        let (socket_path, listener) = {
            let socket_path = crate::default_socket_path()?;

-            log::debug!("remove socket: {socket_path:?}");
+            log::debug!("remove socket: {:?}", socket_path);
            if socket_path.exists() {
                // try to connect to see if some other instance
                // of lan-mouse is already running
--- a/scripts/copy-macos-dylib.sh
+++ b/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!"
--- a/src/config.rs
+++ b/src/config.rs
@@ -51,7 +51,7 @@ struct ConfigToml {
    port: Option<u16>,
    release_bind: Option<Vec<scancode::Linux>>,
    cert_path: Option<PathBuf>,
-    clients: Option<Vec<TomlClient>>,
+    clients: Vec<TomlClient>,
    authorized_fingerprints: Option<HashMap<String, String>>,
 }

@@ -370,7 +370,6 @@ impl Config {
        self.config_toml
            .as_ref()
            .map(|c| c.clients.clone())
-            .unwrap_or_default()
            .into_iter()
            .flatten()
            .map(From::<TomlClient>::from)
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -3,7 +3,7 @@ use std::{collections::HashMap, net::IpAddr};
 use local_channel::mpsc::{channel, Receiver, Sender};
 use tokio::task::{spawn_local, JoinHandle};

-use hickory_resolver::{ResolveError, TokioResolver};
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 use tokio_util::sync::CancellationToken;

 use lan_mouse_ipc::ClientHandle;
@@ -26,7 +26,7 @@ pub(crate) enum DnsEvent {
 }

 struct DnsTask {
-    resolver: TokioResolver,
+    resolver: TokioAsyncResolver,
    request_rx: Receiver<DnsRequest>,
    event_tx: Sender<DnsEvent>,
    cancellation_token: CancellationToken,
@@ -35,7 +35,7 @@ struct DnsTask {

 impl DnsResolver {
    pub(crate) fn new() -> Result<Self, ResolveError> {
-        let resolver = TokioResolver::builder_tokio()?.build();
+        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
        let (request_tx, request_rx) = channel();
        let (event_tx, event_rx) = channel();
        let cancellation_token = CancellationToken::new();
--- a/src/emulation.rs
+++ b/src/emulation.rs
@@ -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
                }}
--- a/src/listen.rs
+++ b/src/listen.rs
@@ -264,7 +264,7 @@ async fn read_loop(
            }
        }
    }
-    log::info!("dtls client disconnected {addr:?}");
+    log::info!("dtls client disconnected {:?}", addr);
    let mut conns = conns.lock().await;
    let index = conns
        .iter()
--- a/src/service.rs
+++ b/src/service.rs
@@ -9,7 +9,7 @@ use crate::{
    listen::{LanMouseListener, ListenerCreationError},
 };
 use futures::StreamExt;
-use hickory_resolver::ResolveError;
+use hickory_resolver::error::ResolveError;
 use lan_mouse_ipc::{
    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
    IpcError, IpcListenerCreationError, Position, Status,
Author	SHA1	Message	Date
Ferdinand Schober	42521a1997	only alert on actual error	2025-03-22 22:12:17 +01:00
Ferdinand Schober	6e66f47887	ask the user to accept unauthorized devices	2025-03-22 21:56:13 +01:00