Compare commits

..

6 Commits

Author SHA1 Message Date
Ferdinand Schober
fcef748225 Revert "test windows deps"
This reverts commit 09c73d4fab.
2026-02-08 16:30:24 +01:00
Ferdinand Schober
09c73d4fab test windows deps 2026-02-08 15:39:32 +01:00
Ferdinand Schober
2a74e0acd2 clippy annotations 2026-02-08 15:37:52 +01:00
Ferdinand Schober
3a8298d1ce fix condition 2026-02-08 15:28:49 +01:00
Ferdinand Schober
1fbb6d2af6 separate run jobs 2026-02-08 15:27:37 +01:00
Ferdinand Schober
e8bd604609 rust.yml: run fmt/build/check/test separately 2026-02-08 15:22:16 +01:00
29 changed files with 1437 additions and 1598 deletions

View File

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

View File

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

View File

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

View File

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

View File

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

150
.github/workflows/tagged-release.yml vendored Normal file
View File

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

View File

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

1760
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

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

12
flake.lock generated
View File

@@ -2,11 +2,11 @@
"nodes": { "nodes": {
"nixpkgs": { "nixpkgs": {
"locked": { "locked": {
"lastModified": 1772963539, "lastModified": 1752687322,
"narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=", "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
"owner": "nixos", "owner": "nixos",
"repo": "nixpkgs", "repo": "nixpkgs",
"rev": "9dcb002ca1690658be4a04645215baea8b95f31d", "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
"type": "github" "type": "github"
}, },
"original": { "original": {
@@ -29,11 +29,11 @@
] ]
}, },
"locked": { "locked": {
"lastModified": 1773025773, "lastModified": 1752806774,
"narHash": "sha256-Wik8+xApNfldpUFjPmJkPdg0RrvUPSWGIZis+A/0N1w=", "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
"owner": "oxalica", "owner": "oxalica",
"repo": "rust-overlay", "repo": "rust-overlay",
"rev": "3c06fdbbd36ff60386a1e590ee0cd52dcd1892bf", "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
"type": "github" "type": "github"
}, },
"original": { "original": {

139
flake.nix
View File

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

View File

@@ -12,7 +12,7 @@ futures-core = "0.3.30"
log = "0.4.22" log = "0.4.22"
input-event = { path = "../input-event", version = "0.3.0" } input-event = { path = "../input-event", version = "0.3.0" }
memmap = "0.7" memmap = "0.7"
tempfile = "3.25.0" tempfile = "3.8"
thiserror = "2.0.0" thiserror = "2.0.0"
tokio = { version = "1.32.0", features = [ tokio = { version = "1.32.0", features = [
"io-util", "io-util",
@@ -41,8 +41,7 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
"client", "client",
], optional = true } ], optional = true }
x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true } x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
ashpd = { version = "0.13.9", default-features = false, features = [ ashpd = { version = "0.11.0", default-features = false, features = [
"input_capture",
"tokio", "tokio",
], optional = true } ], optional = true }
reis = { version = "0.5.0", features = ["tokio"], optional = true } reis = { version = "0.5.0", features = ["tokio"], optional = true }

View File

@@ -2,7 +2,6 @@ use std::{
collections::{HashMap, HashSet, VecDeque}, collections::{HashMap, HashSet, VecDeque},
fmt::Display, fmt::Display,
mem::swap, mem::swap,
sync::{Arc, Mutex},
task::{Poll, ready}, task::{Poll, ready},
}; };
@@ -130,24 +129,6 @@ pub struct InputCapture {
pending: VecDeque<(CaptureHandle, CaptureEvent)>, pending: VecDeque<(CaptureHandle, CaptureEvent)>,
} }
#[derive(Clone, Debug)]
pub enum WindowIdentifier {
Wayland(String),
X11(u32),
}
#[cfg(all(unix, feature = "libei"))]
impl Into<ashpd::WindowIdentifier> for WindowIdentifier {
fn into(self) -> ashpd::WindowIdentifier {
match self {
WindowIdentifier::Wayland(handle) => {
ashpd::WindowIdentifier::from_xdg_foreign_exported(handle)
}
WindowIdentifier::X11(_) => todo!(),
}
}
}
impl InputCapture { impl InputCapture {
/// create a new client with the given id /// create a new client with the given id
pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> { pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
@@ -196,11 +177,8 @@ impl InputCapture {
} }
/// creates a new [`InputCapture`] /// creates a new [`InputCapture`]
pub async fn new( pub async fn new(backend: Option<Backend>) -> Result<Self, CaptureCreationError> {
backend: Option<Backend>, let capture = create(backend).await?;
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> Result<Self, CaptureCreationError> {
let capture = create(backend, window_identifier).await?;
Ok(Self { Ok(Self {
capture, capture,
id_map: Default::default(), id_map: Default::default(),
@@ -302,16 +280,13 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
async fn create_backend( async fn create_backend(
backend: Backend, backend: Backend,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> Result< ) -> Result<
Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>, Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
CaptureCreationError, CaptureCreationError,
> { > {
match backend { match backend {
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))] #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
Backend::InputCapturePortal => Ok(Box::new( Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
libei::LibeiInputCapture::new(window_identifier).await?,
)),
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))] #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)), Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))] #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -326,13 +301,12 @@ async fn create_backend(
async fn create( async fn create(
backend: Option<Backend>, backend: Option<Backend>,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> Result< ) -> Result<
Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>, Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
CaptureCreationError, CaptureCreationError,
> { > {
if let Some(backend) = backend { if let Some(backend) = backend {
let b = create_backend(backend, window_identifier).await; let b = create_backend(backend).await;
if b.is_ok() { if b.is_ok() {
log::info!("using capture backend: {backend}"); log::info!("using capture backend: {backend}");
} }
@@ -351,7 +325,7 @@ async fn create(
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
Backend::MacOs, Backend::MacOs,
] { ] {
match create_backend(backend, window_identifier.clone()).await { match create_backend(backend).await {
Ok(b) => { Ok(b) => {
log::info!("using capture backend: {backend}"); log::info!("using capture backend: {backend}");
return Ok(b); return Ok(b);

View File

@@ -2,8 +2,8 @@ use ashpd::{
desktop::{ desktop::{
Session, Session,
input_capture::{ input_capture::{
Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, CreateSessionOptions, Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
InputCapture, Region, ReleaseOptions, Zones, Zones,
}, },
}, },
enumflags2::BitFlags, enumflags2::BitFlags,
@@ -23,7 +23,7 @@ use std::{
os::unix::net::UnixStream, os::unix::net::UnixStream,
pin::Pin, pin::Pin,
rc::Rc, rc::Rc,
sync::{Arc, Mutex}, sync::Arc,
task::{Context, Poll}, task::{Context, Poll},
}; };
use tokio::{ use tokio::{
@@ -39,7 +39,7 @@ use futures_core::Stream;
use input_event::Event; use input_event::Event;
use crate::{CaptureEvent, WindowIdentifier}; use crate::CaptureEvent;
use super::{ use super::{
Capture as LanMouseInputCapture, Position, Capture as LanMouseInputCapture, Position,
@@ -58,8 +58,8 @@ enum LibeiNotifyEvent {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub struct LibeiInputCapture { pub struct LibeiInputCapture<'a> {
input_capture: Pin<Box<InputCapture>>, input_capture: Pin<Box<InputCapture<'a>>>,
capture_task: JoinHandle<Result<(), CaptureError>>, capture_task: JoinHandle<Result<(), CaptureError>>,
event_rx: Receiver<(Position, CaptureEvent)>, event_rx: Receiver<(Position, CaptureEvent)>,
notify_capture: Sender<LibeiNotifyEvent>, notify_capture: Sender<LibeiNotifyEvent>,
@@ -130,15 +130,12 @@ fn select_barriers(
} }
async fn update_barriers( async fn update_barriers(
input_capture: &InputCapture, input_capture: &InputCapture<'_>,
session: &Session<InputCapture>, session: &Session<'_, InputCapture<'_>>,
active_clients: &[Position], active_clients: &[Position],
next_barrier_id: &mut NonZeroU32, next_barrier_id: &mut NonZeroU32,
) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> { ) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
let zones = input_capture let zones = input_capture.zones(session).await?.response()?;
.zones(session, Default::default())
.await?
.response()?;
log::debug!("zones: {zones:?}"); log::debug!("zones: {zones:?}");
let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id); let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
@@ -147,42 +144,31 @@ async fn update_barriers(
let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect(); let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
let response = input_capture let response = input_capture
.set_pointer_barriers( .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
session,
&ashpd_barriers,
zones.zone_set(),
Default::default(),
)
.await?; .await?;
let response = response.response()?; let response = response.response()?;
log::debug!("{response:?}"); log::debug!("{response:?}");
Ok((barriers, id_map)) Ok((barriers, id_map))
} }
async fn create_session( async fn create_session<'a>(
input_capture: &InputCapture, input_capture: &'a InputCapture<'a>,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>, ) -> std::result::Result<(Session<'a, InputCapture<'a>>, BitFlags<Capabilities>), ashpd::Error> {
) -> std::result::Result<(Session<InputCapture>, BitFlags<Capabilities>), ashpd::Error> { log::debug!("creating input capture session");
log::debug!("creating input capture session: {window_identifier:?}");
let window_identifier = window_identifier.lock().unwrap().clone();
let create_session_options = CreateSessionOptions::default().set_capabilities(
Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
);
let ashpd_window_identifier: Option<ashpd::WindowIdentifier> =
window_identifier.map(|i| i.into());
input_capture input_capture
.create_session(ashpd_window_identifier.as_ref(), create_session_options) .create_session(
None,
Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
)
.await .await
} }
async fn connect_to_eis( async fn connect_to_eis(
input_capture: &InputCapture, input_capture: &InputCapture<'_>,
session: &Session<InputCapture>, session: &Session<'_, InputCapture<'_>>,
) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> { ) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
log::debug!("connect_to_eis"); log::debug!("connect_to_eis");
let fd = input_capture let fd = input_capture.connect_to_eis(session).await?;
.connect_to_eis(session, Default::default())
.await?;
// create unix stream from fd // create unix stream from fd
let stream = UnixStream::from(fd); let stream = UnixStream::from(fd);
@@ -215,16 +201,11 @@ async fn libei_event_handler(
} }
} }
impl LibeiInputCapture { impl LibeiInputCapture<'_> {
/// creates a new libei input capture pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
/// `window_id` is a window identifier for user prompts
pub async fn new(
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> std::result::Result<Self, LibeiCaptureCreationError> {
let input_capture = Box::pin(InputCapture::new().await?); let input_capture = Box::pin(InputCapture::new().await?);
let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture; let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
let first_session = let first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
Some(create_session(unsafe { &*input_capture_ptr }, window_identifier.clone()).await?);
let (event_tx, event_rx) = mpsc::channel(1); let (event_tx, event_rx) = mpsc::channel(1);
let (notify_capture, notify_rx) = mpsc::channel(1); let (notify_capture, notify_rx) = mpsc::channel(1);
@@ -239,7 +220,6 @@ impl LibeiInputCapture {
first_session, first_session,
event_tx, event_tx,
cancellation_token.clone(), cancellation_token.clone(),
window_identifier,
); );
let capture_task = tokio::task::spawn_local(capture); let capture_task = tokio::task::spawn_local(capture);
@@ -258,13 +238,12 @@ impl LibeiInputCapture {
} }
async fn do_capture( async fn do_capture(
input_capture: *const InputCapture, input_capture: *const InputCapture<'static>,
mut capture_event: Receiver<LibeiNotifyEvent>, mut capture_event: Receiver<LibeiNotifyEvent>,
notify_release: Arc<Notify>, notify_release: Arc<Notify>,
session: Option<(Session<InputCapture>, BitFlags<Capabilities>)>, session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
event_tx: Sender<(Position, CaptureEvent)>, event_tx: Sender<(Position, CaptureEvent)>,
cancellation_token: CancellationToken, cancellation_token: CancellationToken,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> Result<(), CaptureError> { ) -> Result<(), CaptureError> {
let mut session = session.map(|s| s.0); let mut session = session.map(|s| s.0);
@@ -310,11 +289,7 @@ async fn do_capture(
// create session // create session
let mut session = match session.take() { let mut session = match session.take() {
Some(s) => s, Some(s) => s,
None => { None => create_session(input_capture).await?.0,
create_session(input_capture, window_identifier.clone())
.await?
.0
}
}; };
let capture_session = do_capture_session( let capture_session = do_capture_session(
@@ -332,7 +307,7 @@ async fn do_capture(
// disable capture // disable capture
log::debug!("disabling input capture"); log::debug!("disabling input capture");
if let Err(e) = input_capture.disable(&session, Default::default()).await { if let Err(e) = input_capture.disable(&session).await {
log::warn!("input_capture.disable(&session) {e}"); log::warn!("input_capture.disable(&session) {e}");
} }
if let Err(e) = session.close().await { if let Err(e) = session.close().await {
@@ -361,8 +336,8 @@ async fn do_capture(
} }
async fn do_capture_session( async fn do_capture_session(
input_capture: &InputCapture, input_capture: &InputCapture<'_>,
session: &mut Session<InputCapture>, session: &mut Session<'_, InputCapture<'_>>,
event_tx: &Sender<(Position, CaptureEvent)>, event_tx: &Sender<(Position, CaptureEvent)>,
active_clients: &[Position], active_clients: &[Position],
next_barrier_id: &mut NonZeroU32, next_barrier_id: &mut NonZeroU32,
@@ -381,7 +356,7 @@ async fn do_capture_session(
update_barriers(input_capture, session, active_clients, next_barrier_id).await?; update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
log::debug!("enabling session"); log::debug!("enabling session");
input_capture.enable(session, Default::default()).await?; input_capture.enable(session).await?;
// cancellation token to release session // cancellation token to release session
let release_session = Arc::new(Notify::new()); let release_session = Arc::new(Notify::new());
@@ -487,9 +462,9 @@ async fn do_capture_session(
Ok(()) Ok(())
} }
async fn release_capture( async fn release_capture<'a>(
input_capture: &InputCapture, input_capture: &InputCapture<'a>,
session: &Session<InputCapture>, session: &Session<'a, InputCapture<'a>>,
activated: Activated, activated: Activated,
current_pos: Position, current_pos: Position,
) -> Result<(), CaptureError> { ) -> Result<(), CaptureError> {
@@ -509,10 +484,9 @@ async fn release_capture(
}; };
// release 1px to the right of the entered zone // release 1px to the right of the entered zone
let cursor_position = (x as f64 + dx, y as f64 + dy); let cursor_position = (x as f64 + dx, y as f64 + dy);
let release_options = ReleaseOptions::default() input_capture
.set_activation_id(activated.activation_id()) .release(session, activated.activation_id(), Some(cursor_position))
.set_cursor_position(Some(cursor_position)); .await?;
input_capture.release(session, release_options).await?;
Ok(()) Ok(())
} }
@@ -587,7 +561,7 @@ async fn handle_ei_event(
} }
#[async_trait] #[async_trait]
impl LanMouseInputCapture for LibeiInputCapture { impl LanMouseInputCapture for LibeiInputCapture<'_> {
async fn create(&mut self, pos: Position) -> Result<(), CaptureError> { async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
let _ = self let _ = self
.notify_capture .notify_capture
@@ -624,7 +598,7 @@ impl LanMouseInputCapture for LibeiInputCapture {
} }
} }
impl Drop for LibeiInputCapture { impl Drop for LibeiInputCapture<'_> {
fn drop(&mut self) { fn drop(&mut self) {
if !self.terminated { if !self.terminated {
/* this workaround is needed until async drop is stabilized */ /* this workaround is needed until async drop is stabilized */
@@ -633,10 +607,10 @@ impl Drop for LibeiInputCapture {
} }
} }
impl Stream for LibeiInputCapture { impl Stream for LibeiInputCapture<'_> {
type Item = Result<(Position, CaptureEvent), CaptureError>; type Item = Result<(Position, CaptureEvent), CaptureError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> { fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
match self.capture_task.poll_unpin(cx) { match self.capture_task.poll_unpin(cx) {
Poll::Ready(r) => match r.expect("failed to join") { Poll::Ready(r) => match r.expect("failed to join") {
Ok(()) => Poll::Ready(None), Ok(()) => Poll::Ready(None),

View File

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

View File

@@ -40,9 +40,7 @@ wayland-protocols-misc = { version = "0.3.1", features = [
"client", "client",
], optional = true } ], optional = true }
x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true } x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
ashpd = { version = "0.13.9", default-features = false, features = [ ashpd = { version = "0.11.0", default-features = false, features = [
"remote_desktop",
"screencast",
"tokio", "tokio",
], optional = true } ], optional = true }
reis = { version = "0.5.0", features = ["tokio"], optional = true } reis = { version = "0.5.0", features = ["tokio"], optional = true }

View File

@@ -1,8 +1,7 @@
use futures::{StreamExt, future}; use futures::{StreamExt, future};
use std::{ use std::{
env, fs, io, io,
os::{fd::OwnedFd, unix::net::UnixStream}, os::{fd::OwnedFd, unix::net::UnixStream},
path::PathBuf,
sync::{ sync::{
Arc, Mutex, RwLock, Arc, Mutex, RwLock,
atomic::{AtomicBool, Ordering}, atomic::{AtomicBool, Ordering},
@@ -13,7 +12,7 @@ use tokio::task::JoinHandle;
use ashpd::desktop::{ use ashpd::desktop::{
PersistMode, Session, PersistMode, Session,
remote_desktop::{DeviceType, RemoteDesktop, SelectDevicesOptions}, remote_desktop::{DeviceType, RemoteDesktop},
}; };
use async_trait::async_trait; use async_trait::async_trait;
@@ -40,85 +39,42 @@ struct Devices {
keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>, keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
} }
pub(crate) struct LibeiEmulation { pub(crate) struct LibeiEmulation<'a> {
context: ei::Context, context: ei::Context,
conn: event::Connection, conn: event::Connection,
devices: Devices, devices: Devices,
ei_task: JoinHandle<()>, ei_task: JoinHandle<()>,
error: Arc<Mutex<Option<EmulationError>>>, error: Arc<Mutex<Option<EmulationError>>>,
libei_error: Arc<AtomicBool>, libei_error: Arc<AtomicBool>,
_remote_desktop: RemoteDesktop, _remote_desktop: RemoteDesktop<'a>,
session: Session<RemoteDesktop>, session: Session<'a, RemoteDesktop<'a>>,
} }
/// Get the path to the RemoteDesktop token file async fn get_ei_fd<'a>()
fn get_token_file_path() -> PathBuf { -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
let cache_dir = env::var("XDG_CACHE_HOME")
.ok()
.map(PathBuf::from)
.unwrap_or_else(|| {
let home = env::var("HOME").expect("HOME not set");
PathBuf::from(home).join(".cache")
});
cache_dir.join("lan-mouse").join("remote-desktop.token")
}
/// Read the RemoteDesktop token from file
fn read_token() -> Option<String> {
let token_path = get_token_file_path();
match fs::read_to_string(&token_path) {
Ok(token) => Some(token.trim().to_string()),
Err(_) => None,
}
}
/// Write the RemoteDesktop token to file
fn write_token(token: &str) -> io::Result<()> {
let token_path = get_token_file_path();
if let Some(parent) = token_path.parent() {
fs::create_dir_all(parent)?;
}
fs::write(&token_path, token)?;
Ok(())
}
async fn get_ei_fd() -> Result<(RemoteDesktop, Session<RemoteDesktop>, OwnedFd), ashpd::Error> {
let remote_desktop = RemoteDesktop::new().await?; let remote_desktop = RemoteDesktop::new().await?;
let restore_token = read_token();
log::debug!("creating session ..."); log::debug!("creating session ...");
let session = remote_desktop.create_session(Default::default()).await?; let session = remote_desktop.create_session().await?;
log::debug!("selecting devices ..."); log::debug!("selecting devices ...");
let options = SelectDevicesOptions::default() remote_desktop
.set_devices(DeviceType::Keyboard | DeviceType::Pointer) .select_devices(
.set_persist_mode(PersistMode::ExplicitlyRevoked) &session,
.set_restore_token(restore_token.as_deref()); DeviceType::Keyboard | DeviceType::Pointer,
remote_desktop.select_devices(&session, options).await?; None,
PersistMode::ExplicitlyRevoked,
)
.await?;
log::info!("requesting permission for input emulation"); log::info!("requesting permission for input emulation");
let start_response = remote_desktop let _devices = remote_desktop.start(&session, None).await?.response()?;
.start(&session, None, Default::default())
.await?
.response()?;
// The restore token is only valid once, we need to re-save it each time let fd = remote_desktop.connect_to_eis(&session).await?;
if let Some(token_str) = start_response.restore_token() {
if let Err(e) = write_token(token_str) {
log::warn!("failed to save RemoteDesktop token: {}", e);
}
}
let fd = remote_desktop
.connect_to_eis(&session, Default::default())
.await?;
Ok((remote_desktop, session, fd)) Ok((remote_desktop, session, fd))
} }
impl LibeiEmulation { impl LibeiEmulation<'_> {
pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> { pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
let (_remote_desktop, session, eifd) = get_ei_fd().await?; let (_remote_desktop, session, eifd) = get_ei_fd().await?;
let stream = UnixStream::from(eifd); let stream = UnixStream::from(eifd);
@@ -153,14 +109,14 @@ impl LibeiEmulation {
} }
} }
impl Drop for LibeiEmulation { impl Drop for LibeiEmulation<'_> {
fn drop(&mut self) { fn drop(&mut self) {
self.ei_task.abort(); self.ei_task.abort();
} }
} }
#[async_trait] #[async_trait]
impl Emulation for LibeiEmulation { impl Emulation for LibeiEmulation<'_> {
async fn consume( async fn consume(
&mut self, &mut self,
event: Event, event: Event,

View File

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

View File

@@ -1,10 +1,7 @@
use ashpd::{ use ashpd::{
desktop::{ desktop::{
PersistMode, Session, PersistMode, Session,
remote_desktop::{ remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
Axis, DeviceType, KeyState, NotifyPointerAxisOptions, RemoteDesktop,
SelectDevicesOptions,
},
}, },
zbus::AsyncDrop, zbus::AsyncDrop,
}; };
@@ -20,31 +17,32 @@ use crate::error::EmulationError;
use super::{Emulation, EmulationHandle, error::XdpEmulationCreationError}; use super::{Emulation, EmulationHandle, error::XdpEmulationCreationError};
pub(crate) struct DesktopPortalEmulation { pub(crate) struct DesktopPortalEmulation<'a> {
proxy: RemoteDesktop, proxy: RemoteDesktop<'a>,
session: Session<RemoteDesktop>, session: Session<'a, RemoteDesktop<'a>>,
} }
impl DesktopPortalEmulation { impl<'a> DesktopPortalEmulation<'a> {
pub(crate) async fn new() -> Result<DesktopPortalEmulation, XdpEmulationCreationError> { pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ..."); log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
let proxy = RemoteDesktop::new().await?; let proxy = RemoteDesktop::new().await?;
// retry when user presses the cancel button // retry when user presses the cancel button
log::debug!("creating session ..."); log::debug!("creating session ...");
let session = proxy.create_session(Default::default()).await?; let session = proxy.create_session().await?;
log::debug!("selecting devices ..."); log::debug!("selecting devices ...");
let options = SelectDevicesOptions::default() proxy
.set_devices(DeviceType::Keyboard | DeviceType::Pointer) .select_devices(
.set_persist_mode(PersistMode::ExplicitlyRevoked); &session,
proxy.select_devices(&session, options).await?; DeviceType::Keyboard | DeviceType::Pointer,
None,
PersistMode::ExplicitlyRevoked,
)
.await?;
log::info!("requesting permission for input emulation"); log::info!("requesting permission for input emulation");
let _devices = proxy let _devices = proxy.start(&session, None).await?.response()?;
.start(&session, None, Default::default())
.await?
.response()?;
log::debug!("started session"); log::debug!("started session");
let session = session; let session = session;
@@ -54,7 +52,7 @@ impl DesktopPortalEmulation {
} }
#[async_trait] #[async_trait]
impl Emulation for DesktopPortalEmulation { impl Emulation for DesktopPortalEmulation<'_> {
async fn consume( async fn consume(
&mut self, &mut self,
event: input_event::Event, event: input_event::Event,
@@ -64,7 +62,7 @@ impl Emulation for DesktopPortalEmulation {
Pointer(p) => match p { Pointer(p) => match p {
PointerEvent::Motion { time: _, dx, dy } => { PointerEvent::Motion { time: _, dx, dy } => {
self.proxy self.proxy
.notify_pointer_motion(&self.session, dx, dy, Default::default()) .notify_pointer_motion(&self.session, dx, dy)
.await?; .await?;
} }
PointerEvent::Button { PointerEvent::Button {
@@ -77,12 +75,7 @@ impl Emulation for DesktopPortalEmulation {
_ => KeyState::Pressed, _ => KeyState::Pressed,
}; };
self.proxy self.proxy
.notify_pointer_button( .notify_pointer_button(&self.session, button as i32, state)
&self.session,
button as i32,
state,
Default::default(),
)
.await?; .await?;
} }
PointerEvent::AxisDiscrete120 { axis, value } => { PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -91,12 +84,7 @@ impl Emulation for DesktopPortalEmulation {
_ => Axis::Horizontal, _ => Axis::Horizontal,
}; };
self.proxy self.proxy
.notify_pointer_axis_discrete( .notify_pointer_axis_discrete(&self.session, axis, value / 120)
&self.session,
axis,
value / 120,
Default::default(),
)
.await?; .await?;
} }
PointerEvent::Axis { PointerEvent::Axis {
@@ -113,12 +101,7 @@ impl Emulation for DesktopPortalEmulation {
Axis::Horizontal => (value, 0.), Axis::Horizontal => (value, 0.),
}; };
self.proxy self.proxy
.notify_pointer_axis( .notify_pointer_axis(&self.session, dx, dy, true)
&self.session,
dx,
dy,
NotifyPointerAxisOptions::default().set_finish(true),
)
.await?; .await?;
} }
}, },
@@ -134,12 +117,7 @@ impl Emulation for DesktopPortalEmulation {
_ => KeyState::Pressed, _ => KeyState::Pressed,
}; };
self.proxy self.proxy
.notify_keyboard_keycode( .notify_keyboard_keycode(&self.session, key as i32, state)
&self.session,
key as i32,
state,
Default::default(),
)
.await?; .await?;
} }
KeyboardEvent::Modifiers { .. } => { KeyboardEvent::Modifiers { .. } => {
@@ -163,7 +141,7 @@ impl Emulation for DesktopPortalEmulation {
} }
} }
impl AsyncDrop for DesktopPortalEmulation { impl AsyncDrop for DesktopPortalEmulation<'_> {
#[doc = r" Perform the async cleanup."] #[doc = r" Perform the async cleanup."]
#[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)] #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
fn async_drop<'async_trait>( fn async_drop<'async_trait>(

View File

@@ -15,13 +15,5 @@ log = "0.4.20"
lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" } lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
thiserror = "2.0.0" thiserror = "2.0.0"
[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
gdk4_wayland = { package = "gdk4-wayland", version="0.9.6", optional=true }
[build-dependencies] [build-dependencies]
glib-build-tools = { version = "0.20.0" } glib-build-tools = { version = "0.20.0" }
[features]
default = ["wayland_window_identifier"]
wayland_window_identifier = ["dep:gdk4_wayland"]

View File

@@ -10,7 +10,7 @@ use std::{env, process, str};
use window::Window; use window::Window;
use lan_mouse_ipc::{FrontendEvent, FrontendRequest, WindowIdentifier}; use lan_mouse_ipc::FrontendEvent;
use adw::Application; use adw::Application;
use gtk::{IconTheme, gdk::Display, glib::clone, prelude::*}; use gtk::{IconTheme, gdk::Display, glib::clone, prelude::*};
@@ -19,9 +19,6 @@ use gtk::{gio, glib, prelude::ApplicationExt};
use self::client_object::ClientObject; use self::client_object::ClientObject;
use self::key_object::KeyObject; use self::key_object::KeyObject;
#[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
use gdk4_wayland::WaylandToplevel;
use thiserror::Error; use thiserror::Error;
#[derive(Error, Debug)] #[derive(Error, Debug)]
@@ -127,28 +124,6 @@ fn build_ui(app: &Application) {
let window = Window::new(app, frontend_tx); let window = Window::new(app, frontend_tx);
// export TopLevel handle and send it to the service so that it can put the InpuCapture / RemoteDesktop
// windows on top of it using xdg-foreign.
#[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
window.connect_show(|window| {
// needs the surface so we have to present first!
if let Some(surface) = window.surface() {
if surface.display().backend().is_wayland() {
// let surface = surface.downcast::<WaylandSurface>();
let toplevel = surface.downcast::<WaylandToplevel>().expect("xdg-toplevel");
let window = window.clone();
toplevel.export_handle(move |_toplevel, handle| {
if let Ok(handle) = handle {
let handle = handle.to_string();
window.request(FrontendRequest::WindowIdentifier(
WindowIdentifier::Wayland(handle),
));
}
});
}
}
});
glib::spawn_future_local(clone!( glib::spawn_future_local(clone!(
#[weak] #[weak]
window, window,

View File

@@ -422,7 +422,7 @@ impl Window {
self.request(FrontendRequest::RemoveAuthorizedKey(fp)); self.request(FrontendRequest::RemoveAuthorizedKey(fp));
} }
pub(crate) fn request(&self, request: FrontendRequest) { fn request(&self, request: FrontendRequest) {
let mut requester = self.imp().frontend_request_writer.borrow_mut(); let mut requester = self.imp().frontend_request_writer.borrow_mut();
let requester = requester.as_mut().unwrap(); let requester = requester.as_mut().unwrap();
if let Err(e) = requester.request(request) { if let Err(e) = requester.request(request) {

View File

@@ -255,14 +255,6 @@ pub enum FrontendRequest {
UpdateEnterHook(u64, Option<String>), UpdateEnterHook(u64, Option<String>),
/// save config file /// save config file
SaveConfiguration, SaveConfiguration,
/// window identifier used to present input-capture / remote-desktop prompts
WindowIdentifier(WindowIdentifier),
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum WindowIdentifier {
Wayland(String),
X11(u32),
} }
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)] #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]

View File

@@ -1,40 +1,34 @@
{ {
stdenv,
rustPlatform, rustPlatform,
lib, lib,
pkg-config, pkgs,
libX11, }: let
gtk4, cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
libadwaita,
libXtst,
wrapGAppsHook4,
librsvg,
git,
}:
let
cargoToml = fromTOML (builtins.readFile ../Cargo.toml);
pname = cargoToml.package.name; pname = cargoToml.package.name;
version = cargoToml.package.version; version = cargoToml.package.version;
in in
rustPlatform.buildRustPackage { rustPlatform.buildRustPackage {
inherit pname; pname = pname;
inherit version; version = version;
nativeBuildInputs = [ nativeBuildInputs = with pkgs; [
pkg-config
wrapGAppsHook4
git git
pkg-config
cmake
makeWrapper
buildPackages.gtk4
]; ];
buildInputs = [ buildInputs = with pkgs; [
xorg.libX11
gtk4 gtk4
libadwaita libadwaita
librsvg xorg.libXtst
] ] ++ lib.optionals stdenv.isDarwin
++ lib.optionals stdenv.isLinux [ (with darwin.apple_sdk_11_0.frameworks; [
libX11 CoreGraphics
libXtst ApplicationServices
]; ]);
src = builtins.path { src = builtins.path {
name = pname; name = pname;
@@ -46,7 +40,11 @@ rustPlatform.buildRustPackage {
# Set Environment Variables # Set Environment Variables
RUST_BACKTRACE = "full"; RUST_BACKTRACE = "full";
# Needed to enable support for SVG icons in GTK
postInstall = '' postInstall = ''
wrapProgram "$out/bin/lan-mouse" \
--set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
install -Dm444 *.desktop -t $out/share/applications install -Dm444 *.desktop -t $out/share/applications
install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
''; '';

View File

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

View File

@@ -1,14 +1,12 @@
use std::{ use std::{
cell::{Cell, RefCell}, cell::{Cell, RefCell},
rc::Rc, rc::Rc,
sync::{Arc, Mutex},
time::{Duration, Instant}, time::{Duration, Instant},
}; };
use futures::StreamExt; use futures::StreamExt;
use input_capture::{ use input_capture::{
CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
WindowIdentifier,
}; };
use input_event::scancode; use input_event::scancode;
use lan_mouse_proto::ProtoEvent; use lan_mouse_proto::ProtoEvent;
@@ -51,7 +49,7 @@ pub(crate) enum CaptureType {
EnterOnly, EnterOnly,
} }
#[derive(Clone, Debug)] #[derive(Clone, Copy, Debug)]
enum CaptureRequest { enum CaptureRequest {
/// capture must release the mouse /// capture must release the mouse
Release, Release,
@@ -68,7 +66,6 @@ impl Capture {
backend: Option<input_capture::Backend>, backend: Option<input_capture::Backend>,
conn: LanMouseConnection, conn: LanMouseConnection,
release_bind: Vec<scancode::Linux>, release_bind: Vec<scancode::Linux>,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
) -> Self { ) -> Self {
let (request_tx, request_rx) = channel(); let (request_tx, request_rx) = channel();
let (event_tx, event_rx) = channel(); let (event_tx, event_rx) = channel();
@@ -83,7 +80,6 @@ impl Capture {
request_rx, request_rx,
release_bind: Rc::new(RefCell::new(release_bind)), release_bind: Rc::new(RefCell::new(release_bind)),
state: Default::default(), state: Default::default(),
window_identifier,
}; };
let task = spawn_local(capture_task.run()); let task = spawn_local(capture_task.run());
Self { Self {
@@ -164,7 +160,6 @@ struct CaptureTask {
release_bind: Rc<RefCell<Vec<scancode::Linux>>>, release_bind: Rc<RefCell<Vec<scancode::Linux>>>,
request_rx: Receiver<CaptureRequest>, request_rx: Receiver<CaptureRequest>,
state: State, state: State,
window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
} }
impl CaptureTask { impl CaptureTask {
@@ -199,7 +194,6 @@ impl CaptureTask {
} }
async fn run(mut self) { async fn run(mut self) {
tokio::time::sleep(Duration::from_secs(1)).await;
loop { loop {
if let Err(e) = self.do_capture().await { if let Err(e) = self.do_capture().await {
log::warn!("input capture exited: {e}"); log::warn!("input capture exited: {e}");
@@ -207,10 +201,10 @@ impl CaptureTask {
loop { loop {
tokio::select! { tokio::select! {
r = self.request_rx.recv() => match r.expect("channel closed") { r = self.request_rx.recv() => match r.expect("channel closed") {
CaptureRequest::Reenable=>break, CaptureRequest::Reenable => break,
CaptureRequest::Create(h,p,t)=>self.add_capture(h,p,t), CaptureRequest::Create(h, p, t) => self.add_capture(h, p, t),
CaptureRequest::Destroy(h)=>self.remove_capture(h), CaptureRequest::Destroy(h) => self.remove_capture(h),
CaptureRequest::Release=>{} CaptureRequest::Release => { /* nothing to do */ }
}, },
_ = self.cancellation_token.cancelled() => return, _ = self.cancellation_token.cancelled() => return,
} }
@@ -221,7 +215,7 @@ impl CaptureTask {
async fn do_capture(&mut self) -> Result<(), InputCaptureError> { async fn do_capture(&mut self) -> Result<(), InputCaptureError> {
/* allow cancelling capture request */ /* allow cancelling capture request */
let mut capture = tokio::select! { let mut capture = tokio::select! {
r = InputCapture::new(self.backend, self.window_identifier.clone()) => r?, r = InputCapture::new(self.backend) => r?,
_ = self.cancellation_token.cancelled() => return Ok(()), _ = self.cancellation_token.cancelled() => return Ok(()),
}; };
@@ -291,10 +285,16 @@ impl CaptureTask {
} }
}, },
e = self.request_rx.recv() => match e.expect("channel closed") { e = self.request_rx.recv() => match e.expect("channel closed") {
CaptureRequest::Reenable=>{}, CaptureRequest::Reenable => { /* already active */ },
CaptureRequest::Release=>self.release_capture(capture).await?, CaptureRequest::Release => self.release_capture(capture).await?,
CaptureRequest::Create(h,p,t)=>{self.add_capture(h,p,t);capture.create(h,p).await?;} CaptureRequest::Create(h, p, t) => {
CaptureRequest::Destroy(h)=>{self.remove_capture(h);capture.destroy(h).await?;} self.add_capture(h, p, t);
capture.create(h, p).await?;
}
CaptureRequest::Destroy(h) => {
self.remove_capture(h);
capture.destroy(h).await?;
}
}, },
_ = self.cancellation_token.cancelled() => break, _ = self.cancellation_token.cancelled() => break,
} }

View File

@@ -1,5 +1,3 @@
use std::sync::{Arc, Mutex};
use crate::config::Config; use crate::config::Config;
use clap::Args; use clap::Args;
use futures::StreamExt; use futures::StreamExt;
@@ -14,7 +12,7 @@ pub async fn run(config: Config, _args: TestCaptureArgs) -> Result<(), InputCapt
log::info!("creating input capture"); log::info!("creating input capture");
let backend = config.capture_backend().map(|b| b.into()); let backend = config.capture_backend().map(|b| b.into());
loop { loop {
let mut input_capture = InputCapture::new(backend, Arc::new(Mutex::new(None))).await?; let mut input_capture = InputCapture::new(backend).await?;
log::info!("creating clients"); log::info!("creating clients");
input_capture.create(0, Position::Left).await?; input_capture.create(0, Position::Left).await?;
input_capture.create(4, Position::Left).await?; input_capture.create(4, Position::Left).await?;

View File

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

View File

@@ -19,7 +19,7 @@ use std::{
collections::{HashMap, HashSet, VecDeque}, collections::{HashMap, HashSet, VecDeque},
io, io,
net::{IpAddr, SocketAddr}, net::{IpAddr, SocketAddr},
sync::{Arc, Mutex, RwLock}, sync::{Arc, RwLock},
}; };
use thiserror::Error; use thiserror::Error;
use tokio::{process::Command, signal, sync::Notify}; use tokio::{process::Command, signal, sync::Notify};
@@ -70,7 +70,6 @@ pub struct Service {
/// map from capture handle to connection info /// map from capture handle to connection info
incoming_conn_info: HashMap<ClientHandle, Incoming>, incoming_conn_info: HashMap<ClientHandle, Incoming>,
next_trigger_handle: u64, next_trigger_handle: u64,
window_identifier: Arc<Mutex<Option<input_capture::WindowIdentifier>>>,
} }
#[derive(Debug)] #[derive(Debug)]
@@ -116,13 +115,7 @@ impl Service {
// input capture + emulation // input capture + emulation
let capture_backend = config.capture_backend().map(|b| b.into()); let capture_backend = config.capture_backend().map(|b| b.into());
let window_identifier = Arc::new(Mutex::new(None)); let capture = Capture::new(capture_backend, conn, config.release_bind());
let capture = Capture::new(
capture_backend,
conn,
config.release_bind(),
window_identifier.clone(),
);
let emulation_backend = config.emulation_backend().map(|b| b.into()); let emulation_backend = config.emulation_backend().map(|b| b.into());
let emulation = Emulation::new(emulation_backend, listener); let emulation = Emulation::new(emulation_backend, listener);
@@ -147,7 +140,6 @@ impl Service {
incoming_conn_info: Default::default(), incoming_conn_info: Default::default(),
incoming_conns: Default::default(), incoming_conns: Default::default(),
next_trigger_handle: 0, next_trigger_handle: 0,
window_identifier,
}; };
Ok(service) Ok(service)
} }
@@ -239,20 +231,6 @@ impl Service {
self.update_enter_hook(handle, enter_hook) self.update_enter_hook(handle, enter_hook)
} }
FrontendRequest::SaveConfiguration => self.save_config(), FrontendRequest::SaveConfiguration => self.save_config(),
FrontendRequest::WindowIdentifier(handle) => {
log::info!("xdg-foreign handle: {handle:?}");
self.window_identifier
.lock()
.unwrap()
.replace(match handle {
lan_mouse_ipc::WindowIdentifier::Wayland(handle) => {
input_capture::WindowIdentifier::Wayland(handle)
}
lan_mouse_ipc::WindowIdentifier::X11(xid) => {
input_capture::WindowIdentifier::X11(xid)
}
});
}
} }
} }