From 6cc97ee56eb0a8cd4855785ecdc7058155379d41 Mon Sep 17 00:00:00 2001 From: Julian Orth Date: Wed, 1 Jun 2022 14:29:56 +0200 Subject: [PATCH] metal,config: allow enabling tap-to-click --- build/enums.rs | 15 ++++++ jay-config/src/_private/client.rs | 12 +++++ jay-config/src/_private/ipc.rs | 12 +++++ jay-config/src/input.rs | 21 +++++++++ src/backend.rs | 3 ++ src/backends/metal.rs | 33 +++++++++++++ src/backends/metal/monitor.rs | 3 ++ src/backends/x.rs | 24 ++++++++++ src/config/handler.rs | 31 +++++++++++++ src/it/test_backend.rs | 24 ++++++++++ src/libinput/consts.rs | 21 +++++++++ src/libinput/device.rs | 77 +++++++++++++++++++++++++++++-- src/libinput/sys.rs | 21 +++++++++ 13 files changed, 293 insertions(+), 4 deletions(-) diff --git a/build/enums.rs b/build/enums.rs index ecaaf96c..d7316e50 100644 --- a/build/enums.rs +++ b/build/enums.rs @@ -119,6 +119,21 @@ pub fn main() -> anyhow::Result<()> { libinput::LIBINPUT_CONFIG_ACCEL_PROFILE, "libinput_config_accel_profile", )?; + write_ty( + &mut f, + libinput::LIBINPUT_CONFIG_TAP_STATE, + "libinput_config_tap_state", + )?; + write_ty( + &mut f, + libinput::LIBINPUT_CONFIG_DRAG_STATE, + "libinput_config_drag_state", + )?; + write_ty( + &mut f, + libinput::LIBINPUT_CONFIG_DRAG_LOCK_STATE, + "libinput_config_drag_lock_state", + )?; let mut f = open("pango_tys.rs")?; write_ty(&mut f, pango::CAIRO_FORMATS, "cairo_format_t")?; diff --git a/jay-config/src/_private/client.rs b/jay-config/src/_private/client.rs index 303af529..c3da73c5 100644 --- a/jay-config/src/_private/client.rs +++ b/jay-config/src/_private/client.rs @@ -556,6 +556,18 @@ impl Client { self.send(&ClientMessage::SetPxPerWheelScroll { device, px }) } + pub fn set_input_tap_enabled(&self, device: InputDevice, enabled: bool) { + self.send(&ClientMessage::SetTapEnabled { device, enabled }) + } + + pub fn set_input_drag_enabled(&self, device: InputDevice, enabled: bool) { + self.send(&ClientMessage::SetDragEnabled { device, enabled }) + } + + pub fn set_input_drag_lock_enabled(&self, device: InputDevice, enabled: bool) { + self.send(&ClientMessage::SetDragLockEnabled { device, enabled }) + } + pub fn device_name(&self, device: InputDevice) -> String { let res = self.send_with_response(&ClientMessage::GetDeviceName { device }); get_response!(res, String::new(), GetDeviceName { name }); diff --git a/jay-config/src/_private/ipc.rs b/jay-config/src/_private/ipc.rs index cc29025a..cce4d751 100644 --- a/jay-config/src/_private/ipc.rs +++ b/jay-config/src/_private/ipc.rs @@ -288,6 +288,18 @@ pub enum ClientMessage<'a> { seat: Seat, size: i32, }, + SetTapEnabled { + device: InputDevice, + enabled: bool, + }, + SetDragEnabled { + device: InputDevice, + enabled: bool, + }, + SetDragLockEnabled { + device: InputDevice, + enabled: bool, + }, } #[derive(Encode, Decode, Debug)] diff --git a/jay-config/src/input.rs b/jay-config/src/input.rs index 25ba95f1..adcd5839 100644 --- a/jay-config/src/input.rs +++ b/jay-config/src/input.rs @@ -83,6 +83,27 @@ impl InputDevice { pub fn set_px_per_wheel_scroll(self, px: f64) { get!().set_px_per_wheel_scroll(self, px); } + + /// Sets whether tap-to-click is enabled for this device. + /// + /// See https://wayland.freedesktop.org/libinput/doc/latest/tapping.html + pub fn set_tap_enabled(self, enabled: bool) { + get!().set_input_tap_enabled(self, enabled); + } + + /// Sets whether tap-and-drag is enabled for this device. + /// + /// See https://wayland.freedesktop.org/libinput/doc/latest/tapping.html + pub fn set_drag_enabled(self, enabled: bool) { + get!().set_input_drag_enabled(self, enabled); + } + + /// Sets whether drag lock is enabled for this device. + /// + /// See https://wayland.freedesktop.org/libinput/doc/latest/tapping.html + pub fn set_drag_lock_enabled(self, enabled: bool) { + get!().set_input_drag_lock_enabled(self, enabled); + } } /// A seat. diff --git a/src/backend.rs b/src/backend.rs index 30daa384..43e327a4 100644 --- a/src/backend.rs +++ b/src/backend.rs @@ -104,6 +104,9 @@ pub trait InputDevice { fn set_accel_speed(&self, speed: f64); fn set_transform_matrix(&self, matrix: TransformMatrix); fn name(&self) -> Rc; + fn set_tap_enabled(&self, enabled: bool); + fn set_drag_enabled(&self, enabled: bool); + fn set_drag_lock_enabled(&self, enabled: bool); } #[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)] diff --git a/src/backends/metal.rs b/src/backends/metal.rs index 2e2c651d..6bc130c7 100644 --- a/src/backends/metal.rs +++ b/src/backends/metal.rs @@ -291,6 +291,9 @@ struct MetalInputDevice { accel_profile: Cell>, accel_speed: Cell>, transform_matrix: Cell>, + tap_enabled: Cell>, + drag_enabled: Cell>, + drag_lock_enabled: Cell>, } #[derive(Clone)] @@ -339,6 +342,15 @@ impl MetalInputDevice { if let Some(speed) = self.accel_speed.get() { dev.device().set_accel_speed(speed); } + if let Some(enabled) = self.tap_enabled.get() { + dev.device().set_tap_enabled(enabled); + } + if let Some(enabled) = self.drag_enabled.get() { + dev.device().set_drag_enabled(enabled); + } + if let Some(enabled) = self.drag_lock_enabled.get() { + dev.device().set_drag_lock_enabled(enabled); + } } fn pre_pause(&self) { @@ -429,6 +441,27 @@ impl InputDevice for MetalInputDevice { fn name(&self) -> Rc { self.name.get() } + + fn set_tap_enabled(&self, enabled: bool) { + self.tap_enabled.set(Some(enabled)); + if let Some(dev) = self.inputdev.get() { + dev.device().set_tap_enabled(enabled); + } + } + + fn set_drag_enabled(&self, enabled: bool) { + self.drag_enabled.set(Some(enabled)); + if let Some(dev) = self.inputdev.get() { + dev.device().set_drag_enabled(enabled); + } + } + + fn set_drag_lock_enabled(&self, enabled: bool) { + self.drag_lock_enabled.set(Some(enabled)); + if let Some(dev) = self.inputdev.get() { + dev.device().set_drag_lock_enabled(enabled); + } + } } impl MetalInputDevice { diff --git a/src/backends/metal/monitor.rs b/src/backends/metal/monitor.rs index b4813215..775ea662 100644 --- a/src/backends/metal/monitor.rs +++ b/src/backends/metal/monitor.rs @@ -287,6 +287,9 @@ impl MetalBackend { accel_profile: Default::default(), accel_speed: Default::default(), transform_matrix: Default::default(), + tap_enabled: Default::default(), + drag_enabled: Default::default(), + drag_lock_enabled: Default::default(), }); slots[slot] = Some(dev.clone()); self.device_holder diff --git a/src/backends/x.rs b/src/backends/x.rs index d24b387f..1bffa8d1 100644 --- a/src/backends/x.rs +++ b/src/backends/x.rs @@ -1081,6 +1081,18 @@ impl InputDevice for XSeatKeyboard { fn name(&self) -> Rc { self.0.kb_name.clone() } + + fn set_tap_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_lock_enabled(&self, enabled: bool) { + let _ = enabled; + } } impl InputDevice for XSeatMouse { @@ -1130,4 +1142,16 @@ impl InputDevice for XSeatMouse { fn name(&self) -> Rc { self.0.mouse_name.clone() } + + fn set_tap_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_lock_enabled(&self, enabled: bool) { + let _ = enabled; + } } diff --git a/src/config/handler.rs b/src/config/handler.rs index 1914ac30..d9a0eff1 100644 --- a/src/config/handler.rs +++ b/src/config/handler.rs @@ -494,6 +494,28 @@ impl ConfigProxyHandler { Ok(()) } + fn handle_set_tap_enabled(&self, device: InputDevice, enabled: bool) -> Result<(), CphError> { + let dev = self.get_device_handler_data(device)?; + dev.device.set_tap_enabled(enabled); + Ok(()) + } + + fn handle_set_drag_enabled(&self, device: InputDevice, enabled: bool) -> Result<(), CphError> { + let dev = self.get_device_handler_data(device)?; + dev.device.set_drag_enabled(enabled); + Ok(()) + } + + fn handle_set_drag_lock_enabled( + &self, + device: InputDevice, + enabled: bool, + ) -> Result<(), CphError> { + let dev = self.get_device_handler_data(device)?; + dev.device.set_drag_lock_enabled(enabled); + Ok(()) + } + fn handle_set_transform_matrix( &self, device: InputDevice, @@ -1140,6 +1162,15 @@ impl ConfigProxyHandler { ClientMessage::SetCursorSize { seat, size } => self .handle_set_cursor_size(seat, size) .wrn("set_cursor_size")?, + ClientMessage::SetTapEnabled { device, enabled } => self + .handle_set_tap_enabled(device, enabled) + .wrn("set_tap_enabled")?, + ClientMessage::SetDragEnabled { device, enabled } => self + .handle_set_drag_enabled(device, enabled) + .wrn("set_drag_enabled")?, + ClientMessage::SetDragLockEnabled { device, enabled } => self + .handle_set_drag_lock_enabled(device, enabled) + .wrn("set_drag_lock_enabled")?, } Ok(()) } diff --git a/src/it/test_backend.rs b/src/it/test_backend.rs index 2b7b0dc3..45f38ea2 100644 --- a/src/it/test_backend.rs +++ b/src/it/test_backend.rs @@ -427,6 +427,18 @@ trait TestInputDevice: InputDevice { fn set_transform_matrix(&self, matrix: TransformMatrix) { let _ = matrix; } + + fn set_tap_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_enabled(&self, enabled: bool) { + let _ = enabled; + } + + fn set_drag_lock_enabled(&self, enabled: bool) { + let _ = enabled; + } } impl InputDevice for T { @@ -473,4 +485,16 @@ impl InputDevice for T { fn name(&self) -> Rc { self.common().name.clone() } + + fn set_tap_enabled(&self, enabled: bool) { + ::set_tap_enabled(self, enabled) + } + + fn set_drag_enabled(&self, enabled: bool) { + ::set_drag_enabled(self, enabled) + } + + fn set_drag_lock_enabled(&self, enabled: bool) { + ::set_drag_lock_enabled(self, enabled) + } } diff --git a/src/libinput/consts.rs b/src/libinput/consts.rs index 42b2d3ff..0766b764 100644 --- a/src/libinput/consts.rs +++ b/src/libinput/consts.rs @@ -166,3 +166,24 @@ cenum! { LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT = 1 << 0, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE = 1 << 1, } + +cenum! { + ConfigTapState, LIBINPUT_CONFIG_TAP_STATE; + + LIBINPUT_CONFIG_TAP_DISABLED = 0, + LIBINPUT_CONFIG_TAP_ENABLED = 1, +} + +cenum! { + ConfigDragState, LIBINPUT_CONFIG_DRAG_STATE; + + LIBINPUT_CONFIG_DRAG_DISABLED = 0, + LIBINPUT_CONFIG_DRAG_ENABLED = 1, +} + +cenum! { + ConfigDragLockState, LIBINPUT_CONFIG_DRAG_LOCK_STATE; + + LIBINPUT_CONFIG_DRAG_LOCK_DISABLED = 0, + LIBINPUT_CONFIG_DRAG_LOCK_ENABLED = 1, +} diff --git a/src/libinput/device.rs b/src/libinput/device.rs index 29e6b524..b996b39f 100644 --- a/src/libinput/device.rs +++ b/src/libinput/device.rs @@ -1,12 +1,21 @@ use { crate::libinput::{ - consts::{AccelProfile, DeviceCapability}, + consts::{ + AccelProfile, ConfigDragLockState, ConfigDragState, ConfigTapState, DeviceCapability, + LIBINPUT_CONFIG_DRAG_DISABLED, LIBINPUT_CONFIG_DRAG_ENABLED, + LIBINPUT_CONFIG_DRAG_LOCK_DISABLED, LIBINPUT_CONFIG_DRAG_LOCK_ENABLED, + LIBINPUT_CONFIG_TAP_DISABLED, LIBINPUT_CONFIG_TAP_ENABLED, + }, sys::{ libinput_device, libinput_device_config_accel_set_profile, libinput_device_config_accel_set_speed, libinput_device_config_left_handed_set, - libinput_device_get_name, libinput_device_get_user_data, - libinput_device_has_capability, libinput_device_set_user_data, libinput_device_unref, - libinput_path_remove_device, + libinput_device_config_tap_get_drag_enabled, + libinput_device_config_tap_get_drag_lock_enabled, + libinput_device_config_tap_get_enabled, libinput_device_config_tap_set_drag_enabled, + libinput_device_config_tap_set_drag_lock_enabled, + libinput_device_config_tap_set_enabled, libinput_device_get_name, + libinput_device_get_user_data, libinput_device_has_capability, + libinput_device_set_user_data, libinput_device_unref, libinput_path_remove_device, }, LibInput, }, @@ -77,6 +86,66 @@ impl<'a> LibInputDevice<'a> { CStr::from_ptr(name).to_bytes().as_bstr().to_string() } } + + pub fn set_tap_enabled(&self, enabled: bool) { + let enabled = match enabled { + true => LIBINPUT_CONFIG_TAP_ENABLED, + false => LIBINPUT_CONFIG_TAP_DISABLED, + }; + unsafe { + libinput_device_config_tap_set_enabled(self.dev, enabled.raw() as _); + } + } + + #[allow(dead_code)] + pub fn tap_enabled(&self) -> bool { + let enabled = unsafe { ConfigTapState(libinput_device_config_tap_get_enabled(self.dev)) }; + match enabled { + LIBINPUT_CONFIG_TAP_ENABLED => true, + _ => false, + } + } + + pub fn set_drag_enabled(&self, enabled: bool) { + let enabled = match enabled { + true => LIBINPUT_CONFIG_DRAG_ENABLED, + false => LIBINPUT_CONFIG_DRAG_DISABLED, + }; + unsafe { + libinput_device_config_tap_set_drag_enabled(self.dev, enabled.raw() as _); + } + } + + #[allow(dead_code)] + pub fn drag_enabled(&self) -> bool { + let enabled = + unsafe { ConfigDragState(libinput_device_config_tap_get_drag_enabled(self.dev)) }; + match enabled { + LIBINPUT_CONFIG_DRAG_ENABLED => true, + _ => false, + } + } + + pub fn set_drag_lock_enabled(&self, enabled: bool) { + let enabled = match enabled { + true => LIBINPUT_CONFIG_DRAG_LOCK_ENABLED, + false => LIBINPUT_CONFIG_DRAG_LOCK_DISABLED, + }; + unsafe { + libinput_device_config_tap_set_drag_lock_enabled(self.dev, enabled.raw() as _); + } + } + + #[allow(dead_code)] + pub fn drag_lock_enabled(&self) -> bool { + let enabled = unsafe { + ConfigDragLockState(libinput_device_config_tap_get_drag_lock_enabled(self.dev)) + }; + match enabled { + LIBINPUT_CONFIG_DRAG_LOCK_ENABLED => true, + _ => false, + } + } } impl RegisteredDevice { diff --git a/src/libinput/sys.rs b/src/libinput/sys.rs index bd122c3e..151514bb 100644 --- a/src/libinput/sys.rs +++ b/src/libinput/sys.rs @@ -54,6 +54,27 @@ extern "C" { speed: f64, ) -> libinput_config_status; pub fn libinput_device_get_name(device: *mut libinput_device) -> *const c::c_char; + pub fn libinput_device_config_tap_set_enabled( + device: *mut libinput_device, + enable: libinput_config_tap_state, + ) -> libinput_config_status; + pub fn libinput_device_config_tap_get_enabled( + device: *mut libinput_device, + ) -> libinput_config_tap_state; + pub fn libinput_device_config_tap_set_drag_enabled( + device: *mut libinput_device, + enable: libinput_config_drag_state, + ) -> libinput_config_status; + pub fn libinput_device_config_tap_get_drag_enabled( + device: *mut libinput_device, + ) -> libinput_config_drag_state; + pub fn libinput_device_config_tap_set_drag_lock_enabled( + device: *mut libinput_device, + enable: libinput_config_drag_lock_state, + ) -> libinput_config_status; + pub fn libinput_device_config_tap_get_drag_lock_enabled( + device: *mut libinput_device, + ) -> libinput_config_drag_lock_state; pub fn libinput_event_destroy(event: *mut libinput_event); pub fn libinput_event_get_type(event: *mut libinput_event) -> libinput_event_type;