InputConfig: simplify libinput API usage

All of these API calls checking if the device supports a given option
and checking if the value would be changed are effectively useless.

A quick peek inside the libinput source code shows us that all of these
"setter" functions validate their arguments and return an error if they
are invalid.

Since we don't do anything with the information of whether or not a
config option has been changed or if a config option is even supported
for a given device, all these apply() functions can be simplified to a
single libinput function call.

 river/InputConfig.zig | 129 +++++++++++++-------------------------------------
 1 file changed, 32 insertions(+), 97 deletions(-)

diff --git a/river/InputConfig.zig b/river/InputConfig.zig
index 258a25e..4b6fa37 100644
--- a/river/InputConfig.zig
+++ b/river/InputConfig.zig
@@ -37,16 +37,12 @@ pub const EventState = enum {
     disabled,
     @"disabled-on-external-mouse",
 
-    pub fn apply(event_state: EventState, device: *c.libinput_device) void {
-        const want: u32 = switch (event_state) {
+    fn apply(event_state: EventState, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_send_events_set_mode(device, switch (event_state) {
             .enabled => c.LIBINPUT_CONFIG_SEND_EVENTS_ENABLED,
             .disabled => c.LIBINPUT_CONFIG_SEND_EVENTS_DISABLED,
             .@"disabled-on-external-mouse" => c.LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE,
-        };
-        const current = c.libinput_device_config_send_events_get_mode(device);
-        if (want != current) {
-            _ = c.libinput_device_config_send_events_set_mode(device, want);
-        }
+        });
     }
 };
 
@@ -55,17 +51,12 @@ pub const AccelProfile = enum {
     flat,
     adaptive,
 
-    pub fn apply(accel_profile: AccelProfile, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (accel_profile) {
+    fn apply(accel_profile: AccelProfile, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_accel_set_profile(device, switch (accel_profile) {
             .none => c.LIBINPUT_CONFIG_ACCEL_PROFILE_NONE,
             .flat => c.LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
             .adaptive => c.LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
         });
-        if (c.libinput_device_config_accel_is_available(device) == 0) return;
-        const current = c.libinput_device_config_accel_get_profile(device);
-        if (want != current) {
-            _ = c.libinput_device_config_accel_set_profile(device, want);
-        }
     }
 };
 
@@ -74,15 +65,12 @@ pub const ClickMethod = enum {
     @"button-areas",
     clickfinger,
 
-    pub fn apply(click_method: ClickMethod, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (click_method) {
+    fn apply(click_method: ClickMethod, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_click_set_method(device, switch (click_method) {
             .none => c.LIBINPUT_CONFIG_CLICK_METHOD_NONE,
             .@"button-areas" => c.LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS,
             .clickfinger => c.LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER,
         });
-        const supports = c.libinput_device_config_click_get_methods(device);
-        if (supports & want == 0) return;
-        _ = c.libinput_device_config_click_set_method(device, want);
     }
 };
 
@@ -90,16 +78,11 @@ pub const DragState = enum {
     disabled,
     enabled,
 
-    pub fn apply(drag_state: DragState, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (drag_state) {
+    fn apply(drag_state: DragState, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_tap_set_drag_enabled(device, switch (drag_state) {
             .disabled => c.LIBINPUT_CONFIG_DRAG_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_DRAG_ENABLED,
         });
-        if (c.libinput_device_config_tap_get_finger_count(device) <= 0) return;
-        const current = c.libinput_device_config_tap_get_drag_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_tap_set_drag_enabled(device, want);
-        }
     }
 };
 
@@ -107,16 +90,11 @@ pub const DragLock = enum {
     disabled,
     enabled,
 
-    pub fn apply(drag_lock: DragLock, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (drag_lock) {
+    fn apply(drag_lock: DragLock, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_tap_set_drag_lock_enabled(device, switch (drag_lock) {
             .disabled => c.LIBINPUT_CONFIG_DRAG_LOCK_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_DRAG_LOCK_ENABLED,
         });
-        if (c.libinput_device_config_tap_get_finger_count(device) <= 0) return;
-        const current = c.libinput_device_config_tap_get_drag_lock_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_tap_set_drag_lock_enabled(device, want);
-        }
     }
 };
 
@@ -124,16 +102,11 @@ pub const DwtState = enum {
     disabled,
     enabled,
 
-    pub fn apply(dwt_state: DwtState, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (dwt_state) {
+    fn apply(dwt_state: DwtState, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_dwt_set_enabled(device, switch (dwt_state) {
             .disabled => c.LIBINPUT_CONFIG_DWT_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_DWT_ENABLED,
         });
-        if (c.libinput_device_config_dwt_is_available(device) == 0) return;
-        const current = c.libinput_device_config_dwt_get_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_dwt_set_enabled(device, want);
-        }
     }
 };
 
@@ -141,16 +114,11 @@ pub const DwtpState = enum {
     disabled,
     enabled,
 
-    pub fn apply(dwtp_state: DwtpState, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (dwtp_state) {
+    fn apply(dwtp_state: DwtpState, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_dwtp_set_enabled(device, switch (dwtp_state) {
             .disabled => c.LIBINPUT_CONFIG_DWTP_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_DWTP_ENABLED,
         });
-        if (c.libinput_device_config_dwtp_is_available(device) == 0) return;
-        const current = c.libinput_device_config_dwtp_get_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_dwtp_set_enabled(device, want);
-        }
     }
 };
 
@@ -158,16 +126,11 @@ pub const MiddleEmulation = enum {
     disabled,
     enabled,
 
-    pub fn apply(middle_emulation: MiddleEmulation, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (middle_emulation) {
+    fn apply(middle_emulation: MiddleEmulation, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_middle_emulation_set_enabled(device, switch (middle_emulation) {
             .disabled => c.LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED,
         });
-        if (c.libinput_device_config_middle_emulation_is_available(device) == 0) return;
-        const current = c.libinput_device_config_middle_emulation_get_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_middle_emulation_set_enabled(device, want);
-        }
     }
 };
 
@@ -175,16 +138,11 @@ pub const NaturalScroll = enum {
     disabled,
     enabled,
 
-    pub fn apply(natural_scroll: NaturalScroll, device: *c.libinput_device) void {
-        const want: c_int = switch (natural_scroll) {
+    fn apply(natural_scroll: NaturalScroll, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_scroll_set_natural_scroll_enabled(device, switch (natural_scroll) {
             .disabled => 0,
             .enabled => 1,
-        };
-        if (c.libinput_device_config_scroll_has_natural_scroll(device) == 0) return;
-        const current = c.libinput_device_config_scroll_get_natural_scroll_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_scroll_set_natural_scroll_enabled(device, want);
-        }
+        });
     }
 };
 
@@ -192,16 +150,11 @@ pub const LeftHanded = enum {
     disabled,
     enabled,
 
-    pub fn apply(left_handed: LeftHanded, device: *c.libinput_device) void {
-        const want: c_int = switch (left_handed) {
+    fn apply(left_handed: LeftHanded, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_left_handed_set(device, switch (left_handed) {
             .disabled => 0,
             .enabled => 1,
-        };
-        if (c.libinput_device_config_left_handed_is_available(device) == 0) return;
-        const current = c.libinput_device_config_left_handed_get(device);
-        if (want != current) {
-            _ = c.libinput_device_config_left_handed_set(device, want);
-        }
+        });
     }
 };
 
@@ -209,16 +162,11 @@ pub const TapState = enum {
     disabled,
     enabled,
 
-    pub fn apply(tap_state: TapState, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (tap_state) {
+    fn apply(tap_state: TapState, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_tap_set_enabled(device, switch (tap_state) {
             .disabled => c.LIBINPUT_CONFIG_TAP_DISABLED,
             .enabled => c.LIBINPUT_CONFIG_TAP_ENABLED,
         });
-        if (c.libinput_device_config_tap_get_finger_count(device) <= 0) return;
-        const current = c.libinput_device_config_tap_get_enabled(device);
-        if (want != current) {
-            _ = c.libinput_device_config_tap_set_enabled(device, want);
-        }
     }
 };
 
@@ -226,27 +174,19 @@ pub const TapButtonMap = enum {
     @"left-middle-right",
     @"left-right-middle",
 
-    pub fn apply(tap_button_map: TapButtonMap, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (tap_button_map) {
+    fn apply(tap_button_map: TapButtonMap, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_tap_set_button_map(device, switch (tap_button_map) {
             .@"left-right-middle" => c.LIBINPUT_CONFIG_TAP_MAP_LRM,
             .@"left-middle-right" => c.LIBINPUT_CONFIG_TAP_MAP_LMR,
         });
-        if (c.libinput_device_config_tap_get_finger_count(device) <= 0) return;
-        const current = c.libinput_device_config_tap_get_button_map(device);
-        if (want != current) {
-            _ = c.libinput_device_config_tap_set_button_map(device, want);
-        }
     }
 };
 
 pub const PointerAccel = struct {
     value: f32,
 
-    pub fn apply(pointer_accel: PointerAccel, device: *c.libinput_device) void {
-        if (c.libinput_device_config_accel_is_available(device) == 0) return;
-        if (c.libinput_device_config_accel_get_speed(device) != pointer_accel.value) {
-            _ = c.libinput_device_config_accel_set_speed(device, pointer_accel.value);
-        }
+    fn apply(pointer_accel: PointerAccel, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_accel_set_speed(device, pointer_accel.value);
     }
 };
 
@@ -256,25 +196,20 @@ pub const ScrollMethod = enum {
     edge,
     button,
 
-    pub fn apply(scroll_method: ScrollMethod, device: *c.libinput_device) void {
-        const want = @as(c_uint, switch (scroll_method) {
+    fn apply(scroll_method: ScrollMethod, device: *c.libinput_device) void {
+        _ = c.libinput_device_config_scroll_set_method(device, switch (scroll_method) {
             .none => c.LIBINPUT_CONFIG_SCROLL_NO_SCROLL,
             .@"two-finger" => c.LIBINPUT_CONFIG_SCROLL_2FG,
             .edge => c.LIBINPUT_CONFIG_SCROLL_EDGE,
             .button => c.LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN,
         });
-        const supports = c.libinput_device_config_scroll_get_methods(device);
-        if (supports & want == 0) return;
-        _ = c.libinput_device_config_scroll_set_method(device, want);
     }
 };
 
 pub const ScrollButton = struct {
     button: u32,
 
-    pub fn apply(scroll_button: ScrollButton, device: *c.libinput_device) void {
-        const supports = c.libinput_device_config_scroll_get_methods(device);
-        if (supports & ~@as(u32, c.LIBINPUT_CONFIG_SCROLL_NO_SCROLL) == 0) return;
+    fn apply(scroll_button: ScrollButton, device: *c.libinput_device) void {
         _ = c.libinput_device_config_scroll_set_button(device, scroll_button.button);
     }
 };