macos: emulate double / triple click

The division by 120 was correct.

.github/workflows/pre-release.yml

@@ -94,7 +94,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle --release
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -120,7 +122,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle --release
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.github/workflows/rust.yml

@@ -112,7 +112,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle
+      run: |
+        cargo bundle
+        scripts/copy-macos-dylib.sh
     - name: Zip bundle
       run: |
         cd target/debug/bundle/osx
@@ -142,7 +144,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle
+      run: |
+        cargo bundle
+        scripts/copy-macos-dylib.sh
     - name: Zip bundle
       run: |
         cd target/debug/bundle/osx

.github/workflows/tagged-release.yml

@@ -90,7 +90,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle --release
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -116,7 +118,9 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: cargo bundle --release
+      run: |
+        cargo bundle --release
+        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.gitignore

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

README.md

@@ -81,15 +81,37 @@ 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).
+First make sure to [install the necessary dependencies](#installing-dependencies-for-development--compiling-from-source).
 
 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 Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies-for-development--compiling-from-source).
 
 Alternatively, the `lan-mouse` binary can be compiled from source (see below).
 
@@ -161,7 +183,15 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
     <summary>MacOS</summary>
 
 ```sh
-brew install libadwaita pkg-config
+# 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
 ```
 </details>
 

build-aux/de.feschber.LanMouse.yml

@@ -0,0 +1,50 @@
+# 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

@@ -1,14 +0,0 @@
-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

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

input-emulation/Cargo.toml

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

input-emulation/src/macos.rs

@@ -10,25 +10,37 @@ use core_graphics::event::{
     ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
+use input_event::{scancode, Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
 use std::ops::{Index, IndexMut};
 use std::rc::Rc;
 use std::sync::Arc;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 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>,
 }
 
@@ -74,6 +86,9 @@ impl MacOSEmulation {
         Ok(Self {
             event_source,
             button_state,
+            previous_button: None,
+            previous_button_click: None,
+            button_click_state: 1,
             repeat_task: None,
             notify_repeat_task: Arc::new(Notify::new()),
             modifier_state: Rc::new(Cell::new(XMods::empty())),
@@ -271,24 +286,12 @@ impl Emulation for MacOSEmulation {
                     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)
-                        }
+                        (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(());
@@ -297,6 +300,22 @@ impl Emulation for MacOSEmulation {
                     // 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());
+                    }
+
+                    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(),
@@ -310,6 +329,10 @@ impl Emulation for MacOSEmulation {
                             return Ok(());
                         }
                     };
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_CLICK_STATE,
+                        self.button_click_state,
+                    );
                     event.post(CGEventTapLocation::HID);
                 }
                 PointerEvent::Axis {
@@ -343,9 +366,10 @@ impl Emulation for MacOSEmulation {
                     event.post(CGEventTapLocation::HID);
                 }
                 PointerEvent::AxisDiscrete120 { axis, value } => {
+                    const LINES_PER_STEP: i32 = 3;
                     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)
+                        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(());
@@ -353,7 +377,7 @@ impl Emulation for MacOSEmulation {
                     };
                     let event = match CGEvent::new_scroll_event(
                         self.event_source.clone(),
-                        ScrollEventUnit::PIXEL,
+                        ScrollEventUnit::LINE,
                         count,
                         wheel1,
                         wheel2,
@@ -416,6 +440,21 @@ impl Emulation for MacOSEmulation {
     async fn terminate(&mut self) {}
 }
 
+trait ButtonEq {
+    fn eq(&self, other: &Self) -> bool;
+}
+
+impl ButtonEq for CGMouseButton {
+    fn eq(&self, other: &Self) -> bool {
+        matches!(
+            (self, other),
+            (CGMouseButton::Left, CGMouseButton::Left)
+                | (CGMouseButton::Right, CGMouseButton::Right)
+                | (CGMouseButton::Center, CGMouseButton::Center)
+        )
+    }
+}
+
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
     if let Ok(key) = scancode::Linux::try_from(key) {
         let mask = match key {

input-emulation/src/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, ButtonState};
+use wayland_client::protocol::wl_pointer::{Axis, AxisSource, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
     zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
@@ -210,7 +210,8 @@ impl VirtualInput {
                     PointerEvent::AxisDiscrete120 { axis, value } => {
                         let axis: Axis = (axis as u32).try_into()?;
                         self.pointer
-                            .axis_discrete(now, axis, value as f64 / 6., value / 120);
+                            .axis_discrete(now, axis, value as f64 / 8., value / 120);
+                        self.pointer.axis_source(AxisSource::Wheel);
                         self.pointer.frame();
                     }
                 }

lan-mouse-gtk/src/window.rs

@@ -474,6 +474,9 @@ 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(
@@ -496,5 +499,6 @@ impl Window {
             }),
         );
         window.present();
+        self.imp().authorization_window.replace(Some(window));
     }
 }

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

@@ -8,6 +8,8 @@ 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 {
@@ -49,6 +51,7 @@ 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]

scripts/copy-macos-dylib.sh

@@ -0,0 +1,93 @@
+#!/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/emulation.rs

@@ -128,6 +128,7 @@ 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 {
@@ -156,7 +157,10 @@ impl ListenTask {
                         self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
                     }
                     Some(ListenEvent::Rejected { fingerprint }) => {
-                        self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
+                        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");
+                            }
                     }
                     None => break
                 }}