monolith

public

Star0

Fork 0

Watch0

135 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `9944e8618a62`

tarball

atagen <boss@atagen.co>2026-10-18 10:18 UTC

8 files changed+422-2

input: configure libinput devices from the config

Touchpads came up with libinput defaults, which leave tap to click and natural scrolling off, and mouse acceleration could not be flattened. Unset options go back to the device default on reload, so dropping a line from the config undoes it without a replug.

Modified file: Cargo.lock+1

@@ -544,6 +544,7 @@ name = "monolith"

544544 version = "0.0.0"

545545 dependencies = [

546546 "calloop-wayland-source",

547+ "input",

547548 "libc",

548549 "monolith-config",

549550 "monolith-ipc",

Modified file: crates/config/default.toml+27 additions@@ -54,6 +54,33 @@ layout = ""
 repeat_delay = 200
 repeat_rate = 25
 
+# libinput settings, bare metal only. Anything left out keeps the device's
+# own default, and options a device lacks are skipped. Touchpads are devices
+# that can tap, every other pointing device takes [input.pointer].
+#
+# accel_profile    flat, adaptive or custom
+# accel_speed      -1 to 1
+# accel_points     the custom profile's curve, pointer speed at 0, accel_step,
+# accel_step       2 * accel_step and so on, in device units per millisecond
+# natural_scroll, left_handed, tap, tap_drag, tap_drag_lock, dwt (disable
+# while typing), middle_emulation   true or false
+# scroll_method    none, two-finger, edge or on-button-down
+# scroll_button    the evdev code of the on-button-down button, 274 for middle
+# click_method     button-areas or clickfinger
+# scroll_factor    multiplies scroll distance, applied by monolith
+[input.pointer]
+
+[input.touchpad]
+# tap = true
+# natural_scroll = true
+
+# Per device, by the name `libinput list-devices` shows, over its kind's settings.
+# Later entries win.
+# [[input.device]]
+# name = "Logitech G502"
+# accel_profile = "flat"
+# accel_speed = -0.3
+
 # Each value is a command in word form, or an argv-style list.
 [binds]
 "Mod+Return" = "spawn beer"

Modified file: crates/config/src/lib.rs+192 additions@@ -16,6 +16,7 @@ pub struct Config {
     pub decoration: Decoration,
     pub animation: Animation,
     pub keyboard: Keyboard,
+    pub input: Input,
     pub binds: Vec<Bind>,
     pub rules: Vec<Rule>,
     pub startup: Vec<Vec<String>>,
@@ -260,6 +261,122 @@ impl Default for Keyboard {
     }
 }
 
+/// libinput settings for pointing devices. Unset options keep libinput's
+/// default for the device.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Input {
+    pub pointer: DeviceSettings,
+    /// Devices that can tap, which libinput only offers on touchpads.
+    pub touchpad: DeviceSettings,
+    /// Overrides for devices by name, later entries winning.
+    pub device: Vec<NamedDevice>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NamedDevice {
+    pub name: String,
+    pub settings: DeviceSettings,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct DeviceSettings {
+    pub accel_profile: Option<AccelProfile>,
+    pub accel_speed: Option<f64>,
+    /// The custom profile's curve, pointer speed sampled every `accel_step`
+    /// device units per millisecond.
+    pub accel_points: Option<Vec<f64>>,
+    pub accel_step: Option<f64>,
+    pub natural_scroll: Option<bool>,
+    pub left_handed: Option<bool>,
+    pub tap: Option<bool>,
+    pub tap_drag: Option<bool>,
+    pub tap_drag_lock: Option<bool>,
+    pub dwt: Option<bool>,
+    pub middle_emulation: Option<bool>,
+    pub scroll_method: Option<ScrollMethod>,
+    pub scroll_button: Option<u32>,
+    pub click_method: Option<ClickMethod>,
+    /// Applied by the compositor, libinput has no such setting.
+    pub scroll_factor: Option<f64>,
+}
+
+impl DeviceSettings {
+    /// `self` with every option `over` sets replaced.
+    pub fn overlay(&self, over: &Self) -> Self {
+        Self {
+            accel_profile: over.accel_profile.or(self.accel_profile),
+            accel_speed: over.accel_speed.or(self.accel_speed),
+            accel_points: over
+                .accel_points
+                .clone()
+                .or_else(|| self.accel_points.clone()),
+            accel_step: over.accel_step.or(self.accel_step),
+            natural_scroll: over.natural_scroll.or(self.natural_scroll),
+            left_handed: over.left_handed.or(self.left_handed),
+            tap: over.tap.or(self.tap),
+            tap_drag: over.tap_drag.or(self.tap_drag),
+            tap_drag_lock: over.tap_drag_lock.or(self.tap_drag_lock),
+            dwt: over.dwt.or(self.dwt),
+            middle_emulation: over.middle_emulation.or(self.middle_emulation),
+            scroll_method: over.scroll_method.or(self.scroll_method),
+            scroll_button: over.scroll_button.or(self.scroll_button),
+            click_method: over.click_method.or(self.click_method),
+            scroll_factor: over.scroll_factor.or(self.scroll_factor),
+        }
+    }
+
+    fn validate(&mut self, name: &str, w: &mut Vec<String>) {
+        if let Some(s) = self.accel_speed
+            && !(-1.0..=1.0).contains(&s)
+        {
+            w.push(format!(
+                "{name}.accel_speed: {s} is outside -1 to 1, ignored"
+            ));
+            self.accel_speed = None;
+        }
+        if let Some(f) = self.scroll_factor
+            && !(f.is_finite() && f >= 0.0)
+        {
+            w.push(format!(
+                "{name}.scroll_factor: {f} must be zero or more, ignored"
+            ));
+            self.scroll_factor = None;
+        }
+        if self.accel_points.is_some() != self.accel_step.is_some() {
+            w.push(format!(
+                "{name}: accel_points needs accel_step and the other way round, both ignored"
+            ));
+            self.accel_points = None;
+            self.accel_step = None;
+        }
+    }
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum AccelProfile {
+    Flat,
+    Adaptive,
+    Custom,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum ScrollMethod {
+    None,
+    TwoFinger,
+    Edge,
+    OnButtonDown,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum ClickMethod {
+    ButtonAreas,
+    Clickfinger,
+}
+
 #[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum Modifier {
@@ -394,6 +511,7 @@ impl Config {
         let w = &mut warnings;
         let general: General = section("general", table.remove("general"), w);
         let keyboard = section("keyboard", table.remove("keyboard"), w);
+        let input = input(table.remove("input"), w);
         let animation = section("animation", table.remove("animation"), w);
         let decoration = section("decoration", table.remove("decoration"), w);
         let output: Outputs = section("output", table.remove("output"), w);
@@ -452,6 +570,7 @@ impl Config {
             decoration,
             output,
             keyboard,
+            input,
             binds,
             rules,
             startup,
@@ -518,6 +637,45 @@ fn entry<T: DeserializeOwned>(name: &str, value: toml::Value, w: &mut Vec<String
         .ok()
 }
 
+fn input(value: Option<toml::Value>, w: &mut Vec<String>) -> Input {
+    let mut table = match value {
+        None => toml::Table::new(),
+        Some(toml::Value::Table(t)) => t,
+        Some(_) => {
+            w.push("[input] is not a table, using the defaults".into());
+            toml::Table::new()
+        }
+    };
+    let mut input = Input {
+        pointer: section("input.pointer", table.remove("pointer"), w),
+        touchpad: section("input.touchpad", table.remove("touchpad"), w),
+        device: Vec::new(),
+    };
+    for (i, mut entry) in items::<toml::Table>("input.device", table.remove("device"), w)
+        .into_iter()
+        .enumerate()
+    {
+        let name = format!("input.device[{i}]");
+        let Some(toml::Value::String(device)) = entry.remove("name") else {
+            w.push(format!("{name}: no name, left out"));
+            continue;
+        };
+        input.device.push(NamedDevice {
+            name: device,
+            settings: section(&name, Some(toml::Value::Table(entry)), w),
+        });
+    }
+    for key in table.keys() {
+        w.push(format!("input.{key}: unknown option, ignored"));
+    }
+    input.pointer.validate("input.pointer", w);
+    input.touchpad.validate("input.touchpad", w);
+    for (i, d) in input.device.iter_mut().enumerate() {
+        d.settings.validate(&format!("input.device[{i}]"), w);
+    }
+    input
+}
+
 fn connector_like(name: &str) -> bool {
     name.rsplit_once('-').is_some_and(|(kind, n)| {
         !kind.is_empty() && !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())
@@ -600,6 +758,7 @@ mod tests {
         assert_eq!(c.decoration, Decoration::default());
         assert_eq!(c.animation, Animation::default());
         assert_eq!(c.keyboard, Keyboard::default());
+        assert_eq!(c.input, Input::default());
         assert!(c.binds.len() > 40);
     }
 
@@ -641,4 +800,37 @@ mod tests {
         assert!(!c.output.named.contains_key("DP-2"));
         assert_eq!(loaded.warnings.len(), 7, "{:#?}", loaded.warnings);
     }
+
+    #[test]
+    fn a_bad_device_option_costs_only_itself() {
+        let loaded = Config::parse(
+            r#"
+            [input.pointer]
+            accel_speed = 2.0
+            scroll_method = "two-finger"
+            [[input.device]]
+            name = "Mouse"
+            accel_profile = "flat"
+            [[input.device]]
+            name = "Typo"
+            tapp = true
+            [[input.device]]
+            name = "Half"
+            accel_points = [0.0, 1.0]
+            "#,
+        )
+        .unwrap();
+        let input = loaded.config.input;
+        assert_eq!(input.pointer.accel_speed, None);
+        assert_eq!(input.pointer.scroll_method, Some(ScrollMethod::TwoFinger));
+        let names: Vec<_> = input.device.iter().map(|d| d.name.as_str()).collect();
+        assert_eq!(names, ["Mouse", "Typo", "Half"]);
+        assert_eq!(
+            input.device[0].settings.accel_profile,
+            Some(AccelProfile::Flat)
+        );
+        assert_eq!(input.device[1].settings, DeviceSettings::default());
+        assert_eq!(input.device[2].settings.accel_points, None);
+        assert_eq!(loaded.warnings.len(), 3, "{:#?}", loaded.warnings);
+    }
 }

Modified file: crates/monolith/Cargo.toml+3 additions@@ -22,6 +22,9 @@ monolith-planner.workspace = true
 monolith-protocols.workspace = true
 monolith-render-vk.workspace = true
 libc = "0.2"
+# Raises the libinput bindings smithay uses. 1.23 brings custom acceleration,
+# and below 1.27 reading a sticky drag lock default panics.
+input = { version = "0.10", default-features = false, features = ["libinput_1_27"] }
 pound = "0.5"
 profiling = "1"
 serde_json.workspace = true

Modified file: crates/monolith/src/commands.rs+4 additions@@ -217,6 +217,7 @@ impl State {
         let loaded = Config::load(self.settings.path.as_deref()).map_err(|e| e.to_string())?;
         let config = warn_config(loaded);
         let keyboard_changed = config.keyboard != self.settings.config.keyboard;
+        let input_changed = config.input != self.settings.config.input;
         self.settings.binds = Binds::new(&config);
         self.wm.layout.gaps = crate::state::gaps(&config);
         self.wm.anim.settings = config.animation.clone();
@@ -224,6 +225,9 @@ impl State {
         if keyboard_changed {
             self.reconfigure_keyboard();
         }
+        if input_changed && let Some(drm) = self.backend.drm_mut() {
+            drm.devices.reconfigure(&self.settings.config.input);
+        }
         crate::drm::reconfigure_outputs(self);
         tracing::info!("config reloaded");
         Ok(())

Added file: crates/monolith/src/devices.rs+173 additions@@ -0,0 +1,173 @@
+//! libinput device settings from `[input]`, on bare metal only. A nested
+//! compositor's devices belong to its host.
+
+use monolith_config::{AccelProfile, ClickMethod, DeviceSettings, Input, ScrollMethod};
+use smithay::reexports::input::{
+    self, AccelConfig, AccelType, Device, DeviceCapability, DeviceConfigResult, DragLockState,
+};
+
+#[derive(Default)]
+pub struct Devices(Vec<(Device, f64)>);
+
+impl Devices {
+    pub fn add(&mut self, mut device: Device, config: &Input) {
+        let factor = configure(&mut device, config);
+        self.0.push((device, factor));
+    }
+
+    pub fn remove(&mut self, device: &Device) {
+        self.0.retain(|(d, _)| d != device);
+    }
+
+    pub fn reconfigure(&mut self, config: &Input) {
+        for (device, factor) in &mut self.0 {
+            *factor = configure(device, config);
+        }
+    }
+
+    pub fn scroll_factor(&self, device: &Device) -> f64 {
+        self.0
+            .iter()
+            .find(|(d, _)| d == device)
+            .map_or(1.0, |&(_, f)| f)
+    }
+}
+
+fn settings(device: &Device, config: &Input) -> DeviceSettings {
+    let base = if device.config_tap_finger_count() > 0 {
+        config.touchpad.clone()
+    } else if device.has_capability(DeviceCapability::Pointer) {
+        config.pointer.clone()
+    } else {
+        DeviceSettings::default()
+    };
+    let name = device.name();
+    config
+        .device
+        .iter()
+        .filter(|d| d.name == name)
+        .fold(base, |s, d| s.overlay(&d.settings))
+}
+
+/// Unset options go back to the device's default rather than being left
+/// alone, so removing one from the config undoes it on reload.
+fn configure(device: &mut Device, config: &Input) -> f64 {
+    let s = settings(device, config);
+    let name = device.name().into_owned();
+    let check = |what: &str, result: DeviceConfigResult| {
+        if let Err(e) = result {
+            tracing::warn!("input {name:?}: libinput refused {what}: {e:?}");
+        }
+    };
+
+    if device.config_accel_is_available() {
+        let profile = s.accel_profile.map(|p| match p {
+            AccelProfile::Flat => input::AccelProfile::Flat,
+            AccelProfile::Adaptive => input::AccelProfile::Adaptive,
+            AccelProfile::Custom => input::AccelProfile::Custom,
+        });
+        let curve = s.accel_points.as_deref().zip(s.accel_step);
+        match (profile.or(device.config_accel_default_profile()), curve) {
+            (Some(input::AccelProfile::Custom), Some((points, step))) => {
+                if let Some(accel) = AccelConfig::new(input::AccelProfile::Custom) {
+                    check(
+                        "accel_points",
+                        accel.set_points(AccelType::Motion, step, points),
+                    );
+                    check("accel_profile", device.config_accel_apply(accel));
+                }
+            }
+            (Some(p), _) if device.config_accel_profiles().contains(&p) => {
+                check("accel_profile", device.config_accel_set_profile(p));
+            }
+            (Some(p), _) => tracing::warn!("input {name:?}: no {p:?} accel profile"),
+            (None, _) => {}
+        }
+        let speed = s
+            .accel_speed
+            .unwrap_or_else(|| device.config_accel_default_speed());
+        check("accel_speed", device.config_accel_set_speed(speed));
+    }
+    if device.config_scroll_has_natural_scroll() {
+        let on = s
+            .natural_scroll
+            .unwrap_or_else(|| device.config_scroll_default_natural_scroll_enabled());
+        check(
+            "natural_scroll",
+            device.config_scroll_set_natural_scroll_enabled(on),
+        );
+    }
+    if device.config_left_handed_is_available() {
+        let on = s
+            .left_handed
+            .unwrap_or_else(|| device.config_left_handed_default());
+        check("left_handed", device.config_left_handed_set(on));
+    }
+    if device.config_tap_finger_count() > 0 {
+        let on = s.tap.unwrap_or_else(|| device.config_tap_default_enabled());
+        check("tap", device.config_tap_set_enabled(on));
+        let on = s
+            .tap_drag
+            .unwrap_or_else(|| device.config_tap_default_drag_enabled());
+        check("tap_drag", device.config_tap_set_drag_enabled(on));
+        let lock = match s.tap_drag_lock {
+            Some(true) => DragLockState::EnabledTimeout,
+            Some(false) => DragLockState::Disabled,
+            None => device.config_tap_default_drag_lock_enabled(),
+        };
+        check(
+            "tap_drag_lock",
+            device.config_tap_set_drag_lock_enabled(lock),
+        );
+    }
+    if device.config_dwt_is_available() {
+        let on = s.dwt.unwrap_or_else(|| device.config_dwt_default_enabled());
+        check("dwt", device.config_dwt_set_enabled(on));
+    }
+    if device.config_middle_emulation_is_available() {
+        let on = s
+            .middle_emulation
+            .unwrap_or_else(|| device.config_middle_emulation_default_enabled());
+        check(
+            "middle_emulation",
+            device.config_middle_emulation_set_enabled(on),
+        );
+    }
+    let methods = device.config_scroll_methods();
+    if !methods.is_empty() {
+        let method = s.scroll_method.map(|m| match m {
+            ScrollMethod::None => input::ScrollMethod::NoScroll,
+            ScrollMethod::TwoFinger => input::ScrollMethod::TwoFinger,
+            ScrollMethod::Edge => input::ScrollMethod::Edge,
+            ScrollMethod::OnButtonDown => input::ScrollMethod::OnButtonDown,
+        });
+        match method.or(device.config_scroll_default_method()) {
+            Some(m) if m == input::ScrollMethod::NoScroll || methods.contains(&m) => {
+                check("scroll_method", device.config_scroll_set_method(m));
+            }
+            Some(m) => tracing::warn!("input {name:?}: no {m:?} scroll method"),
+            None => {}
+        }
+    }
+    if methods.contains(&input::ScrollMethod::OnButtonDown) {
+        let button = s
+            .scroll_button
+            .unwrap_or_else(|| device.config_scroll_default_button());
+        check("scroll_button", device.config_scroll_set_button(button));
+    }
+    let methods = device.config_click_methods();
+    if !methods.is_empty() {
+        let method = s.click_method.map(|m| match m {
+            ClickMethod::ButtonAreas => input::ClickMethod::ButtonAreas,
+            ClickMethod::Clickfinger => input::ClickMethod::Clickfinger,
+        });
+        match method.or(device.config_click_default_method()) {
+            Some(m) if methods.contains(&m) => {
+                check("click_method", device.config_click_set_method(m));
+            }
+            Some(m) => tracing::warn!("input {name:?}: no {m:?} click method"),
+            None => {}
+        }
+    }
+    s.scroll_factor.unwrap_or(1.0)
+}

Modified file: crates/monolith/src/drm.rs+21 additions−2 deletions@@ -3,6 +3,7 @@
 //! each rendered when its own vblank lands.
 
 use crate::backend::Backend;
+use crate::devices::Devices;
 use crate::scene::Draw;
 use crate::state::Services;
 use crate::state::{State, now_ns};
@@ -63,6 +64,7 @@ pub struct Drm {
     nvidia: bool,
     frame_flags: FrameFlags,
     surfaces: HashMap<crtc::Handle, Surface>,
+    pub devices: Devices,
 }
 
 struct Surface {
@@ -227,6 +229,7 @@ pub fn init(
             FrameFlags::DEFAULT
         },
         surfaces: HashMap::new(),
+        devices: Devices::default(),
     }));
     scan(state);
     Ok(())
@@ -883,15 +886,21 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.pointer_frame();
         }
         InputEvent::PointerAxis { event } => {
+            let factor = state
+                .backend
+                .drm()
+                .map_or(1.0, |d| d.devices.scroll_factor(&event.device()));
             let source = event.source();
             let mut frame = AxisFrame::new(event.time()).source(source);
             for axis in [Axis::Horizontal, Axis::Vertical] {
-                if let Some(v120) = event.amount_v120(axis) {
+                let v120 = event.amount_v120(axis).map(|v| v * factor);
+                if let Some(v120) = v120 {
                     frame = frame.v120(axis, v120 as i32);
                 }
                 let amount = event
                     .amount(axis)
-                    .or_else(|| event.amount_v120(axis).map(|v| v * 15.0 / 120.0));
+                    .map(|a| a * factor)
+                    .or_else(|| v120.map(|v| v * 15.0 / 120.0));
                 match amount {
                     Some(a) if a != 0.0 => frame = frame.value(axis, a),
                     Some(_) if source == AxisSource::Finger => frame = frame.stop(axis),
@@ -901,6 +910,16 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.pointer_axis(frame);
             state.pointer_frame();
         }
+        InputEvent::DeviceAdded { device } => {
+            if let Some(drm) = state.backend.drm_mut() {
+                drm.devices.add(device, &state.settings.config.input);
+            }
+        }
+        InputEvent::DeviceRemoved { device } => {
+            if let Some(drm) = state.backend.drm_mut() {
+                drm.devices.remove(&device);
+            }
+        }
         _ => {}
     }
 }

Modified file: crates/monolith/src/main.rs+1

@@ -5,6 +5,7 @@ mod capture;

55 mod commands;

66 mod commit;

77 mod cursor;

8+mod devices;

89 mod drm;

910 mod focus;

1011 mod frame;

monolith

Commit 9944e8618a62

Commit `9944e8618a62`