diff --git a/src/config/handler.rs b/src/config/handler.rs
index 6fcf6ce5..77c95937 100644
--- a/src/config/handler.rs
+++ b/src/config/handler.rs
@@ -88,6 +88,7 @@ use {
 };
 
 mod dispatch;
+mod input_devices;
 mod matchers;
 mod outputs;
 mod theme;
@@ -368,21 +369,6 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_set_device_keymap(
-        &self,
-        device: InputDevice,
-        keymap: Keymap,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        let map = if keymap.is_invalid() {
-            None
-        } else {
-            Some(self.get_keymap(keymap)?)
-        };
-        dev.set_keymap(&self.state, map);
-        Ok(())
-    }
-
     fn handle_set_forward(&self, seat: Seat, forward: bool) -> Result<(), CphError> {
         let seat = self.get_seat(seat)?;
         seat.set_forward(forward);
@@ -426,23 +412,6 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_set_input_device_connector(
-        &self,
-        input_device: InputDevice,
-        connector: Connector,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(input_device)?;
-        let output = self.get_output_node(connector)?;
-        dev.set_output(&self.state, Some(&output.global));
-        Ok(())
-    }
-
-    fn handle_remove_input_mapping(&self, input_device: InputDevice) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(input_device)?;
-        dev.set_output(&self.state, None);
-        Ok(())
-    }
-
     fn handle_set_status(&self, status: &str) {
         self.state.set_status(status);
     }
@@ -694,132 +663,6 @@ impl ConfigProxyHandler {
         }
     }
 
-    fn handle_set_seat(&self, device: InputDevice, seat: Seat) -> Result<(), CphError> {
-        let seat = if seat.is_invalid() {
-            None
-        } else {
-            Some(self.get_seat(seat)?)
-        };
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_seat(&self.state, seat);
-        Ok(())
-    }
-
-    fn handle_set_left_handed(
-        &self,
-        device: InputDevice,
-        left_handed: bool,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_left_handed(&self.state, left_handed);
-        Ok(())
-    }
-
-    fn handle_set_accel_profile(
-        &self,
-        device: InputDevice,
-        accel_profile: AccelProfile,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        let profile = match accel_profile {
-            ACCEL_PROFILE_FLAT => InputDeviceAccelProfile::Flat,
-            ACCEL_PROFILE_ADAPTIVE => InputDeviceAccelProfile::Adaptive,
-            _ => return Err(CphError::UnknownAccelProfile(accel_profile)),
-        };
-        dev.set_accel_profile(&self.state, profile);
-        Ok(())
-    }
-
-    fn handle_set_accel_speed(&self, device: InputDevice, speed: f64) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_accel_speed(&self.state, speed);
-        Ok(())
-    }
-
-    fn handle_set_px_per_wheel_scroll(&self, device: InputDevice, px: f64) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_px_per_scroll_wheel(&self.state, px);
-        Ok(())
-    }
-
-    fn handle_set_tap_enabled(&self, device: InputDevice, enabled: bool) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_tap_enabled(&self.state, enabled);
-        Ok(())
-    }
-
-    fn handle_set_drag_enabled(&self, device: InputDevice, enabled: bool) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_drag_enabled(&self.state, enabled);
-        Ok(())
-    }
-
-    fn handle_set_natural_scrolling_enabled(
-        &self,
-        device: InputDevice,
-        enabled: bool,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_natural_scrolling_enabled(&self.state, enabled);
-        Ok(())
-    }
-
-    fn handle_set_drag_lock_enabled(
-        &self,
-        device: InputDevice,
-        enabled: bool,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_drag_lock_enabled(&self.state, enabled);
-        Ok(())
-    }
-
-    fn handle_set_transform_matrix(
-        &self,
-        device: InputDevice,
-        matrix: [[f64; 2]; 2],
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_transform_matrix(&self.state, matrix);
-        Ok(())
-    }
-
-    fn handle_set_calibration_matrix(
-        &self,
-        device: InputDevice,
-        matrix: [[f32; 3]; 2],
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_calibration_matrix(&self.state, matrix);
-        Ok(())
-    }
-
-    fn handle_set_click_method(
-        &self,
-        device: InputDevice,
-        click_method: ClickMethod,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        let method = match click_method {
-            CLICK_METHOD_NONE => InputDeviceClickMethod::None,
-            CLICK_METHOD_BUTTON_AREAS => InputDeviceClickMethod::ButtonAreas,
-            CLICK_METHOD_CLICKFINGER => InputDeviceClickMethod::Clickfinger,
-            _ => return Err(CphError::UnknownClickMethod(click_method)),
-        };
-        dev.set_click_method(&self.state, method);
-        Ok(())
-    }
-
-    fn handle_set_middle_button_emulation_enabled(
-        &self,
-        device: InputDevice,
-        enabled: bool,
-    ) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        dev.set_middle_button_emulation_enabled(&self.state, enabled);
-        Ok(())
-    }
-
     fn handle_set_ei_socket_enabled(&self, enabled: bool) {
         self.state.set_ei_socket_enabled(enabled);
     }
@@ -1016,31 +859,6 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_get_device_name(&self, device: InputDevice) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        let name = dev.device.name();
-        self.respond(Response::GetDeviceName {
-            name: name.to_string(),
-        });
-        Ok(())
-    }
-
-    fn handle_get_input_device_syspath(&self, device: InputDevice) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        self.respond(Response::GetInputDeviceSyspath {
-            syspath: dev.syspath.clone().unwrap_or_default(),
-        });
-        Ok(())
-    }
-
-    fn handle_get_input_device_devnode(&self, device: InputDevice) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        self.respond(Response::GetInputDeviceDevnode {
-            devnode: dev.devnode.clone().unwrap_or_default(),
-        });
-        Ok(())
-    }
-
     fn handle_move_to_output(
         &self,
         workspace: WorkspaceSource,
@@ -1145,33 +963,6 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_has_capability(&self, device: InputDevice, cap: Capability) -> Result<(), CphError> {
-        let dev = self.get_device_handler_data(device)?;
-        let mut is_unknown = false;
-        let has_cap = 'has_cap: {
-            let cap = match cap {
-                CAP_KEYBOARD => InputDeviceCapability::Keyboard,
-                CAP_POINTER => InputDeviceCapability::Pointer,
-                CAP_TOUCH => InputDeviceCapability::Touch,
-                CAP_TABLET_TOOL => InputDeviceCapability::TabletTool,
-                CAP_TABLET_PAD => InputDeviceCapability::TabletPad,
-                CAP_GESTURE => InputDeviceCapability::Gesture,
-                CAP_SWITCH => InputDeviceCapability::Switch,
-                _ => {
-                    is_unknown = true;
-                    break 'has_cap false;
-                }
-            };
-            dev.device.has_capability(cap)
-        };
-        self.respond(Response::HasCapability { has: has_cap });
-        if is_unknown {
-            Err(CphError::UnknownCapability(cap))
-        } else {
-            Ok(())
-        }
-    }
-
     fn handle_get_seat_mono(&self, seat: Seat) -> Result<(), CphError> {
         let seat = self.get_seat(seat)?;
         self.respond(Response::GetMono {
@@ -1316,30 +1107,6 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_get_input_devices(&self, seat: Option<Seat>) {
-        let id = seat.map(|s| SeatId::from_raw(s.0 as _));
-        let matches = |dhd: &DeviceHandlerData| {
-            let id = match id {
-                Some(id) => id,
-                _ => return true,
-            };
-            if let Some(seat) = dhd.seat.get() {
-                return seat.id() == id;
-            }
-            false
-        };
-        let mut res = vec![];
-        {
-            let devs = self.state.input_device_handlers.borrow_mut();
-            for dev in devs.values() {
-                if matches(&dev.data) {
-                    res.push(InputDevice(dev.id.raw() as _));
-                }
-            }
-        }
-        self.respond(Response::GetInputDevices { devices: res });
-    }
-
     fn handle_get_seats(&self) {
         let seats = {
             let seats = self.state.globals.seats.lock();
@@ -1379,12 +1146,6 @@ impl ConfigProxyHandler {
         self.state.clean_logs_older_than.set(Some(time));
     }
 
-    fn handle_grab(&self, kb: InputDevice, grab: bool) -> Result<(), CphError> {
-        let kb = self.get_kb(kb)?;
-        kb.grab(grab);
-        Ok(())
-    }
-
     fn handle_create_seat_split(&self, seat: Seat, axis: Axis) -> Result<(), CphError> {
         let seat = self.get_seat(seat)?;
         seat.create_split(axis.into());
diff --git a/src/config/handler/input_devices.rs b/src/config/handler/input_devices.rs
new file mode 100644
index 00000000..23dd126c
--- /dev/null
+++ b/src/config/handler/input_devices.rs
@@ -0,0 +1,276 @@
+use super::*;
+
+impl ConfigProxyHandler {
+    pub(super) fn handle_set_device_keymap(
+        &self,
+        device: InputDevice,
+        keymap: Keymap,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        let map = if keymap.is_invalid() {
+            None
+        } else {
+            Some(self.get_keymap(keymap)?)
+        };
+        dev.set_keymap(&self.state, map);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_input_device_connector(
+        &self,
+        input_device: InputDevice,
+        connector: Connector,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(input_device)?;
+        let output = self.get_output_node(connector)?;
+        dev.set_output(&self.state, Some(&output.global));
+        Ok(())
+    }
+
+    pub(super) fn handle_remove_input_mapping(
+        &self,
+        input_device: InputDevice,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(input_device)?;
+        dev.set_output(&self.state, None);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_seat(
+        &self,
+        device: InputDevice,
+        seat: Seat,
+    ) -> Result<(), CphError> {
+        let seat = if seat.is_invalid() {
+            None
+        } else {
+            Some(self.get_seat(seat)?)
+        };
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_seat(&self.state, seat);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_left_handed(
+        &self,
+        device: InputDevice,
+        left_handed: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_left_handed(&self.state, left_handed);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_accel_profile(
+        &self,
+        device: InputDevice,
+        accel_profile: AccelProfile,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        let profile = match accel_profile {
+            ACCEL_PROFILE_FLAT => InputDeviceAccelProfile::Flat,
+            ACCEL_PROFILE_ADAPTIVE => InputDeviceAccelProfile::Adaptive,
+            _ => return Err(CphError::UnknownAccelProfile(accel_profile)),
+        };
+        dev.set_accel_profile(&self.state, profile);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_accel_speed(
+        &self,
+        device: InputDevice,
+        speed: f64,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_accel_speed(&self.state, speed);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_px_per_wheel_scroll(
+        &self,
+        device: InputDevice,
+        px: f64,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_px_per_scroll_wheel(&self.state, px);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_tap_enabled(
+        &self,
+        device: InputDevice,
+        enabled: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_tap_enabled(&self.state, enabled);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_drag_enabled(
+        &self,
+        device: InputDevice,
+        enabled: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_drag_enabled(&self.state, enabled);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_natural_scrolling_enabled(
+        &self,
+        device: InputDevice,
+        enabled: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_natural_scrolling_enabled(&self.state, enabled);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_drag_lock_enabled(
+        &self,
+        device: InputDevice,
+        enabled: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_drag_lock_enabled(&self.state, enabled);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_transform_matrix(
+        &self,
+        device: InputDevice,
+        matrix: [[f64; 2]; 2],
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_transform_matrix(&self.state, matrix);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_calibration_matrix(
+        &self,
+        device: InputDevice,
+        matrix: [[f32; 3]; 2],
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_calibration_matrix(&self.state, matrix);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_click_method(
+        &self,
+        device: InputDevice,
+        click_method: ClickMethod,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        let method = match click_method {
+            CLICK_METHOD_NONE => InputDeviceClickMethod::None,
+            CLICK_METHOD_BUTTON_AREAS => InputDeviceClickMethod::ButtonAreas,
+            CLICK_METHOD_CLICKFINGER => InputDeviceClickMethod::Clickfinger,
+            _ => return Err(CphError::UnknownClickMethod(click_method)),
+        };
+        dev.set_click_method(&self.state, method);
+        Ok(())
+    }
+
+    pub(super) fn handle_set_middle_button_emulation_enabled(
+        &self,
+        device: InputDevice,
+        enabled: bool,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        dev.set_middle_button_emulation_enabled(&self.state, enabled);
+        Ok(())
+    }
+
+    pub(super) fn handle_get_device_name(&self, device: InputDevice) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        let name = dev.device.name();
+        self.respond(Response::GetDeviceName {
+            name: name.to_string(),
+        });
+        Ok(())
+    }
+
+    pub(super) fn handle_get_input_device_syspath(
+        &self,
+        device: InputDevice,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        self.respond(Response::GetInputDeviceSyspath {
+            syspath: dev.syspath.clone().unwrap_or_default(),
+        });
+        Ok(())
+    }
+
+    pub(super) fn handle_get_input_device_devnode(
+        &self,
+        device: InputDevice,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        self.respond(Response::GetInputDeviceDevnode {
+            devnode: dev.devnode.clone().unwrap_or_default(),
+        });
+        Ok(())
+    }
+
+    pub(super) fn handle_has_capability(
+        &self,
+        device: InputDevice,
+        cap: Capability,
+    ) -> Result<(), CphError> {
+        let dev = self.get_device_handler_data(device)?;
+        let mut is_unknown = false;
+        let has_cap = 'has_cap: {
+            let cap = match cap {
+                CAP_KEYBOARD => InputDeviceCapability::Keyboard,
+                CAP_POINTER => InputDeviceCapability::Pointer,
+                CAP_TOUCH => InputDeviceCapability::Touch,
+                CAP_TABLET_TOOL => InputDeviceCapability::TabletTool,
+                CAP_TABLET_PAD => InputDeviceCapability::TabletPad,
+                CAP_GESTURE => InputDeviceCapability::Gesture,
+                CAP_SWITCH => InputDeviceCapability::Switch,
+                _ => {
+                    is_unknown = true;
+                    break 'has_cap false;
+                }
+            };
+            dev.device.has_capability(cap)
+        };
+        self.respond(Response::HasCapability { has: has_cap });
+        if is_unknown {
+            Err(CphError::UnknownCapability(cap))
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(super) fn handle_get_input_devices(&self, seat: Option<Seat>) {
+        let id = seat.map(|s| SeatId::from_raw(s.0 as _));
+        let matches = |dhd: &DeviceHandlerData| {
+            let id = match id {
+                Some(id) => id,
+                _ => return true,
+            };
+            if let Some(seat) = dhd.seat.get() {
+                return seat.id() == id;
+            }
+            false
+        };
+        let mut res = vec![];
+        {
+            let devs = self.state.input_device_handlers.borrow_mut();
+            for dev in devs.values() {
+                if matches(&dev.data) {
+                    res.push(InputDevice(dev.id.raw() as _));
+                }
+            }
+        }
+        self.respond(Response::GetInputDevices { devices: res });
+    }
+
+    pub(super) fn handle_grab(&self, kb: InputDevice, grab: bool) -> Result<(), CphError> {
+        let kb = self.get_kb(kb)?;
+        kb.grab(grab);
+        Ok(())
+    }
+}