fix sizeof usize assumed to be 8

closes #141

Cargo.lock

@@ -1312,7 +1312,6 @@ dependencies = [
  "serde_json",
  "slab",
  "tempfile",
- "thiserror",
  "tokio",
  "toml",
  "wayland-client",
@@ -2012,18 +2011,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -36,7 +36,6 @@ 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"

README.md

@@ -69,15 +69,7 @@ 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

config.toml

@@ -1,7 +1,5 @@
 # example configuration
 
-# capture_backend = "LayerShell"
-
 # release bind
 release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 

src/capture.rs

@@ -4,14 +4,9 @@ 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;
 
@@ -30,57 +25,48 @@ pub mod x11;
 /// fallback input capture (does not produce events)
 pub mod dummy;
 
-pub async fn create_backend(
+pub async fn create() -> Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>> {
-    backend: CaptureBackend,
+    #[cfg(target_os = "macos")]
-) -> Result<Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>>, CaptureCreationError> {
+    match macos::MacOSInputCapture::new() {
-    match backend {
+        Ok(p) => return Box::new(p),
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Err(e) => log::info!("macos input capture not available: {e}"),
-        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())),
-    }
-}
-
-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}");
-        }
-        return b;
     }
 
-    for backend in [
+    #[cfg(windows)]
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    match windows::WindowsInputCapture::new() {
-        CaptureBackend::InputCapturePortal,
+        Ok(p) => return Box::new(p),
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Err(e) => log::info!("windows input capture not available: {e}"),
-        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(CaptureCreationError::NoAvailableBackend)
+
+    #[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);
+        }
+        Err(e) => log::info!("libei input capture not available: {e}"),
+    }
+
+    #[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);
+        }
+        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())
 }
 
 pub trait InputCapture: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {

src/capture/error.rs

@@ -1,142 +0,0 @@
-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 :(")
-    }
-}

src/capture/libei.rs

@@ -36,8 +36,6 @@ use crate::{
     event::{Event, KeyboardEvent, PointerEvent},
 };
 
-use super::error::LibeiCaptureCreationError;
-
 #[derive(Debug)]
 enum ProducerEvent {
     Release,
@@ -133,7 +131,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {
 
 async fn create_session<'a>(
     input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
+) -> Result<(Session<'a>, BitFlags<Capabilities>)> {
     log::debug!("creating input capture session");
     let (session, capabilities) = loop {
         match input_capture
@@ -215,7 +213,7 @@ async fn wait_for_active_client(
 }
 
 impl<'a> LibeiInputCapture<'a> {
-    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
+    pub async fn new() -> Result<Self> {
         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?);

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() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+    pub fn new() -> Result<Self> {
-        Err(MacOSInputCaptureCreationError::NotImplemented)
+        Err(anyhow!("not yet implemented"))
     }
 }
 

src/capture/wayland.rs

@@ -1,8 +1,9 @@
 use crate::{
-    capture::{error::WaylandBindError, InputCapture},
+    capture::InputCapture,
     client::{ClientEvent, ClientHandle, Position},
 };
 
+use anyhow::{anyhow, Result};
 use futures_core::Stream;
 use memmap::MmapOptions;
 use std::{
@@ -67,8 +68,6 @@ use tempfile;
 
 use crate::event::{Event, KeyboardEvent, PointerEvent};
 
-use super::error::LayerShellCaptureCreationError;
-
 struct Globals {
     compositor: wl_compositor::WlCompositor,
     pointer_constraints: ZwpPointerConstraintsV1,
@@ -259,37 +258,64 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
 }
 
 impl WaylandInputCapture {
-    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
+    pub fn new() -> Result<Self> {
-        let conn = Connection::connect_to_env()?;
+        let conn = match Connection::connect_to_env() {
-        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
+            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:?}")),
+        };
 
         let qh = queue.handle();
 
-        let compositor: wl_compositor::WlCompositor = g
+        let compositor: wl_compositor::WlCompositor = match g.bind(&qh, 4..=5, ()) {
-            .bind(&qh, 4..=5, ())
+            Ok(compositor) => compositor,
-            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
+            Err(_) => return Err(anyhow!("wl_compositor >= v4 not supported")),
-        let xdg_output_manager: ZxdgOutputManagerV1 = g
+        };
-            .bind(&qh, 1..=3, ())
+
-            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
+        let xdg_output_manager: ZxdgOutputManagerV1 = match g.bind(&qh, 1..=3, ()) {
-        let shm: wl_shm::WlShm = g
+            Ok(xdg_output_manager) => xdg_output_manager,
-            .bind(&qh, 1..=1, ())
+            Err(_) => return Err(anyhow!("xdg_output not supported!")),
-            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
+        };
-        let layer_shell: ZwlrLayerShellV1 = g
+
-            .bind(&qh, 3..=4, ())
+        let shm: wl_shm::WlShm = match g.bind(&qh, 1..=1, ()) {
-            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
+            Ok(wl_shm) => wl_shm,
-        let seat: wl_seat::WlSeat = g
+            Err(_) => return Err(anyhow!("wl_shm v1 not supported")),
-            .bind(&qh, 7..=8, ())
+        };
-            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
+
+        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 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 {

src/capture/windows.rs

@@ -96,7 +96,8 @@ 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 { *(lparam.0 as *const MSLLHOOKSTRUCT) };
+    let mouse_low_level: MSLLHOOKSTRUCT =
+        unsafe { *std::mem::transmute::<LPARAM, *const MSLLHOOKSTRUCT>(lparam) };
     match wparam {
         WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
             time: 0,
@@ -166,7 +167,8 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
 }
 
 unsafe fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
-    let kybrdllhookstruct: KBDLLHOOKSTRUCT = *(lparam.0 as *const KBDLLHOOKSTRUCT);
+    let kybrdllhookstruct: KBDLLHOOKSTRUCT =
+        *std::mem::transmute::<LPARAM, *const KBDLLHOOKSTRUCT>(lparam);
     let mut scan_code = kybrdllhookstruct.scanCode;
     log::trace!("scan_code: {scan_code}");
     if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
@@ -245,7 +247,8 @@ 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 = *(lparam.0 as *const MSLLHOOKSTRUCT);
+    let mouse_low_level: MSLLHOOKSTRUCT =
+        unsafe { *std::mem::transmute::<LPARAM, *const MSLLHOOKSTRUCT>(lparam) };
     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);
@@ -575,7 +578,7 @@ fn update_clients(client_event: ClientEvent) {
 }
 
 impl WindowsInputCapture {
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new() -> Result<Self> {
         unsafe {
             let (tx, rx) = channel(10);
             EVENT_TX.replace(tx);
@@ -583,10 +586,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");
-            Self {
+            Ok(Self {
                 msg_thread,
                 event_rx: rx,
-            }
+            })
         }
     }
 }

src/capture/x11.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use std::io;
 use std::task::Poll;
 
@@ -8,13 +9,11 @@ use crate::event::Event;
 
 use crate::client::{ClientEvent, ClientHandle};
 
-use super::error::X11InputCaptureCreationError;
-
 pub struct X11InputCapture {}
 
 impl X11InputCapture {
-    pub fn new() -> std::result::Result<Self, X11InputCaptureCreationError> {
+    pub fn new() -> Result<Self> {
-        Err(X11InputCaptureCreationError::NotImplemented)
+        Err(anyhow!("not implemented"))
     }
 }
 

src/capture_test.rs

@@ -1,6 +1,5 @@
 use crate::capture;
 use crate::client::{ClientEvent, Position};
-use crate::config::Config;
 use crate::event::{Event, KeyboardEvent};
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
@@ -13,14 +12,12 @@ pub fn run() -> Result<()> {
         .enable_time()
         .build()?;
 
-    let config = Config::new()?;
+    runtime.block_on(LocalSet::new().run_until(input_capture_test()))
-
-    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
 }
 
-async fn input_capture_test(config: Config) -> Result<()> {
+async fn input_capture_test() -> Result<()> {
     log::info!("creating input capture");
-    let mut input_capture = capture::create(config.capture_backend).await?;
+    let mut input_capture = capture::create().await;
     log::info!("creating clients");
     input_capture.notify(ClientEvent::Create(0, Position::Left))?;
     input_capture.notify(ClientEvent::Create(1, Position::Right))?;

src/config.rs

@@ -1,9 +1,8 @@
 use anyhow::Result;
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 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;
@@ -16,10 +15,8 @@ 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<Frontend>,
+    pub frontend: Option<String>,
     pub release_bind: Option<Vec<scancode::Linux>>,
     pub left: Option<TomlClient>,
     pub right: Option<TomlClient>,
@@ -29,7 +26,6 @@ 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>>,
@@ -55,7 +51,7 @@ struct CliArgs {
 
     /// the frontend to use [cli | gtk]
     #[arg(short, long)]
-    frontend: Option<Frontend>,
+    frontend: Option<String>,
 
     /// non-default config file location
     #[arg(short, long)]
@@ -72,106 +68,16 @@ 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(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
+#[derive(Debug, PartialEq, Eq)]
-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)>,
@@ -223,14 +129,33 @@ impl Config {
             Ok(c) => Some(c),
         };
 
-        let frontend_arg = args.frontend;
+        let frontend = match args.frontend {
-        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
+            None => match &config_toml {
-        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
+                Some(c) => c.frontend.clone(),
+                None => None,
+            },
+            frontend => frontend,
+        };
 
-        let port = args
+        let frontend = match frontend {
-            .port
+            #[cfg(feature = "gtk")]
-            .or(config_toml.as_ref().and_then(|c| c.port))
+            None => Frontend::Gtk,
-            .unwrap_or(DEFAULT_PORT);
+            #[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,
+            },
+        };
 
         log::debug!("{config_toml:?}");
         let release_bind = config_toml
@@ -238,14 +163,6 @@ 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 {
@@ -268,8 +185,6 @@ impl Config {
         let test_emulation = args.test_emulation;
 
         Ok(Config {
-            capture_backend,
-            emulation_backend,
             daemon,
             frontend,
             clients,

src/emulate.rs

@@ -3,13 +3,10 @@ use std::future;
 
 use crate::{
     client::{ClientEvent, ClientHandle},
-    config::EmulationBackend,
     event::Event,
 };
 use anyhow::Result;
 
-use self::error::EmulationCreationError;
-
 #[cfg(windows)]
 pub mod windows;
 
@@ -30,7 +27,6 @@ pub mod macos;
 
 /// fallback input emulation (logs events)
 pub mod dummy;
-pub mod error;
 
 #[async_trait]
 pub trait InputEmulation: Send {
@@ -45,60 +41,58 @@ pub trait InputEmulation: Send {
     async fn destroy(&mut self);
 }
 
-pub async fn create_backend(
+pub async fn create() -> Box<dyn InputEmulation> {
-    backend: EmulationBackend,
+    #[cfg(windows)]
-) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    match windows::WindowsEmulation::new() {
-    match backend {
+        Ok(c) => return Box::new(c),
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Err(e) => log::warn!("windows input emulation unavailable: {e}"),
-        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())),
     }
-}
 
-pub async fn create(
+    #[cfg(target_os = "macos")]
-    backend: Option<EmulationBackend>,
+    match macos::MacOSEmulation::new() {
-) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+        Ok(c) => {
-    if let Some(backend) = backend {
+            log::info!("using macos input emulation");
-        let b = create_backend(backend).await;
+            return Box::new(c);
-        if b.is_ok() {
-            log::info!("using emulation backend: {backend}");
         }
-        return b;
+        Err(e) => log::error!("macos input emulatino not available: {e}"),
     }
 
-    for backend in [
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    match wlroots::WlrootsEmulation::new() {
-        EmulationBackend::Wlroots,
+        Ok(c) => {
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            log::info!("using wlroots input emulation");
-        EmulationBackend::Libei,
+            return Box::new(c);
-        #[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(e) => log::info!("wayland backend not available: {e}"),
     }
 
-    Err(EmulationCreationError::NoAvailableBackend)
+    #[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())
 }

src/emulate/error.rs

@@ -1,168 +0,0 @@
-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 {}

src/emulate/libei.rs

@@ -1,11 +1,10 @@
-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},
@@ -28,8 +27,6 @@ use crate::{
     event::Event,
 };
 
-use super::error::LibeiEmulationCreationError;
-
 pub struct LibeiEmulation {
     handshake: bool,
     context: ei::Context,
@@ -80,14 +77,14 @@ async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
 }
 
 impl LibeiEmulation {
-    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
+    pub async fn new() -> Result<Self> {
         // 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().map_err(|e| io::Error::new(e.kind(), e))?;
+        context.flush()?;
         let events = EiEventStream::new(context.clone())?;
         Ok(Self {
             handshake: false,

src/emulate/macos.rs

@@ -1,6 +1,7 @@
 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::{
@@ -12,8 +13,6 @@ 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);
 
@@ -54,9 +53,11 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}
 
 impl MacOSEmulation {
-    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
+    pub fn new() -> Result<Self> {
-        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
-            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
+            Ok(e) => e,
+            Err(_) => return Err(anyhow!("event source creation failed!")),
+        };
         let button_state = ButtonState {
             left: false,
             right: false,

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, WindowsEmulationCreationError> {
+    pub fn new() -> Result<Self> {
         Ok(Self { repeat_task: None })
     }
 }

src/emulate/wlroots.rs

@@ -1,5 +1,5 @@
 use crate::client::{ClientEvent, ClientHandle};
-use crate::emulate::{error::WlrootsEmulationCreationError, InputEmulation};
+use crate::emulate::InputEmulation;
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -7,6 +7,7 @@ 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;
@@ -29,8 +30,6 @@ 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>,
@@ -48,21 +47,18 @@ pub(crate) struct WlrootsEmulation {
 }
 
 impl WlrootsEmulation {
-    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
+    pub fn new() -> Result<Self> {
         let conn = Connection::connect_to_env()?;
         let (globals, queue) = registry_queue_init::<State>(&conn)?;
         let qh = queue.handle();
 
-        let seat: wl_seat::WlSeat = globals
+        let seat: wl_seat::WlSeat = match globals.bind(&qh, 7..=8, ()) {
-            .bind(&qh, 7..=8, ())
+            Ok(wl_seat) => wl_seat,
-            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
+            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
+        };
 
-        let vpm: VpManager = globals
+        let vpm: VpManager = globals.bind(&qh, 1..=1, ())?;
-            .bind(&qh, 1..=1, ())
+        let vkm: VkManager = 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();
 
@@ -79,7 +75,7 @@ impl WlrootsEmulation {
             queue,
         };
         while emulate.state.keymap.is_none() {
-            emulate.queue.blocking_dispatch(&mut emulate.state)?;
+            emulate.queue.blocking_dispatch(&mut emulate.state).unwrap();
         }
         // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
         // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };

src/emulate/x11.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use std::ptr;
 use x11::{
@@ -13,8 +14,6 @@ use crate::{
     },
 };
 
-use super::error::X11EmulationCreationError;
-
 pub struct X11Emulation {
     display: *mut xlib::Display,
 }
@@ -22,11 +21,11 @@ pub struct X11Emulation {
 unsafe impl Send for X11Emulation {}
 
 impl X11Emulation {
-    pub fn new() -> Result<Self, X11EmulationCreationError> {
+    pub fn new() -> Result<Self> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
                 d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
-                    Err(X11EmulationCreationError::OpenDisplay)
+                    Err(anyhow!("could not open display"))
                 }
                 display => Ok(display),
             }

src/emulate/xdg_desktop_portal.rs

@@ -17,15 +17,13 @@ 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>, XdpEmulationCreationError> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>> {
         log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
         let proxy = RemoteDesktop::new().await?;
 

src/emulation_test.rs

@@ -1,5 +1,4 @@
 use crate::client::{ClientEvent, Position};
-use crate::config::Config;
 use crate::emulate;
 use crate::event::{Event, PointerEvent};
 use anyhow::Result;
@@ -14,16 +13,14 @@ pub fn run() -> Result<()> {
         .enable_time()
         .build()?;
 
-    let config = Config::new()?;
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test()))
-
-    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(config: Config) -> Result<()> {
+async fn input_emulation_test() -> Result<()> {
-    let mut emulation = emulate::create(config.emulation_backend).await?;
+    let mut emulation = emulate::create().await;
     emulation
         .notify(ClientEvent::Create(0, Position::Left))
         .await;

src/main.rs

@@ -68,12 +68,10 @@ fn run_service(config: &Config) -> Result<()> {
     // run async event loop
     runtime.block_on(LocalSet::new().run_until(async {
         // run main loop
-        log::info!("Press {:?} to release the mouse", config.release_bind);
+        log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
 
         let server = Server::new(config);
-        server
+        server.run().await?;
-            .run(config.capture_backend, config.emulation_backend)
-            .await?;
 
         log::debug!("service exiting");
         anyhow::Ok(())

src/server.rs

@@ -8,7 +8,7 @@ use tokio::signal;
 
 use crate::{
     client::{ClientConfig, ClientHandle, ClientManager, ClientState},
-    config::{CaptureBackend, Config, EmulationBackend},
+    config::Config,
     dns,
     frontend::{FrontendListener, FrontendRequest},
     server::capture_task::CaptureEvent,
@@ -77,11 +77,7 @@ impl Server {
         }
     }
 
-    pub async fn run(
+    pub async fn run(&self) -> anyhow::Result<()> {
-        &self,
-        capture_backend: Option<CaptureBackend>,
-        emulation_backend: Option<EmulationBackend>,
-    ) -> anyhow::Result<()> {
         // create frontend communication adapter
         let frontend = match FrontendListener::new().await {
             Some(f) => f?,
@@ -101,22 +97,20 @@ 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?;

src/server/capture_task.rs

@@ -5,9 +5,8 @@ use std::{collections::HashSet, net::SocketAddr};
 use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
 
 use crate::{
-    capture::{self, error::CaptureCreationError, InputCapture},
+    capture::{self, InputCapture},
     client::{ClientEvent, ClientHandle},
-    config::CaptureBackend,
     event::{Event, KeyboardEvent},
     scancode,
     server::State,
@@ -26,15 +25,14 @@ pub enum CaptureEvent {
 }
 
 pub fn new(
-    backend: Option<CaptureBackend>,
     server: Server,
     sender_tx: Sender<(Event, SocketAddr)>,
     timer_tx: Sender<()>,
     release_bind: Vec<scancode::Linux>,
-) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
+) -> (JoinHandle<Result<()>>, Sender<CaptureEvent>) {
     let (tx, mut rx) = tokio::sync::mpsc::channel(32);
     let task = tokio::task::spawn_local(async move {
-        let mut capture = capture::create(backend).await?;
+        let mut capture = capture::create().await;
         let mut pressed_keys = HashSet::new();
         loop {
             tokio::select! {
@@ -64,7 +62,7 @@ pub fn new(
         }
         anyhow::Ok(())
     });
-    Ok((task, tx))
+    (task, tx)
 }
 
 fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {

src/server/emulation_task.rs

@@ -8,8 +8,7 @@ use tokio::{
 
 use crate::{
     client::{ClientEvent, ClientHandle},
-    config::EmulationBackend,
+    emulate::{self, InputEmulation},
-    emulate::{self, error::EmulationCreationError, InputEmulation},
     event::{Event, KeyboardEvent},
     scancode,
     server::State,
@@ -28,16 +27,15 @@ 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<()>,
-) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
+) -> (JoinHandle<Result<()>>, Sender<EmulationEvent>) {
     let (tx, mut rx) = tokio::sync::mpsc::channel(32);
     let emulate_task = tokio::task::spawn_local(async move {
-        let mut emulate = emulate::create(backend).await?;
+        let mut emulate = emulate::create().await;
         let mut last_ignored = None;
 
         loop {
@@ -77,7 +75,7 @@ pub fn new(
         emulate.destroy().await;
         anyhow::Ok(())
     });
-    Ok((emulate_task, tx))
+    (emulate_task, tx)
 }
 
 async fn handle_udp_rx(