fix the 2nd

fix windows
2026-03-08 04:20:01 +03:00 · 2024-07-01 18:47:25 +02:00 · 2024-07-01 17:34:28 +02:00 · 2024-07-01 17:16:36 +02:00 · 2024-07-01 17:03:53 +02:00 · 2024-07-01 17:02:37 +02:00
40 changed files with 913 additions and 465 deletions
--- a/.github/workflows/cachix.yml
+++ b/.github/workflows/cachix.yml
@@ -7,7 +7,7 @@ jobs:
      matrix:
       os: 
        - ubuntu-latest
-        - macos-latest
+        - macos-13
        - macos-14
    name: "Build"
    runs-on: ${{ matrix.os }} 
@@ -31,7 +31,7 @@ jobs:
      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse

    - name: Build lan-mouse (x86_64-darwin)
-      if: matrix.os == 'macos-latest'
+      if: matrix.os == 'macos-13'
      run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse

    - name: Build lan-mouse (aarch64-darwin)
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -78,7 +78,7 @@ jobs:
        path: lan-mouse-windows.zip

  macos-release-build:
-    runs-on: macos-latest
+    runs-on: macos-13
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -92,7 +92,7 @@ jobs:
          target/debug/*.dll

  build-macos:
-    runs-on: macos-latest
+    runs-on: macos-13
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -74,7 +74,7 @@ jobs:
        path: lan-mouse-windows.zip

  macos-release-build:
-    runs-on: macos-latest
+    runs-on: macos-13
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1284,7 +1284,7 @@ dependencies = [

 [[package]]
 name = "lan-mouse"
-version = "0.7.3"
+version = "0.8.0"
 dependencies = [
 "anyhow",
 "ashpd",
@@ -1292,6 +1292,7 @@ dependencies = [
 "async-trait",
 "clap",
 "core-graphics",
+ "endi",
 "env_logger",
 "futures",
 "futures-core",
@@ -1311,6 +1312,7 @@ dependencies = [
 "serde_json",
 "slab",
 "tempfile",
+ "thiserror",
 "tokio",
 "toml",
 "wayland-client",
@@ -2010,18 +2012,18 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.58"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.58"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.7.3"
+version = "0.8.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/ferdinandschober/lan-mouse"
@@ -22,7 +22,7 @@ anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
-tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "rt", "sync", "signal"] }
+tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
 async-trait = "0.1.73"
 futures-core = "0.3.28"
 futures = "0.3.28"
@@ -35,6 +35,8 @@ once_cell = "1.19.0"
 num_enum = "0.7.2"
 hostname = "0.4.0"
 slab = "0.4.9"
+endi = "1.1.0"
+thiserror = "1.0.61"

 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
--- a/README.md
+++ b/README.md
@@ -69,7 +69,15 @@ Precompiled release binaries for Windows, MacOS and Linux are available in the [
 For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).

 ### Arch Linux
-Lan Mouse is available on the AUR:
+
+Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):
+
+```sh
+pacman -S lan-mouse
+```
+
+It is also available on the AUR:
+
 ```sh
 # git version (includes latest changes)
 paru -S lan-mouse-git
--- a/config.toml
+++ b/config.toml
@@ -1,5 +1,7 @@
 # example configuration

+# capture_backend = "LayerShell"
+
 # release bind
 release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]

--- a/flake.lock
+++ b/flake.lock
@@ -20,11 +20,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1710806803,
-        "narHash": "sha256-qrxvLS888pNJFwJdK+hf1wpRCSQcqA6W5+Ox202NDa0=",
+        "lastModified": 1716293225,
+        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "b06025f1533a1e07b6db3e75151caa155d1c7eb3",
+        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
        "type": "github"
      },
      "original": {
@@ -48,11 +48,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1710987136,
-        "narHash": "sha256-Q8GRdlAIKZ8tJUXrbcRO1pA33AdoPfTUirsSnmGQnOU=",
+        "lastModified": 1716257780,
+        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "97596b54ac34ad8184ca1eef44b1ec2e5c2b5f9e",
+        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
        "type": "github"
      },
      "original": {
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -2,10 +2,14 @@
  rustPlatform,
  lib,
  pkgs,
-}:
+}: let
+  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
+  pname = cargoToml.package.name;
+  version = cargoToml.package.version;
+in
 rustPlatform.buildRustPackage {
-  pname = "lan-mouse";
-  version = "0.7.0";
+  pname = pname;
+  version = version;

  nativeBuildInputs = with pkgs; [
    pkg-config
@@ -23,7 +27,7 @@ rustPlatform.buildRustPackage {
  ];

  src = builtins.path {
-    name = "lan-mouse";
+    name = pname;
    path = lib.cleanSource ../.;
  };

@@ -38,7 +42,7 @@ rustPlatform.buildRustPackage {
      Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices. It allows for using multiple pcs with a single set of mouse and keyboard. This is also known as a Software KVM switch.
      The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
    '';
-    mainProgram = "lan-mouse";
+    mainProgram = pname;
    platforms = platforms.all;
  };
 }
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -4,9 +4,14 @@ use futures_core::Stream;

 use crate::{
    client::{ClientEvent, ClientHandle},
+    config::CaptureBackend,
    event::Event,
 };

+use self::error::CaptureCreationError;
+
+pub mod error;
+
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 pub mod libei;

@@ -25,48 +30,57 @@ pub mod x11;
 /// fallback input capture (does not produce events)
 pub mod dummy;

-pub async fn create() -> Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>> {
-    #[cfg(target_os = "macos")]
-    match macos::MacOSInputCapture::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("macos input capture not available: {e}"),
+pub async fn create_backend(
+    backend: CaptureBackend,
+) -> Result<Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>>, CaptureCreationError> {
+    match backend {
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        CaptureBackend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        CaptureBackend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        CaptureBackend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
+        #[cfg(windows)]
+        CaptureBackend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
+        #[cfg(target_os = "macos")]
+        CaptureBackend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
+        CaptureBackend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
    }
+}

-    #[cfg(windows)]
-    match windows::WindowsInputCapture::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("windows input capture not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    match libei::LibeiInputCapture::new().await {
-        Ok(p) => {
-            log::info!("using libei input capture");
-            return Box::new(p);
+pub async fn create(
+    backend: Option<CaptureBackend>,
+) -> Result<Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>>, CaptureCreationError> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using capture backend: {backend}");
        }
-        Err(e) => log::info!("libei input capture not available: {e}"),
+        return b;
    }

-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    match wayland::WaylandInputCapture::new() {
-        Ok(p) => {
-            log::info!("using layer-shell input capture");
-            return Box::new(p);
+    for backend in [
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        CaptureBackend::InputCapturePortal,
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        CaptureBackend::LayerShell,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        CaptureBackend::X11,
+        #[cfg(windows)]
+        CaptureBackend::Windows,
+        #[cfg(target_os = "macos")]
+        CaptureBackend::MacOs,
+        CaptureBackend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using capture backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
        }
-        Err(e) => log::info!("layer_shell input capture not available: {e}"),
    }
-
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    match x11::X11InputCapture::new() {
-        Ok(p) => {
-            log::info!("using x11 input capture");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("x11 input capture not available: {e}"),
-    }
-
-    log::error!("falling back to dummy input capture");
-    Box::new(dummy::DummyInputCapture::new())
+    Err(CaptureCreationError::NoAvailableBackend)
 }

 pub trait InputCapture: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
--- a/src/capture/error.rs
+++ b/src/capture/error.rs
@@ -0,0 +1,142 @@
+use std::fmt::Display;
+use thiserror::Error;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use std::io;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[derive(Debug, Error)]
+pub enum CaptureCreationError {
+    NoAvailableBackend,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei(#[from] LibeiCaptureCreationError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell(#[from] LayerShellCaptureCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11(#[from] X11InputCaptureCreationError),
+    #[cfg(target_os = "macos")]
+    Macos(#[from] MacOSInputCaptureCreationError),
+    #[cfg(windows)]
+    Windows,
+}
+
+impl Display for CaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureCreationError::Libei(reason) => {
+                format!("error creating portal backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureCreationError::LayerShell(reason) => {
+                format!("error creating layer-shell backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureCreationError::X11(e) => format!("{e}"),
+            #[cfg(target_os = "macos")]
+            CaptureCreationError::Macos(e) => format!("{e}"),
+            #[cfg(windows)]
+            CaptureCreationError::Windows => String::new(),
+            CaptureCreationError::NoAvailableBackend => "no available backend".to_string(),
+        };
+        write!(f, "could not create input capture: {reason}")
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiCaptureCreationError {
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiCaptureCreationError::Ashpd(portal_error) => write!(f, "{portal_error}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LayerShellCaptureCreationError {
+    Connect(#[from] ConnectError),
+    Global(#[from] GlobalError),
+    Wayland(#[from] WaylandError),
+    Bind(#[from] WaylandBindError),
+    Dispatch(#[from] DispatchError),
+    Io(#[from] io::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for LayerShellCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LayerShellCaptureCreationError::Bind(e) => write!(f, "{e}"),
+            LayerShellCaptureCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            LayerShellCaptureCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            LayerShellCaptureCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11InputCaptureCreationError {
+    NotImplemented,
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11InputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "X11 input capture is not yet implemented :(")
+    }
+}
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSInputCaptureCreationError {
+    NotImplemented,
+}
+
+#[cfg(target_os = "macos")]
+impl Display for MacOSInputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "macos input capture is not yet implemented :(")
+    }
+}
--- a/src/capture/libei.rs
+++ b/src/capture/libei.rs
@@ -36,6 +36,8 @@ use crate::{
    event::{Event, KeyboardEvent, PointerEvent},
 };

+use super::error::LibeiCaptureCreationError;
+
 #[derive(Debug)]
 enum ProducerEvent {
    Release,
@@ -131,7 +133,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {

 async fn create_session<'a>(
    input_capture: &'a InputCapture<'a>,
-) -> Result<(Session<'a>, BitFlags<Capabilities>)> {
+) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
    log::debug!("creating input capture session");
    let (session, capabilities) = loop {
        match input_capture
@@ -213,7 +215,7 @@ async fn wait_for_active_client(
 }

 impl<'a> LibeiInputCapture<'a> {
-    pub async fn new() -> Result<Self> {
+    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
        let input_capture = Box::pin(InputCapture::new().await?);
        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
        let mut first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
--- a/src/capture/macos.rs
+++ b/src/capture/macos.rs
@@ -1,7 +1,7 @@
+use crate::capture::error::MacOSInputCaptureCreationError;
 use crate::capture::InputCapture;
 use crate::client::{ClientEvent, ClientHandle};
 use crate::event::Event;
-use anyhow::{anyhow, Result};
 use futures_core::Stream;
 use std::task::{Context, Poll};
 use std::{io, pin::Pin};
@@ -9,8 +9,8 @@ use std::{io, pin::Pin};
 pub struct MacOSInputCapture;

 impl MacOSInputCapture {
-    pub fn new() -> Result<Self> {
-        Err(anyhow!("not yet implemented"))
+    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+        Err(MacOSInputCaptureCreationError::NotImplemented)
    }
 }

--- a/src/capture/wayland.rs
+++ b/src/capture/wayland.rs
@@ -1,9 +1,8 @@
 use crate::{
-    capture::InputCapture,
+    capture::{error::WaylandBindError, InputCapture},
    client::{ClientEvent, ClientHandle, Position},
 };

-use anyhow::{anyhow, Result};
 use futures_core::Stream;
 use memmap::MmapOptions;
 use std::{
@@ -68,6 +67,8 @@ use tempfile;

 use crate::event::{Event, KeyboardEvent, PointerEvent};

+use super::error::LayerShellCaptureCreationError;
+
 struct Globals {
    compositor: wl_compositor::WlCompositor,
    pointer_constraints: ZwpPointerConstraintsV1,
@@ -111,6 +112,7 @@ struct State {
    qh: QueueHandle<Self>,
    pending_events: VecDeque<(ClientHandle, Event)>,
    output_info: Vec<(WlOutput, OutputInfo)>,
+    scroll_discrete_pending: bool,
 }

 struct Inner {
@@ -257,64 +259,37 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
 }

 impl WaylandInputCapture {
-    pub fn new() -> Result<Self> {
-        let conn = match Connection::connect_to_env() {
-            Ok(c) => c,
-            Err(e) => return Err(anyhow!("could not connect to wayland compositor: {e:?}")),
-        };
-
-        let (g, mut queue) = match registry_queue_init::<State>(&conn) {
-            Ok(q) => q,
-            Err(e) => return Err(anyhow!("failed to initialize wl_registry: {e:?}")),
-        };
+    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
+        let conn = Connection::connect_to_env()?;
+        let (g, mut queue) = registry_queue_init::<State>(&conn)?;

        let qh = queue.handle();

-        let compositor: wl_compositor::WlCompositor = match g.bind(&qh, 4..=5, ()) {
-            Ok(compositor) => compositor,
-            Err(_) => return Err(anyhow!("wl_compositor >= v4 not supported")),
-        };
-
-        let xdg_output_manager: ZxdgOutputManagerV1 = match g.bind(&qh, 1..=3, ()) {
-            Ok(xdg_output_manager) => xdg_output_manager,
-            Err(_) => return Err(anyhow!("xdg_output not supported!")),
-        };
-
-        let shm: wl_shm::WlShm = match g.bind(&qh, 1..=1, ()) {
-            Ok(wl_shm) => wl_shm,
-            Err(_) => return Err(anyhow!("wl_shm v1 not supported")),
-        };
-
-        let layer_shell: ZwlrLayerShellV1 = match g.bind(&qh, 3..=4, ()) {
-            Ok(layer_shell) => layer_shell,
-            Err(_) => return Err(anyhow!("zwlr_layer_shell_v1 >= v3 not supported - required to display a surface at the edge of the screen")),
-        };
-
-        let seat: wl_seat::WlSeat = match g.bind(&qh, 7..=8, ()) {
-            Ok(wl_seat) => wl_seat,
-            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
-        };
-
-        let pointer_constraints: ZwpPointerConstraintsV1 = match g.bind(&qh, 1..=1, ()) {
-            Ok(pointer_constraints) => pointer_constraints,
-            Err(_) => return Err(anyhow!("zwp_pointer_constraints_v1 not supported")),
-        };
-
-        let relative_pointer_manager: ZwpRelativePointerManagerV1 = match g.bind(&qh, 1..=1, ()) {
-            Ok(relative_pointer_manager) => relative_pointer_manager,
-            Err(_) => return Err(anyhow!("zwp_relative_pointer_manager_v1 not supported")),
-        };
-
-        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 =
-            match g.bind(&qh, 1..=1, ()) {
-                Ok(shortcut_inhibit_manager) => shortcut_inhibit_manager,
-                Err(_) => {
-                    return Err(anyhow!(
-                        "zwp_keyboard_shortcuts_inhibit_manager_v1 not supported"
-                    ))
-                }
-            };
+        let compositor: wl_compositor::WlCompositor = g
+            .bind(&qh, 4..=5, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
+        let xdg_output_manager: ZxdgOutputManagerV1 = g
+            .bind(&qh, 1..=3, ())
+            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
+        let shm: wl_shm::WlShm = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
+        let layer_shell: ZwlrLayerShellV1 = g
+            .bind(&qh, 3..=4, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
+        let seat: wl_seat::WlSeat = g
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;

+        let pointer_constraints: ZwpPointerConstraintsV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
        let outputs = vec![];

        let g = Globals {
@@ -351,6 +326,7 @@ impl WaylandInputCapture {
            read_guard: None,
            pending_events: VecDeque::new(),
            output_info: vec![],
+            scroll_discrete_pending: false,
        };

        // dispatch registry to () again, in order to read all wl_outputs
@@ -752,17 +728,25 @@ impl Dispatch<WlPointer, ()> for State {
            }
            wl_pointer::Event::Axis { time, axis, value } => {
                let (_, client) = app.focused.as_ref().unwrap();
-                app.pending_events.push_back((
-                    *client,
-                    Event::Pointer(PointerEvent::Axis {
-                        time,
-                        axis: u32::from(axis) as u8,
-                        value,
-                    }),
-                ));
+                if app.scroll_discrete_pending {
+                    // each axisvalue120 event is coupled with
+                    // a corresponding axis event, which needs to
+                    // be ignored to not duplicate the scrolling
+                    app.scroll_discrete_pending = false;
+                } else {
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Pointer(PointerEvent::Axis {
+                            time,
+                            axis: u32::from(axis) as u8,
+                            value,
+                        }),
+                    ));
+                }
            }
            wl_pointer::Event::AxisValue120 { axis, value120 } => {
                let (_, client) = app.focused.as_ref().unwrap();
+                app.scroll_discrete_pending = true;
                app.pending_events.push_back((
                    *client,
                    Event::Pointer(PointerEvent::AxisDiscrete120 {
--- a/src/capture/windows.rs
+++ b/src/capture/windows.rs
@@ -96,8 +96,7 @@ unsafe fn get_event_tid() -> Option<u32> {
 static mut ENTRY_POINT: (i32, i32) = (0, 0);

 fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
-    let mouse_low_level: MSLLHOOKSTRUCT =
-        unsafe { *std::mem::transmute::<LPARAM, *const MSLLHOOKSTRUCT>(lparam) };
+    let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
    match wparam {
        WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
            time: 0,
@@ -141,7 +140,7 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
        },
        WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
            axis: 0,
-            value: -(mouse_low_level.mouseData as i32),
+            value: -(mouse_low_level.mouseData as i32 >> 16),
        }),
        WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
            let hb = mouse_low_level.mouseData >> 16;
@@ -167,8 +166,7 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
 }

 unsafe fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
-    let kybrdllhookstruct: KBDLLHOOKSTRUCT =
-        *std::mem::transmute::<LPARAM, *const KBDLLHOOKSTRUCT>(lparam);
+    let kybrdllhookstruct: KBDLLHOOKSTRUCT = *(lparam.0 as *const KBDLLHOOKSTRUCT);
    let mut scan_code = kybrdllhookstruct.scanCode;
    log::trace!("scan_code: {scan_code}");
    if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
@@ -247,8 +245,7 @@ unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
    if wparam.0 != WM_MOUSEMOVE as usize {
        return ACTIVE_CLIENT.is_some();
    }
-    let mouse_low_level: MSLLHOOKSTRUCT =
-        unsafe { *std::mem::transmute::<LPARAM, *const MSLLHOOKSTRUCT>(lparam) };
+    let mouse_low_level: MSLLHOOKSTRUCT = *(lparam.0 as *const MSLLHOOKSTRUCT);
    static mut PREV_POS: Option<(i32, i32)> = None;
    let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
    let prev_pos = PREV_POS.unwrap_or(curr_pos);
@@ -578,7 +575,7 @@ fn update_clients(client_event: ClientEvent) {
 }

 impl WindowsInputCapture {
-    pub(crate) fn new() -> Result<Self> {
+    pub(crate) fn new() -> Self {
        unsafe {
            let (tx, rx) = channel(10);
            EVENT_TX.replace(tx);
@@ -586,10 +583,10 @@ impl WindowsInputCapture {
            let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
            /* wait for thread to set its id */
            ready_rx.recv().expect("channel closed");
-            Ok(Self {
+            Self {
                msg_thread,
                event_rx: rx,
-            })
+            }
        }
    }
 }
--- a/src/capture/x11.rs
+++ b/src/capture/x11.rs
@@ -1,4 +1,3 @@
-use anyhow::{anyhow, Result};
 use std::io;
 use std::task::Poll;

@@ -9,11 +8,13 @@ use crate::event::Event;

 use crate::client::{ClientEvent, ClientHandle};

+use super::error::X11InputCaptureCreationError;
+
 pub struct X11InputCapture {}

 impl X11InputCapture {
-    pub fn new() -> Result<Self> {
-        Err(anyhow!("not implemented"))
+    pub fn new() -> std::result::Result<Self, X11InputCaptureCreationError> {
+        Err(X11InputCaptureCreationError::NotImplemented)
    }
 }

--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -1,5 +1,6 @@
 use crate::capture;
 use crate::client::{ClientEvent, Position};
+use crate::config::Config;
 use crate::event::{Event, KeyboardEvent};
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
@@ -12,12 +13,14 @@ pub fn run() -> Result<()> {
        .enable_time()
        .build()?;

-    runtime.block_on(LocalSet::new().run_until(input_capture_test()))
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
 }

-async fn input_capture_test() -> Result<()> {
+async fn input_capture_test(config: Config) -> Result<()> {
    log::info!("creating input capture");
-    let mut input_capture = capture::create().await;
+    let mut input_capture = capture::create(config.capture_backend).await?;
    log::info!("creating clients");
    input_capture.notify(ClientEvent::Create(0, Position::Left))?;
    input_capture.notify(ClientEvent::Create(1, Position::Right))?;
--- a/src/client.rs
+++ b/src/client.rs
@@ -102,6 +102,8 @@ pub struct ClientConfig {
    pub port: u16,
    /// position of a client on screen
    pub pos: Position,
+    /// enter hook
+    pub cmd: Option<String>,
 }

 impl Default for ClientConfig {
@@ -111,6 +113,7 @@ impl Default for ClientConfig {
            hostname: Default::default(),
            fix_ips: Default::default(),
            pos: Default::default(),
+            cmd: None,
        }
    }
 }
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,8 +1,9 @@
 use anyhow::Result;
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::env;
+use std::fmt::Display;
 use std::net::IpAddr;
 use std::{error::Error, fs};
 use toml;
@@ -15,8 +16,10 @@ pub const DEFAULT_PORT: u16 = 4242;

 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
    pub port: Option<u16>,
-    pub frontend: Option<String>,
+    pub frontend: Option<Frontend>,
    pub release_bind: Option<Vec<scancode::Linux>>,
    pub left: Option<TomlClient>,
    pub right: Option<TomlClient>,
@@ -26,11 +29,13 @@ pub struct ConfigToml {

 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct TomlClient {
+    pub capture_backend: Option<CaptureBackend>,
    pub hostname: Option<String>,
    pub host_name: Option<String>,
    pub ips: Option<Vec<IpAddr>>,
    pub port: Option<u16>,
    pub activate_on_startup: Option<bool>,
+    pub enter_hook: Option<String>,
 }

 impl ConfigToml {
@@ -50,7 +55,7 @@ struct CliArgs {

    /// the frontend to use [cli | gtk]
    #[arg(short, long)]
-    frontend: Option<String>,
+    frontend: Option<Frontend>,

    /// non-default config file location
    #[arg(short, long)]
@@ -67,16 +72,106 @@ struct CliArgs {
    /// test input emulation
    #[arg(long)]
    test_emulation: bool,
+
+    /// capture backend override
+    #[arg(long)]
+    capture_backend: Option<CaptureBackend>,
+
+    /// emulation backend override
+    #[arg(long)]
+    emulation_backend: Option<EmulationBackend>,
 }

-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
+pub enum CaptureBackend {
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    InputCapturePortal,
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for CaptureBackend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureBackend::LayerShell => write!(f, "layer-shell"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureBackend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            CaptureBackend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            CaptureBackend::MacOs => write!(f, "MacOS"),
+            CaptureBackend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
+pub enum EmulationBackend {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei,
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for EmulationBackend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationBackend::Wlroots => write!(f, "wlroots"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationBackend::Libei => write!(f, "libei"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationBackend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            EmulationBackend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            EmulationBackend::MacOs => write!(f, "macos"),
+            EmulationBackend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
 pub enum Frontend {
    Gtk,
    Cli,
 }

+impl Default for Frontend {
+    fn default() -> Self {
+        if cfg!(feature = "gtk") {
+            Self::Gtk
+        } else {
+            Self::Cli
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Config {
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
    pub frontend: Frontend,
    pub port: u16,
    pub clients: Vec<(TomlClient, Position)>,
@@ -92,6 +187,7 @@ pub struct ConfigClient {
    pub port: u16,
    pub pos: Position,
    pub active: bool,
+    pub enter_hook: Option<String>,
 }

 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
@@ -127,33 +223,14 @@ impl Config {
            Ok(c) => Some(c),
        };

-        let frontend = match args.frontend {
-            None => match &config_toml {
-                Some(c) => c.frontend.clone(),
-                None => None,
-            },
-            frontend => frontend,
-        };
+        let frontend_arg = args.frontend;
+        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
+        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();

-        let frontend = match frontend {
-            #[cfg(feature = "gtk")]
-            None => Frontend::Gtk,
-            #[cfg(not(feature = "gtk"))]
-            None => Frontend::Cli,
-            Some(s) => match s.as_str() {
-                "cli" => Frontend::Cli,
-                "gtk" => Frontend::Gtk,
-                _ => Frontend::Cli,
-            },
-        };
-
-        let port = match args.port {
-            Some(port) => port,
-            None => match &config_toml {
-                Some(c) => c.port.unwrap_or(DEFAULT_PORT),
-                None => DEFAULT_PORT,
-            },
-        };
+        let port = args
+            .port
+            .or(config_toml.as_ref().and_then(|c| c.port))
+            .unwrap_or(DEFAULT_PORT);

        log::debug!("{config_toml:?}");
        let release_bind = config_toml
@@ -161,6 +238,14 @@ impl Config {
            .and_then(|c| c.release_bind.clone())
            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));

+        let capture_backend = args
+            .capture_backend
+            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
+
+        let emulation_backend = args
+            .emulation_backend
+            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
+
        let mut clients: Vec<(TomlClient, Position)> = vec![];

        if let Some(config_toml) = config_toml {
@@ -183,6 +268,8 @@ impl Config {
        let test_emulation = args.test_emulation;

        Ok(Config {
+            capture_backend,
+            emulation_backend,
            daemon,
            frontend,
            clients,
@@ -208,12 +295,14 @@ impl Config {
                    None => c.host_name.clone(),
                };
                let active = c.activate_on_startup.unwrap_or(false);
+                let enter_hook = c.enter_hook.clone();
                ConfigClient {
                    ips,
                    hostname,
                    port,
                    pos: *pos,
                    active,
+                    enter_hook,
                }
            })
            .collect()
--- a/src/emulate.rs
+++ b/src/emulate.rs
@@ -3,10 +3,13 @@ use std::future;

 use crate::{
    client::{ClientEvent, ClientHandle},
+    config::EmulationBackend,
    event::Event,
 };
 use anyhow::Result;

+use self::error::EmulationCreationError;
+
 #[cfg(windows)]
 pub mod windows;

@@ -27,6 +30,7 @@ pub mod macos;

 /// fallback input emulation (logs events)
 pub mod dummy;
+pub mod error;

 #[async_trait]
 pub trait InputEmulation: Send {
@@ -41,58 +45,60 @@ pub trait InputEmulation: Send {
    async fn destroy(&mut self);
 }

-pub async fn create() -> Box<dyn InputEmulation> {
-    #[cfg(windows)]
-    match windows::WindowsEmulation::new() {
-        Ok(c) => return Box::new(c),
-        Err(e) => log::warn!("windows input emulation unavailable: {e}"),
+pub async fn create_backend(
+    backend: EmulationBackend,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    match backend {
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        EmulationBackend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        EmulationBackend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        EmulationBackend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        EmulationBackend::Xdp => Ok(Box::new(
+            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
+        )),
+        #[cfg(windows)]
+        EmulationBackend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
+        #[cfg(target_os = "macos")]
+        EmulationBackend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
+        EmulationBackend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
    }
-
-    #[cfg(target_os = "macos")]
-    match macos::MacOSEmulation::new() {
-        Ok(c) => {
-            log::info!("using macos input emulation");
-            return Box::new(c);
-        }
-        Err(e) => log::error!("macos input emulatino not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    match wlroots::WlrootsEmulation::new() {
-        Ok(c) => {
-            log::info!("using wlroots input emulation");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("wayland backend not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    match libei::LibeiEmulation::new().await {
-        Ok(c) => {
-            log::info!("using libei input emulation");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("libei not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-    match xdg_desktop_portal::DesktopPortalEmulation::new().await {
-        Ok(c) => {
-            log::info!("using xdg-remote-desktop-portal input emulation");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("remote desktop portal not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    match x11::X11Emulation::new() {
-        Ok(c) => {
-            log::info!("using x11 input emulation");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("x11 input emulation not available: {e}"),
-    }
-
-    log::error!("falling back to dummy input emulation");
-    Box::new(dummy::DummyEmulation::new())
+}
+
+pub async fn create(
+    backend: Option<EmulationBackend>,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using emulation backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        EmulationBackend::Wlroots,
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        EmulationBackend::Libei,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        EmulationBackend::X11,
+        #[cfg(windows)]
+        EmulationBackend::Windows,
+        #[cfg(target_os = "macos")]
+        EmulationBackend::MacOs,
+        EmulationBackend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using emulation backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) => log::warn!("{e}"),
+        }
+    }
+
+    Err(EmulationCreationError::NoAvailableBackend)
 }
--- a/src/emulate/error.rs
+++ b/src/emulate/error.rs
@@ -0,0 +1,168 @@
+use std::fmt::Display;
+
+use thiserror::Error;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[derive(Debug, Error)]
+pub enum EmulationCreationError {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots(#[from] WlrootsEmulationCreationError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei(#[from] LibeiEmulationCreationError),
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp(#[from] XdpEmulationCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11(#[from] X11EmulationCreationError),
+    #[cfg(target_os = "macos")]
+    MacOs(#[from] MacOSEmulationCreationError),
+    #[cfg(windows)]
+    Windows(#[from] WindowsEmulationCreationError),
+    NoAvailableBackend,
+}
+
+impl Display for EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationCreationError::Wlroots(e) => format!("wlroots backend: {e}"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationCreationError::Libei(e) => format!("libei backend: {e}"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationCreationError::Xdp(e) => format!("desktop portal backend: {e}"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationCreationError::X11(e) => format!("x11 backend: {e}"),
+            #[cfg(target_os = "macos")]
+            EmulationCreationError::MacOs(e) => format!("macos backend: {e}"),
+            #[cfg(windows)]
+            EmulationCreationError::Windows(e) => format!("windows backend: {e}"),
+            EmulationCreationError::NoAvailableBackend => "no backend available".to_string(),
+        };
+        write!(f, "could not create input emulation backend: {reason}")
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum WlrootsEmulationCreationError {
+    Connect(#[from] ConnectError),
+    Global(#[from] GlobalError),
+    Wayland(#[from] WaylandError),
+    Bind(#[from] WaylandBindError),
+    Dispatch(#[from] DispatchError),
+    Io(#[from] std::io::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WlrootsEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WlrootsEmulationCreationError::Bind(e) => write!(f, "{e}"),
+            WlrootsEmulationCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            WlrootsEmulationCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            WlrootsEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiEmulationCreationError {
+    Ashpd(#[from] ashpd::Error),
+    Io(#[from] std::io::Error),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiEmulationCreationError::Ashpd(e) => write!(f, "xdg-desktop-portal: {e}"),
+            LibeiEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum XdpEmulationCreationError {
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+impl Display for XdpEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            XdpEmulationCreationError::Ashpd(e) => write!(f, "portal error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11EmulationCreationError {
+    OpenDisplay,
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            X11EmulationCreationError::OpenDisplay => write!(f, "could not open display!"),
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSEmulationCreationError {
+    EventSourceCreation,
+}
+
+#[cfg(target_os = "macos")]
+impl Display for MacOSEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MacOSEmulationCreationError::EventSourceCreation => {
+                write!(f, "could not create event source")
+            }
+        }
+    }
+}
+
+#[cfg(windows)]
+#[derive(Debug, Error)]
+pub enum WindowsEmulationCreationError {}
--- a/src/emulate/libei.rs
+++ b/src/emulate/libei.rs
@@ -1,10 +1,11 @@
+use anyhow::{anyhow, Result};
 use std::{
    collections::HashMap,
+    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    time::{SystemTime, UNIX_EPOCH},
 };

-use anyhow::{anyhow, Result};
 use ashpd::{
    desktop::{
        remote_desktop::{DeviceType, RemoteDesktop},
@@ -27,6 +28,8 @@ use crate::{
    event::Event,
 };

+use super::error::LibeiEmulationCreationError;
+
 pub struct LibeiEmulation {
    handshake: bool,
    context: ei::Context,
@@ -77,14 +80,14 @@ async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
 }

 impl LibeiEmulation {
-    pub async fn new() -> Result<Self> {
+    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
        // fd is owned by the message, so we need to dup it
        let eifd = get_ei_fd().await?;
        let stream = UnixStream::from(eifd);
        // let stream = UnixStream::connect("/run/user/1000/eis-0")?;
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
-        context.flush()?;
+        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
        let events = EiEventStream::new(context.clone())?;
        Ok(Self {
            handshake: false,
--- a/src/emulate/macos.rs
+++ b/src/emulate/macos.rs
@@ -1,7 +1,6 @@
 use crate::client::{ClientEvent, ClientHandle};
 use crate::emulate::InputEmulation;
 use crate::event::{Event, KeyboardEvent, PointerEvent};
-use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
@@ -13,6 +12,8 @@ use std::ops::{Index, IndexMut};
 use std::time::Duration;
 use tokio::task::AbortHandle;

+use super::error::MacOSEmulationCreationError;
+
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

@@ -53,11 +54,9 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}

 impl MacOSEmulation {
-    pub fn new() -> Result<Self> {
-        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
-            Ok(e) => e,
-            Err(_) => return Err(anyhow!("event source creation failed!")),
-        };
+    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
+        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
        let button_state = ButtonState {
            left: false,
            right: false,
--- a/src/emulate/windows.rs
+++ b/src/emulate/windows.rs
@@ -1,9 +1,9 @@
+use super::error::WindowsEmulationCreationError;
 use crate::{
    emulate::InputEmulation,
    event::{KeyboardEvent, PointerEvent},
    scancode,
 };
-use anyhow::Result;
 use async_trait::async_trait;
 use std::ops::BitOrAssign;
 use std::time::Duration;
@@ -33,7 +33,7 @@ pub struct WindowsEmulation {
 }

 impl WindowsEmulation {
-    pub fn new() -> Result<Self> {
+    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
        Ok(Self { repeat_task: None })
    }
 }
--- a/src/emulate/wlroots.rs
+++ b/src/emulate/wlroots.rs
@@ -1,5 +1,5 @@
 use crate::client::{ClientEvent, ClientHandle};
-use crate::emulate::InputEmulation;
+use crate::emulate::{error::WlrootsEmulationCreationError, InputEmulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -7,7 +7,6 @@ use std::os::fd::{AsFd, OwnedFd};
 use wayland_client::backend::WaylandError;
 use wayland_client::WEnum;

-use anyhow::{anyhow, Result};
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
 use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
@@ -30,6 +29,8 @@ use wayland_client::{

 use crate::event::{Event, KeyboardEvent, PointerEvent};

+use super::error::WaylandBindError;
+
 struct State {
    keymap: Option<(u32, OwnedFd, u32)>,
    input_for_client: HashMap<ClientHandle, VirtualInput>,
@@ -47,18 +48,21 @@ pub(crate) struct WlrootsEmulation {
 }

 impl WlrootsEmulation {
-    pub fn new() -> Result<Self> {
+    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
        let conn = Connection::connect_to_env()?;
        let (globals, queue) = registry_queue_init::<State>(&conn)?;
        let qh = queue.handle();

-        let seat: wl_seat::WlSeat = match globals.bind(&qh, 7..=8, ()) {
-            Ok(wl_seat) => wl_seat,
-            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
-        };
+        let seat: wl_seat::WlSeat = globals
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;

-        let vpm: VpManager = globals.bind(&qh, 1..=1, ())?;
-        let vkm: VkManager = globals.bind(&qh, 1..=1, ())?;
+        let vpm: VpManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr-virtual-pointer-unstable-v1"))?;
+        let vkm: VkManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "virtual-keyboard-unstable-v1"))?;

        let input_for_client: HashMap<ClientHandle, VirtualInput> = HashMap::new();

@@ -75,7 +79,7 @@ impl WlrootsEmulation {
            queue,
        };
        while emulate.state.keymap.is_none() {
-            emulate.queue.blocking_dispatch(&mut emulate.state).unwrap();
+            emulate.queue.blocking_dispatch(&mut emulate.state)?;
        }
        // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
        // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
@@ -182,7 +186,8 @@ impl VirtualInput {
                    }
                    PointerEvent::AxisDiscrete120 { axis, value } => {
                        let axis: Axis = (axis as u32).try_into()?;
-                        self.pointer.axis(0, axis, (value / 15) as f64);
+                        self.pointer
+                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
                        self.pointer.frame();
                    }
                    PointerEvent::Frame {} => self.pointer.frame(),
--- a/src/emulate/x11.rs
+++ b/src/emulate/x11.rs
@@ -1,4 +1,3 @@
-use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use std::ptr;
 use x11::{
@@ -14,6 +13,8 @@ use crate::{
    },
 };

+use super::error::X11EmulationCreationError;
+
 pub struct X11Emulation {
    display: *mut xlib::Display,
 }
@@ -21,11 +22,11 @@ pub struct X11Emulation {
 unsafe impl Send for X11Emulation {}

 impl X11Emulation {
-    pub fn new() -> Result<Self> {
+    pub fn new() -> Result<Self, X11EmulationCreationError> {
        let display = unsafe {
            match xlib::XOpenDisplay(ptr::null()) {
                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
-                    Err(anyhow!("could not open display"))
+                    Err(X11EmulationCreationError::OpenDisplay)
                }
                display => Ok(display),
            }
--- a/src/emulate/xdg_desktop_portal.rs
+++ b/src/emulate/xdg_desktop_portal.rs
@@ -17,13 +17,15 @@ use crate::{
    },
 };

+use super::error::XdpEmulationCreationError;
+
 pub struct DesktopPortalEmulation<'a> {
    proxy: RemoteDesktop<'a>,
    session: Session<'a>,
 }

 impl<'a> DesktopPortalEmulation<'a> {
-    pub async fn new() -> Result<DesktopPortalEmulation<'a>> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
        let proxy = RemoteDesktop::new().await?;

--- a/src/emulation_test.rs
+++ b/src/emulation_test.rs
@@ -1,4 +1,5 @@
 use crate::client::{ClientEvent, Position};
+use crate::config::Config;
 use crate::emulate;
 use crate::event::{Event, PointerEvent};
 use anyhow::Result;
@@ -13,14 +14,16 @@ pub fn run() -> Result<()> {
        .enable_time()
        .build()?;

-    runtime.block_on(LocalSet::new().run_until(input_emulation_test()))
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
 }

 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

-async fn input_emulation_test() -> Result<()> {
-    let mut emulation = emulate::create().await;
+async fn input_emulation_test(config: Config) -> Result<()> {
+    let mut emulation = emulate::create(config.emulation_backend).await?;
    emulation
        .notify(ClientEvent::Create(0, Position::Left))
        .await;
--- a/src/frontend.rs
+++ b/src/frontend.rs
@@ -107,16 +107,18 @@ pub enum FrontendRequest {
    UpdatePosition(ClientHandle, Position),
    /// update fix-ips
    UpdateFixIps(ClientHandle, Vec<IpAddr>),
+    /// request the state of the given client
+    GetState(ClientHandle),
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum FrontendEvent {
    /// a client was created
    Created(ClientHandle, ClientConfig, ClientState),
-    /// a client was updated
-    Updated(ClientHandle, ClientConfig),
+    /// no such client
+    NoSuchClient(ClientHandle),
    /// state changed
-    StateChange(ClientHandle, ClientState),
+    State(ClientHandle, ClientConfig, ClientState),
    /// the client was deleted
    Deleted(ClientHandle),
    /// new port, reason of failure (if failed)
@@ -235,9 +237,7 @@ impl FrontendListener {
        let json = serde_json::to_string(&notify).unwrap();
        let payload = json.as_bytes();
        let len = payload.len().to_be_bytes();
-        log::debug!("json: {json}, len: {}", payload.len());
-
-        log::debug!("broadcasting event to streams: {:?}", self.tx_streams);
+        log::debug!("broadcasting event to streams: {json}");
        let mut keep = vec![];
        // TODO do simultaneously
        for tx in self.tx_streams.iter_mut() {
--- a/src/frontend/cli.rs
+++ b/src/frontend/cli.rs
@@ -100,6 +100,18 @@ impl<'a> Cli<'a> {
        }
    }

+    async fn update_client(&mut self, handle: ClientHandle) -> Result<()> {
+        self.send_request(FrontendRequest::GetState(handle)).await?;
+        loop {
+            let event = self.await_event().await?;
+            self.handle_event(event.clone());
+            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
+                break;
+            }
+        }
+        Ok(())
+    }
+
    async fn execute(&mut self, cmd: Command) -> Result<()> {
        match cmd {
            Command::None => {}
@@ -125,14 +137,8 @@ impl<'a> Cli<'a> {
                    FrontendRequest::UpdatePosition(handle, pos),
                ] {
                    self.send_request(request).await?;
-                    loop {
-                        let event = self.await_event().await?;
-                        self.handle_event(event.clone());
-                        if let FrontendEvent::Updated(_, _) = event {
-                            break;
-                        }
-                    }
                }
+                self.update_client(handle).await?;
            }
            Command::Disconnect(id) => {
                self.send_request(FrontendRequest::Delete(id)).await?;
@@ -148,26 +154,12 @@ impl<'a> Cli<'a> {
            Command::Activate(id) => {
                self.send_request(FrontendRequest::Activate(id, true))
                    .await?;
-                loop {
-                    let event = self.await_event().await?;
-                    self.handle_event(event.clone());
-                    if let FrontendEvent::StateChange(_, _) = event {
-                        self.handle_event(event);
-                        break;
-                    }
-                }
+                self.update_client(id).await?;
            }
            Command::Deactivate(id) => {
                self.send_request(FrontendRequest::Activate(id, false))
                    .await?;
-                loop {
-                    let event = self.await_event().await?;
-                    self.handle_event(event.clone());
-                    if let FrontendEvent::StateChange(_, _) = event {
-                        self.handle_event(event);
-                        break;
-                    }
-                }
+                self.update_client(id).await?;
            }
            Command::List => {
                self.send_request(FrontendRequest::Enumerate()).await?;
@@ -182,25 +174,12 @@ impl<'a> Cli<'a> {
            Command::SetHost(handle, host) => {
                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
                self.send_request(request).await?;
-                loop {
-                    let event = self.await_event().await?;
-                    self.handle_event(event.clone());
-                    if let FrontendEvent::Updated(_, _) = event {
-                        self.handle_event(event);
-                        break;
-                    }
-                }
+                self.update_client(handle).await?;
            }
            Command::SetPort(handle, port) => {
                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
                self.send_request(request).await?;
-                loop {
-                    let event = self.await_event().await?;
-                    self.handle_event(event.clone());
-                    if let FrontendEvent::Updated(_, _) = event {
-                        break;
-                    }
-                }
+                self.update_client(handle).await?;
            }
            Command::Help => {
                for cmd_type in [
@@ -244,8 +223,11 @@ impl<'a> Cli<'a> {
                eprintln!();
                self.clients.push((h, c, s));
            }
-            FrontendEvent::Updated(h, c) => {
-                if let Some((_, config, _)) = self.find_mut(h) {
+            FrontendEvent::NoSuchClient(h) => {
+                eprintln!("no such client: {h}");
+            }
+            FrontendEvent::State(h, c, s) => {
+                if let Some((_, config, state)) = self.find_mut(h) {
                    let old_host = config.hostname.clone().unwrap_or("\"\"".into());
                    let new_host = c.hostname.clone().unwrap_or("\"\"".into());
                    if old_host != new_host {
@@ -261,10 +243,6 @@ impl<'a> Cli<'a> {
                        eprintln!("client {h} ips updated: {:?}", c.fix_ips)
                    }
                    *config = c;
-                }
-            }
-            FrontendEvent::StateChange(h, s) => {
-                if let Some((_, _, state)) = self.find_mut(h) {
                    if state.active ^ s.active {
                        eprintln!(
                            "client {h} {}",
--- a/src/frontend/gtk.rs
+++ b/src/frontend/gtk.rs
@@ -11,6 +11,7 @@ use std::{
 use crate::frontend::{gtk::window::Window, FrontendRequest};

 use adw::Application;
+use endi::{Endian, ReadBytes};
 use gtk::{
    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
 };
@@ -85,16 +86,14 @@ fn build_ui(app: &Application) {
    gio::spawn_blocking(move || {
        match loop {
            // read length
-            let mut len = [0u8; 8];
-            match rx.read_exact(&mut len) {
-                Ok(_) => (),
+            let len = match rx.read_u64(Endian::Big) {
+                Ok(l) => l,
                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
                Err(e) => break Err(e),
            };
-            let len = usize::from_be_bytes(len);

            // read payload
-            let mut buf = vec![0u8; len];
+            let mut buf = vec![0u8; len as usize];
            match rx.read_exact(&mut buf) {
                Ok(_) => (),
                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
@@ -126,12 +125,11 @@ fn build_ui(app: &Application) {
                FrontendEvent::Deleted(client) => {
                    window.delete_client(client);
                }
-                FrontendEvent::Updated(handle, client) => {
-                    window.update_client_config(handle, client);
-                }
-                FrontendEvent::StateChange(handle, state) => {
+                FrontendEvent::State(handle, config, state) => {
+                    window.update_client_config(handle, config);
                    window.update_client_state(handle, state);
                }
+                FrontendEvent::NoSuchClient(_) => { }
                FrontendEvent::Error(e) => {
                    window.show_toast(e.as_str());
                },
--- a/src/frontend/gtk/window.rs
+++ b/src/frontend/gtk/window.rs
@@ -10,6 +10,7 @@ use std::net::TcpStream;

 use adw::prelude::*;
 use adw::subclass::prelude::*;
+use endi::{Endian, WriteBytes};
 use glib::{clone, Object};
 use gtk::{
    gio,
@@ -51,6 +52,10 @@ impl Window {
            .expect("Could not get clients")
    }

+    fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
+        self.clients().item(idx).map(|o| o.downcast().unwrap())
+    }
+
    fn setup_clients(&self) {
        let model = gio::ListStore::new::<ClientObject>();
        self.imp().clients.replace(Some(model));
@@ -62,27 +67,24 @@ impl Window {
                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
                let row = window.create_client_row(client_object);
                row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
-                    let index = row.index() as u32;
-                    let Some(client) = window.clients().item(index) else {
-                        return;
-                    };
-                    let client = client.downcast_ref::<ClientObject>().unwrap();
-                    window.request_client_update(client);
-                    window.request_client_activate(client, active)
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_activate(&client, active);
+                        window.request_client_update(&client);
+                        window.request_client_state(&client);
+                    }
                }));
                row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
-                    let index = row.index() as u32;
-                    window.request_client_delete(index);
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_delete(&client);
+                    }
                }));
                row.connect_closure("request-dns", false, closure_local!(@strong window => move
                |row: ClientRow| {
-                    let index = row.index() as u32;
-                    let Some(client) = window.clients().item(index) else {
-                        return;
-                    };
-                    let client = client.downcast_ref::<ClientObject>().unwrap();
-                    window.request_client_update(client);
-                    window.request_dns(index);
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_update(&client);
+                        window.request_dns(&client);
+                        window.request_client_state(&client);
+                    }
                }));
                row.upcast()
            })
@@ -177,7 +179,7 @@ impl Window {

        if state.resolving != data.resolving {
            client_object.set_resolving(state.resolving);
-            log::debug!("resolving {}: {}", data.handle, state.active);
+            log::debug!("resolving {}: {}", data.handle, state.resolving);
        }

        self.update_dns_state(handle, !state.ips.is_empty());
@@ -204,20 +206,6 @@ impl Window {
        }
    }

-    pub fn request_dns(&self, idx: u32) {
-        let client_object = self.clients().item(idx).unwrap();
-        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
-        let data = client_object.get_data();
-        let event = FrontendRequest::ResolveDns(data.handle);
-        self.request(event);
-    }
-
-    pub fn request_client_create(&self) {
-        let event = FrontendRequest::Create;
-        self.imp().set_port(DEFAULT_PORT);
-        self.request(event);
-    }
-
    pub fn request_port_change(&self) {
        let port = self.imp().port_entry.get().text().to_string();
        if let Ok(port) = port.as_str().parse::<u16>() {
@@ -227,6 +215,23 @@ impl Window {
        }
    }

+    pub fn request_client_state(&self, client: &ClientObject) {
+        let handle = client.handle();
+        let event = FrontendRequest::GetState(handle);
+        self.request(event);
+    }
+
+    pub fn request_client_create(&self) {
+        let event = FrontendRequest::Create;
+        self.request(event);
+    }
+
+    pub fn request_dns(&self, client: &ClientObject) {
+        let data = client.get_data();
+        let event = FrontendRequest::ResolveDns(data.handle);
+        self.request(event);
+    }
+
    pub fn request_client_update(&self, client: &ClientObject) {
        let handle = client.handle();
        let data = client.get_data();
@@ -239,38 +244,29 @@ impl Window {
            FrontendRequest::UpdatePosition(handle, position),
            FrontendRequest::UpdatePort(handle, port),
        ] {
-            log::debug!("requesting: {event:?}");
            self.request(event);
        }
    }

    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
        let handle = client.handle();
-
        let event = FrontendRequest::Activate(handle, active);
-        log::debug!("requesting: {event:?}");
        self.request(event);
    }

-    pub fn request_client_delete(&self, idx: u32) {
-        if let Some(obj) = self.clients().item(idx) {
-            let client_object: &ClientObject = obj
-                .downcast_ref()
-                .expect("Expected object of type `ClientObject`.");
-            let handle = client_object.handle();
-            let event = FrontendRequest::Delete(handle);
-            self.request(event);
-        }
+    pub fn request_client_delete(&self, client: &ClientObject) {
+        let handle = client.handle();
+        let event = FrontendRequest::Delete(handle);
+        self.request(event);
    }

    pub fn request(&self, event: FrontendRequest) {
        let json = serde_json::to_string(&event).unwrap();
-        log::debug!("requesting {json}");
+        log::debug!("requesting: {json}");
        let mut stream = self.imp().stream.borrow_mut();
        let stream = stream.as_mut().unwrap();
        let bytes = json.as_bytes();
-        let len = bytes.len().to_be_bytes();
-        if let Err(e) = stream.write(&len) {
+        if let Err(e) = stream.write_u64(Endian::Big, bytes.len() as u64) {
            log::error!("error sending message: {e}");
        };
        if let Err(e) = stream.write(bytes) {
--- a/src/main.rs
+++ b/src/main.rs
@@ -68,10 +68,12 @@ fn run_service(config: &Config) -> Result<()> {
    // run async event loop
    runtime.block_on(LocalSet::new().run_until(async {
        // run main loop
-        log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
+        log::info!("Press {:?} to release the mouse", config.release_bind);

        let server = Server::new(config);
-        server.run().await?;
+        server
+            .run(config.capture_backend, config.emulation_backend)
+            .await?;

        log::debug!("service exiting");
        anyhow::Ok(())
--- a/src/scancode.rs
+++ b/src/scancode.rs
@@ -3,6 +3,8 @@ use serde::{Deserialize, Serialize};

 /*
 * https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input
+ * https://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
+ * https://kbd-project.org/docs/scancodes/scancodes-1.html
 */
 #[repr(u32)]
 #[derive(Debug, Clone, Copy, TryFromPrimitive)]
@@ -120,15 +122,15 @@ pub enum Windows {
    KeyF21 = 0x006C,
    KeyF22 = 0x006D,
    KeyF23 = 0x006E,
-    KeyF24 = 0x0076,
+    KeyF24 = 0x0076, // KeyLANG5
    KeypadComma = 0x007E,
    KeyInternational1 = 0x0073,
    KeyInternational2 = 0x0070,
-    KeyInternational3 = 0x007D,
+    KeyInternational3 = 0x007D, // typo in doc -> its Int'l 3 not Int'l 2
    #[allow(dead_code)]
-    KeyInternational4 = 0x0079, // FIXME unused
+    KeyInternational4 = 0x0079,
    #[allow(dead_code)]
-    KeyInternational5 = 0x007B, // FIXME unused
+    KeyInternational5 = 0x007B,
    // KeyInternational6 = 0x005C,
    KeyLANG1 = 0x0072,
    KeyLANG2 = 0x0071,
@@ -141,6 +143,7 @@ pub enum Windows {
    KeyLeftGUI = 0xE05B,
    KeyRightCtrl = 0xE01D,
    KeyRightShift = 0x0036,
+    KeyFakeRightShift = 0xE036,
    KeyRightAlt = 0xE038,
    KeyRightGUI = 0xE05C,
    KeyScanNextTrack = 0xE019,
@@ -293,7 +296,7 @@ pub enum Linux {
    KeyPause = 119,
    KeyScale = 120, /* AL Compiz Scale (Expose) */
    KeyKpcomma = 121,
-    KeyHangeul = 122,
+    KeyHanguel = 122,
    // KEY_HANGUEL = KeyHangeul,
    KeyHanja = 123,
    KeyYen = 124,
@@ -518,16 +521,16 @@ impl TryFrom<Linux> for Windows {
            Linux::KeyKp3 => Ok(Self::Keypad3PageDn),
            Linux::KeyKp0 => Ok(Self::Keypad0Insert),
            Linux::KeyKpDot => Ok(Self::KeypadDot),
-            Linux::KeyZenkakuhankaku => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar),  // TODO unsure
+            Linux::KeyZenkakuhankaku => Ok(Self::KeyF24), // KeyLANG5
+            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar), // TODO unsure
            Linux::KeyF11 => Ok(Self::KeyF11),
            Linux::KeyF12 => Ok(Self::KeyF12),
-            Linux::KeyRo => Ok(Self::ErrorRollOver), // TODO unsure
-            Linux::KeyKatakana => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::KeyHiragana => Ok(Self::KeyLANG2), // TODO unsure
-            Linux::KeyHenkan => Ok(Self::KeyLANG3),  // TODO unsure
-            Linux::KeyKatakanahiragana => Ok(Self::KeyLANG4), // TODO unsure
-            Linux::KeyMuhenkan => Ok(Self::KeyLANG4), // TODO unsure
+            Linux::KeyRo => Ok(Self::KeyInternational1),
+            Linux::KeyKatakana => Ok(Self::KeyLANG3),
+            Linux::KeyHiragana => Ok(Self::KeyLANG4),
+            Linux::KeyHenkan => Ok(Self::KeyInternational4),
+            Linux::KeyKatakanahiragana => Ok(Self::KeyInternational2),
+            Linux::KeyMuhenkan => Ok(Self::KeyInternational5),
            Linux::KeyKpJpComma => Ok(Self::KeypadComma),
            Linux::KeyKpEnter => Ok(Self::KeypadEnter),
            Linux::KeyRightCtrl => Ok(Self::KeyRightCtrl),
@@ -555,9 +558,9 @@ impl TryFrom<Linux> for Windows {
            Linux::KeyPause => Ok(Self::KeyPause),
            Linux::KeyScale => Err(()), // TODO
            Linux::KeyKpcomma => Ok(Self::KeypadComma),
-            Linux::KeyHangeul => Ok(Self::KeyInternational1), // TODO unsure
-            Linux::KeyHanja => Ok(Self::KeyInternational2),   // TODO unsure
-            Linux::KeyYen => Ok(Self::KeyInternational3),     // TODO unsure
+            Linux::KeyHanguel => Ok(Self::KeyLANG1), // FIXME should be 00F2?
+            Linux::KeyHanja => Ok(Self::KeyLANG2),   // FIXME should be 00F1?
+            Linux::KeyYen => Ok(Self::KeyInternational3),
            Linux::KeyLeftMeta => Ok(Self::KeyLeftGUI),
            Linux::KeyRightmeta => Ok(Self::KeyRightGUI),
            Linux::KeyCompose => Ok(Self::KeyApplication),
@@ -807,21 +810,22 @@ impl TryFrom<Windows> for Linux {
            Windows::KeyF23 => Ok(Self::KeyF23),
            Windows::KeyF24 => Ok(Self::KeyF24),
            Windows::KeypadComma => Ok(Self::KeyKpcomma),
-            Windows::KeyInternational1 => Ok(Self::KeyHangeul),
-            Windows::KeyInternational2 => Ok(Self::KeyHanja),
+            Windows::KeyInternational1 => Ok(Self::KeyRo),
+            Windows::KeyInternational2 => Ok(Self::KeyKatakanahiragana),
            Windows::KeyInternational3 => Ok(Self::KeyYen),
-            Windows::KeyInternational4 => Err(()),
-            Windows::KeyInternational5 => Err(()),
-            Windows::KeyLANG1 => Ok(Self::KeyKatakana),
-            Windows::KeyLANG2 => Ok(Self::KeyHiragana),
-            Windows::KeyLANG3 => Ok(Self::KeyHenkan),
-            Windows::KeyLANG4 => Ok(Self::KeyKatakanahiragana),
+            Windows::KeyInternational4 => Ok(Self::KeyHenkan),
+            Windows::KeyInternational5 => Ok(Self::KeyMuhenkan),
+            Windows::KeyLANG1 => Ok(Self::KeyHanguel),
+            Windows::KeyLANG2 => Ok(Self::KeyHanja),
+            Windows::KeyLANG3 => Ok(Self::KeyKatakana),
+            Windows::KeyLANG4 => Ok(Self::KeyHiragana),
            Windows::KeyLeftCtrl => Ok(Self::KeyLeftCtrl),
            Windows::KeyLeftShift => Ok(Self::KeyLeftShift),
            Windows::KeyLeftAlt => Ok(Self::KeyLeftAlt),
            Windows::KeyLeftGUI => Ok(Self::KeyLeftMeta),
            Windows::KeyRightCtrl => Ok(Self::KeyRightCtrl),
            Windows::KeyRightShift => Ok(Self::KeyRightShift),
+            Windows::KeyFakeRightShift => Ok(Self::KeyRightShift),
            Windows::KeyRightAlt => Ok(Self::KeyRightalt),
            Windows::KeyRightGUI => Ok(Self::KeyRightmeta),
            Windows::KeyScanNextTrack => Ok(Self::KeyNextsong),
--- a/src/server.rs
+++ b/src/server.rs
@@ -8,7 +8,7 @@ use tokio::signal;

 use crate::{
    client::{ClientConfig, ClientHandle, ClientManager, ClientState},
-    config::Config,
+    config::{CaptureBackend, Config, EmulationBackend},
    dns,
    frontend::{FrontendListener, FrontendRequest},
    server::capture_task::CaptureEvent,
@@ -55,6 +55,7 @@ impl Server {
                fix_ips: config_client.ips.into_iter().collect(),
                port: config_client.port,
                pos: config_client.pos,
+                cmd: config_client.enter_hook,
            };
            let state = ClientState {
                active: config_client.active,
@@ -76,7 +77,11 @@ impl Server {
        }
    }

-    pub async fn run(&self) -> anyhow::Result<()> {
+    pub async fn run(
+        &self,
+        capture_backend: Option<CaptureBackend>,
+        emulation_backend: Option<EmulationBackend>,
+    ) -> anyhow::Result<()> {
        // create frontend communication adapter
        let frontend = match FrontendListener::new().await {
            Some(f) => f?,
@@ -96,20 +101,22 @@ impl Server {

        // input capture
        let (mut capture_task, capture_channel) = capture_task::new(
+            capture_backend,
            self.clone(),
            sender_tx.clone(),
            timer_tx.clone(),
            self.release_bind.clone(),
-        );
+        )?;

        // input emulation
        let (mut emulation_task, emulate_channel) = emulation_task::new(
+            emulation_backend,
            self.clone(),
            receiver_rx,
            sender_tx.clone(),
            capture_channel.clone(),
            timer_tx,
-        );
+        )?;

        // create dns resolver
        let resolver = dns::DnsResolver::new().await?;
--- a/src/server/capture_task.rs
+++ b/src/server/capture_task.rs
@@ -2,11 +2,12 @@ use anyhow::{anyhow, Result};
 use futures::StreamExt;
 use std::{collections::HashSet, net::SocketAddr};

-use tokio::{sync::mpsc::Sender, task::JoinHandle};
+use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};

 use crate::{
-    capture::{self, InputCapture},
+    capture::{self, error::CaptureCreationError, InputCapture},
    client::{ClientEvent, ClientHandle},
+    config::CaptureBackend,
    event::{Event, KeyboardEvent},
    scancode,
    server::State,
@@ -25,14 +26,15 @@ pub enum CaptureEvent {
 }

 pub fn new(
+    backend: Option<CaptureBackend>,
    server: Server,
    sender_tx: Sender<(Event, SocketAddr)>,
    timer_tx: Sender<()>,
    release_bind: Vec<scancode::Linux>,
-) -> (JoinHandle<Result<()>>, Sender<CaptureEvent>) {
+) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
    let task = tokio::task::spawn_local(async move {
-        let mut capture = capture::create().await;
+        let mut capture = capture::create(backend).await?;
        let mut pressed_keys = HashSet::new();
        loop {
            tokio::select! {
@@ -62,7 +64,7 @@ pub fn new(
        }
        anyhow::Ok(())
    });
-    (task, tx)
+    Ok((task, tx))
 }

 fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
@@ -140,6 +142,9 @@ async fn handle_capture_event(
    if start_timer {
        let _ = timer_tx.try_send(());
    }
+    if enter {
+        spawn_hook_command(server, handle);
+    }
    if let Some(addr) = addr {
        if enter {
            let _ = sender_tx.send((Event::Enter(), addr)).await;
@@ -148,3 +153,34 @@ async fn handle_capture_event(
    }
    Ok(())
 }
+
+fn spawn_hook_command(server: &Server, handle: ClientHandle) {
+    let Some(cmd) = server
+        .client_manager
+        .borrow()
+        .get(handle)
+        .and_then(|(c, _)| c.cmd.clone())
+    else {
+        return;
+    };
+    tokio::task::spawn_local(async move {
+        log::info!("spawning command!");
+        let mut child = match Command::new("sh").arg("-c").arg(cmd.as_str()).spawn() {
+            Ok(c) => c,
+            Err(e) => {
+                log::warn!("could not execute cmd: {e}");
+                return;
+            }
+        };
+        match child.wait().await {
+            Ok(s) => {
+                if s.success() {
+                    log::info!("{cmd} exited successfully");
+                } else {
+                    log::warn!("{cmd} exited with {s}");
+                }
+            }
+            Err(e) => log::warn!("{cmd}: {e}"),
+        }
+    });
+}
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -8,7 +8,8 @@ use tokio::{

 use crate::{
    client::{ClientEvent, ClientHandle},
-    emulate::{self, InputEmulation},
+    config::EmulationBackend,
+    emulate::{self, error::EmulationCreationError, InputEmulation},
    event::{Event, KeyboardEvent},
    scancode,
    server::State,
@@ -27,15 +28,16 @@ pub enum EmulationEvent {
 }

 pub fn new(
+    backend: Option<EmulationBackend>,
    server: Server,
    mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
    sender_tx: Sender<(Event, SocketAddr)>,
    capture_tx: Sender<CaptureEvent>,
    timer_tx: Sender<()>,
-) -> (JoinHandle<Result<()>>, Sender<EmulationEvent>) {
+) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
    let emulate_task = tokio::task::spawn_local(async move {
-        let mut emulate = emulate::create().await;
+        let mut emulate = emulate::create(backend).await?;
        let mut last_ignored = None;

        loop {
@@ -75,7 +77,7 @@ pub fn new(
        emulate.destroy().await;
        anyhow::Ok(())
    });
-    (emulate_task, tx)
+    Ok((emulate_task, tx))
 }

 async fn handle_udp_rx(
--- a/src/server/frontend_task.rs
+++ b/src/server/frontend_task.rs
@@ -107,20 +107,22 @@ async fn handle_frontend_event(
    log::debug!("frontend: {event:?}");
    match event {
        FrontendRequest::Create => {
-            add_client(server, frontend).await;
+            let handle = add_client(server, frontend).await;
+            resolve_dns(server, resolve_tx, handle).await;
        }
        FrontendRequest::Activate(handle, active) => {
            if active {
-                activate_client(server, frontend, capture, emulate, handle).await;
+                activate_client(server, capture, emulate, handle).await;
            } else {
-                deactivate_client(server, frontend, capture, emulate, handle).await;
+                deactivate_client(server, capture, emulate, handle).await;
            }
        }
        FrontendRequest::ChangePort(port) => {
            let _ = port_tx.send(port).await;
        }
        FrontendRequest::Delete(handle) => {
-            remove_client(server, frontend, capture, emulate, handle).await;
+            remove_client(server, capture, emulate, handle).await;
+            broadcast(frontend, FrontendEvent::Deleted(handle)).await;
        }
        FrontendRequest::Enumerate() => {
            let clients = server
@@ -131,65 +133,74 @@ async fn handle_frontend_event(
                .collect();
            broadcast(frontend, FrontendEvent::Enumerate(clients)).await;
        }
+        FrontendRequest::GetState(handle) => {
+            broadcast_client(server, frontend, handle).await;
+        }
        FrontendRequest::Terminate() => {
            log::info!("terminating gracefully...");
            return true;
        }
        FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-            update_fix_ips(server, resolve_tx, handle, fix_ips).await;
-            broadcast_client_update(server, frontend, handle).await;
+            update_fix_ips(server, handle, fix_ips).await;
+            resolve_dns(server, resolve_tx, handle).await;
        }
        FrontendRequest::UpdateHostname(handle, hostname) => {
            update_hostname(server, resolve_tx, handle, hostname).await;
-            broadcast_client_update(server, frontend, handle).await;
+            resolve_dns(server, resolve_tx, handle).await;
        }
        FrontendRequest::UpdatePort(handle, port) => {
            update_port(server, handle, port).await;
-            broadcast_client_update(server, frontend, handle).await;
        }
        FrontendRequest::UpdatePosition(handle, pos) => {
            update_pos(server, handle, capture, emulate, pos).await;
-            broadcast_client_update(server, frontend, handle).await;
        }
        FrontendRequest::ResolveDns(handle) => {
-            let hostname = server
-                .client_manager
-                .borrow()
-                .get(handle)
-                .and_then(|(c, _)| c.hostname.clone());
-            if let Some(hostname) = hostname {
-                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-            }
+            resolve_dns(server, resolve_tx, handle).await;
        }
    };
    false
 }

+async fn resolve_dns(server: &Server, resolve_tx: &Sender<DnsRequest>, handle: ClientHandle) {
+    let hostname = server
+        .client_manager
+        .borrow()
+        .get(handle)
+        .and_then(|(c, _)| c.hostname.clone());
+    if let Some(hostname) = hostname {
+        let _ = resolve_tx
+            .send(DnsRequest {
+                hostname: hostname.clone(),
+                handle,
+            })
+            .await;
+    }
+}
+
 async fn broadcast(frontend: &mut FrontendListener, event: FrontendEvent) {
    if let Err(e) = frontend.broadcast_event(event).await {
        log::error!("error notifying frontend: {e}");
    }
 }

-pub async fn add_client(server: &Server, frontend: &mut FrontendListener) {
+pub async fn add_client(server: &Server, frontend: &mut FrontendListener) -> ClientHandle {
    let handle = server.client_manager.borrow_mut().add_client();
    log::info!("added client {handle}");

    let (c, s) = server.client_manager.borrow().get(handle).unwrap().clone();
    broadcast(frontend, FrontendEvent::Created(handle, c, s)).await;
+    handle
 }

 pub async fn deactivate_client(
    server: &Server,
-    frontend: &mut FrontendListener,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
 ) {
-    let state = match server.client_manager.borrow_mut().get_mut(handle) {
+    match server.client_manager.borrow_mut().get_mut(handle) {
        Some((_, s)) => {
            s.active = false;
-            s.clone()
        }
        None => return,
    };
@@ -197,13 +208,10 @@ pub async fn deactivate_client(
    let event = ClientEvent::Destroy(handle);
    let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
    let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
-    let event = FrontendEvent::StateChange(handle, state);
-    broadcast(frontend, event).await;
 }

 pub async fn activate_client(
    server: &Server,
-    frontend: &mut FrontendListener,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
@@ -217,14 +225,13 @@ pub async fn activate_client(
    let other = server.client_manager.borrow_mut().find_client(pos);
    if let Some(other) = other {
        if other != handle {
-            deactivate_client(server, frontend, capture, emulate, other).await;
+            deactivate_client(server, capture, emulate, other).await;
        }
    }

    /* activate the client */
-    let state = if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+    if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
        s.active = true;
-        s.clone()
    } else {
        return;
    };
@@ -233,13 +240,10 @@ pub async fn activate_client(
    let event = ClientEvent::Create(handle, pos);
    let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
    let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
-    let event = FrontendEvent::StateChange(handle, state);
-    broadcast(frontend, event).await;
 }

 pub async fn remove_client(
    server: &Server,
-    frontend: &mut FrontendListener,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
@@ -258,30 +262,15 @@ pub async fn remove_client(
        let _ = capture.send(CaptureEvent::ClientEvent(destroy)).await;
        let _ = emulate.send(EmulationEvent::ClientEvent(destroy)).await;
    }
-
-    let event = FrontendEvent::Deleted(handle);
-    broadcast(frontend, event).await;
 }

-async fn update_fix_ips(
-    server: &Server,
-    resolve_tx: &Sender<DnsRequest>,
-    handle: ClientHandle,
-    fix_ips: Vec<IpAddr>,
-) {
-    let hostname = {
-        let mut client_manager = server.client_manager.borrow_mut();
-        let Some((c, _)) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        c.fix_ips = fix_ips;
-        c.hostname.clone()
+async fn update_fix_ips(server: &Server, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+    let mut client_manager = server.client_manager.borrow_mut();
+    let Some((c, _)) = client_manager.get_mut(handle) else {
+        return;
    };

-    if let Some(hostname) = hostname {
-        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-    }
+    c.fix_ips = fix_ips;
 }

 async fn update_hostname(
@@ -356,11 +345,11 @@ async fn update_pos(
    }
 }

-async fn broadcast_client_update(
-    server: &Server,
-    frontend: &mut FrontendListener,
-    handle: ClientHandle,
-) {
-    let (client, _) = server.client_manager.borrow().get(handle).unwrap().clone();
-    broadcast(frontend, FrontendEvent::Updated(handle, client)).await;
+async fn broadcast_client(server: &Server, frontend: &mut FrontendListener, handle: ClientHandle) {
+    let client = server.client_manager.borrow().get(handle).cloned();
+    if let Some((config, state)) = client {
+        broadcast(frontend, FrontendEvent::State(handle, config, state)).await;
+    } else {
+        broadcast(frontend, FrontendEvent::NoSuchClient(handle)).await;
+    }
 }
--- a/src/server/resolver_task.rs
+++ b/src/server/resolver_task.rs
@@ -35,7 +35,7 @@ pub fn new(
                Ok(ips) => ips,
                Err(e) => {
                    log::warn!("could not resolve host '{host}': {e}");
-                    continue;
+                    vec![]
                }
            };

@@ -59,14 +59,10 @@ async fn notify_state_change(
    server: &mut Server,
    handle: ClientHandle,
 ) {
-    let state = server
-        .client_manager
-        .borrow_mut()
-        .get_mut(handle)
-        .map(|(_, s)| s.clone());
-    if let Some(state) = state {
+    let state = server.client_manager.borrow_mut().get_mut(handle).cloned();
+    if let Some((config, state)) = state {
        let _ = frontend
-            .send(FrontendEvent::StateChange(handle, state))
+            .send(FrontendEvent::State(handle, config, state))
            .await;
    }
 }
Author	SHA1	Message	Date
Ferdinand Schober	a038a24317	fix the 2nd	2024-07-01 18:47:25 +02:00
Ferdinand Schober	a4cdc138f0	fix windows	2024-07-01 17:34:28 +02:00
Ferdinand Schober	db2004fd02	fix windows	2024-07-01 17:16:36 +02:00
Ferdinand Schober	3c2f9da5b7	clippy	2024-07-01 17:03:53 +02:00
Ferdinand Schober	1599e6e76a	formatting	2024-07-01 17:02:37 +02:00
Ferdinand Schober	aba9ddbdcb	fix macos	2024-07-01 16:21:17 +02:00
Ferdinand Schober	984efe7dd7	fix typo	2024-07-01 16:04:09 +02:00
Ferdinand Schober	160b2532ff	fix module	2024-07-01 16:02:47 +02:00
Ferdinand Schober	51d98cc2eb	improve backend creation code	2024-07-01 14:01:42 +02:00
Ferdinand Schober	b1d9180cca	correct conditional compilation	2024-07-01 12:13:27 +02:00
Ferdinand Schober	08f24293f8	fix compilation errors	2024-07-01 10:02:55 +02:00
Ferdinand Schober	e2162b905a	update	2024-06-30 19:46:51 +02:00
Ferdinand Schober	2ac193a5b2	refactor error types	2024-06-30 19:35:34 +02:00
Ferdinand Schober	9cbe1ed8d8	fix release bind message	2024-06-30 14:41:16 +02:00
Ferdinand Schober	3528ef4fae	Configurable capture backend (#150 ) capture backend can now be configured via the `capture_backend` cli argument / config entry	2024-06-29 00:10:36 +02:00
Ferdinand Schober	232c048c19	fix transmuting to pointer types UB (#147 ) closes #134	2024-06-25 14:13:05 +02:00
Orhun Parmaksız	1c37579ae5	Update Arch Linux instructions (#145 )	2024-06-19 20:28:30 +02:00
Ferdinand Schober	460bacade5	fix sizeof usize assumed to be 8 (#143 ) closes #141	2024-06-09 00:49:00 +02:00
虢豳	5fd3b719d6	Extract package name and version from Cargo.toml (#136 ) * chore: nix flake update * feat: Extract package name and version from Cargo.toml	2024-05-22 08:06:44 +02:00
Ferdinand Schober	e6d4585bb2	chore: Release lan-mouse version 0.8.0	2024-05-17 18:06:11 +02:00
Ferdinand Schober	1c082d5c0c	fix win -> lin scancode translations for intl keys	2024-05-17 17:39:52 +02:00
Ferdinand Schober	cd98acbd08	fix right shift not working	2024-05-16 22:36:51 +02:00
Ferdinand Schober	11e1919588	fix most international keybindings	2024-05-16 22:29:41 +02:00
Ferdinand Schober	152bceaa86	fix dns resolving	2024-05-13 08:12:55 +02:00
Ferdinand Schober	60180d841c	fix formatting	2024-05-12 15:50:03 +02:00
Ferdinand Schober	5802a0be0b	fix discrete scrolling on wlroots	2024-05-12 15:49:39 +02:00
Ferdinand Schober	1737727d61	fix cast	2024-05-12 15:07:29 +02:00
Ferdinand Schober	ba46037a1f	fix scrolling in windows	2024-05-12 14:55:56 +02:00
Ferdinand Schober	da768b6fb8	ignore Axis events corresponding to v120 events	2024-05-12 13:32:14 +02:00
Ferdinand Schober	799b45104a	enter hook command (#130 ) new configuration option `enter_hook` can now be used to spawn a command when a client is entered	2024-05-12 13:01:07 +02:00
Ferdinand Schober	e9738fc024	explicit state synchronisation (#129 ) prevents unnecessary state updates and makes synchronization less error prone	2024-05-12 00:49:53 +02:00
Ferdinand Schober	9969f997d3	macos-latest on longer runs on intel macs	2024-05-07 11:46:01 +02:00
Ferdinand Schober	b8cc9e2197	hotfix: race condition when activating clients	2024-05-07 11:18:15 +02:00
Ferdinand Schober	ba6abafe75	windows: fix resolution with scaling enabled (#124 )	2024-05-07 00:07:30 +02:00