split into input-{event,capture,emulation}

input-capture/src/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 :(")
+    }
+}