Something went wrong. Try again.
window manager for the river wayland compositor
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646// SPDX-FileCopyrightText: © 2026 mtmn//// SPDX-License-Identifier: BSD-3-Clause// Analyzer does not resolve method-call syntax to free functions.// Module type aliases use PascalCase per Zig convention.// zwanzig-disable: identifier-style, unused-decl
const Input = @This();
const std = @import("std");const river = @import("wayland").client.river;const xkb = @import("xkbcommon");
const PointerBinding = @import("PointerBinding.zig");const Rule = @import("Rule.zig");
const gpa = std.heap.c_allocator;const log = std.log.scoped(.laguna);
/// One river_input_device_v1. river sends input_device as the first event,/// exactly once, on every libinput device and xkb keyboard object, and the/// device it names was already announced on this connection, so those/// objects attach here when that event arrives.pub const Device = struct { owner: *Input, input: *river.InputDeviceV1, libinput: ?*river.LibinputDeviceV1 = null, keyboard: ?*river.XkbKeyboardV1 = null, kind: ?river.InputDeviceV1.Type = null, name: ?[]const u8 = null,};
pub const StoredConfig = struct { pattern: []const u8, category: ?[]const u8, setting: []const u8, value: ?[]const u8,};
input_manager: ?*river.InputManagerV1 = null,libinput_config: ?*river.LibinputConfigV1 = null,xkb_config: ?*river.XkbConfigV1 = null,devices: std.ArrayListUnmanaged(*Device) = .empty,keymap: ?*river.XkbKeymapV1 = null,repeat_rate: ?i32 = null,repeat_delay: ?i32 = null,stored_configs: std.ArrayListUnmanaged(StoredConfig) = .empty,
pub fn deinit(input: *Input) void { for (input.devices.items) |device| { destroyDevice(device); gpa.destroy(device); } input.clearStoredConfigs(); input.stored_configs.deinit(gpa); if (input.keymap) |keymap| keymap.destroy(); if (input.input_manager) |object| object.destroy(); if (input.libinput_config) |object| object.destroy(); if (input.xkb_config) |object| object.destroy(); input.input_manager = null; input.libinput_config = null; input.xkb_config = null; input.keymap = null; input.devices.deinit(gpa);}
pub fn setGlobals( input: *Input, input_manager: ?*river.InputManagerV1, libinput_config: ?*river.LibinputConfigV1, xkb_config: ?*river.XkbConfigV1,) void { input.input_manager = input_manager; input.libinput_config = libinput_config; input.xkb_config = xkb_config; if (input_manager) |object| object.setListener(*Input, handleManagerEvent, input); if (libinput_config) |object| object.setListener(*Input, handleConfigEvent, input); if (xkb_config) |object| object.setListener(*Input, handleXkbConfigEvent, input);}
fn handleManagerEvent( _: *river.InputManagerV1, event: river.InputManagerV1.Event, input: *Input,) void { switch (event) { .finished => {}, .input_device => |created| input.addInputDevice(created.id), }}
fn handleConfigEvent( _: *river.LibinputConfigV1, event: river.LibinputConfigV1.Event, input: *Input,) void { switch (event) { .finished => {}, .libinput_device => |created| input.addLibinputDevice(created.id), }}
fn handleXkbConfigEvent(_: *river.XkbConfigV1, event: river.XkbConfigV1.Event, input: *Input) void { switch (event) { .finished => {}, .xkb_keyboard => |created| input.addKeyboard(created.id), }}
fn addInputDevice(input: *Input, object: *river.InputDeviceV1) void { const device = gpa.create(Device) catch std.process.fatal("out of memory", .{}); device.* = .{ .owner = input, .input = object }; input.devices.append(gpa, device) catch std.process.fatal("out of memory", .{}); object.setListener(*Device, handleInputEvent, device);}
fn addLibinputDevice(input: *Input, object: *river.LibinputDeviceV1) void { object.setListener(*Input, handleLibinputEvent, input);}
fn addKeyboard(input: *Input, object: *river.XkbKeyboardV1) void { object.setListener(*Input, handleKeyboardEvent, input); if (input.keymap) |keymap| object.setKeymap(keymap);}
fn findDevice(input: *Input, object: ?*river.InputDeviceV1) ?*Device { for (input.devices.items) |device| { if (device.input == object) return device; } return null;}
fn handleInputEvent( _: *river.InputDeviceV1, event: river.InputDeviceV1.Event, device: *Device,) void { switch (event) { .removed => device.owner.removeDevice(device), .type => |typed| { device.kind = typed.type; // Keyboards arriving after set-repeat still get the stored rate. if (typed.type == .keyboard) { if (device.owner.repeat_rate) |rate| { if (device.owner.repeat_delay) |delay| device.input.setRepeatInfo(rate, delay); } } }, .name => |named| { if (device.name) |old| gpa.free(old); device.name = gpa.dupe(u8, std.mem.sliceTo(named.name, 0)) catch |err| blk: { log.warn("failed to store input device name: {s}", .{@errorName(err)}); break :blk null; }; if (device.name) |name| log.info("input device: {s}", .{name}); }, .done => {}, }}
fn handleLibinputEvent( object: *river.LibinputDeviceV1, event: river.LibinputDeviceV1.Event, input: *Input,) void { switch (event) { .input_device => |paired| { const device = input.findDevice(paired.device) orelse { log.warn("libinput device without a known input device", .{}); return; }; device.libinput = object; applyStoredConfigs(input, device); }, .removed => { for (input.devices.items) |device| { if (device.libinput == object) device.libinput = null; } object.destroy(); }, else => {}, }}
fn handleKeyboardEvent( object: *river.XkbKeyboardV1, event: river.XkbKeyboardV1.Event, input: *Input,) void { switch (event) { .input_device => |paired| { const device = input.findDevice(paired.device) orelse { log.warn("xkb keyboard without a known input device", .{}); return; }; device.keyboard = object; }, .removed => { for (input.devices.items) |device| { if (device.keyboard == object) device.keyboard = null; } object.destroy(); }, else => {}, }}
fn handleResult(_: *river.LibinputResultV1, event: river.LibinputResultV1.Event, _: ?*anyopaque) void { switch (event) { .success => {}, .unsupported => log.warn("input setting unsupported by device", .{}), .invalid => log.warn("input setting invalid for device", .{}), }}
fn removeDevice(input: *Input, device: *Device) void { for (input.devices.items, 0..) |candidate, index| { if (candidate != device) continue; _ = input.devices.swapRemove(index); break; } destroyDevice(device); gpa.destroy(device);}
/// Destroying the libinput and keyboard objects here is safe even though/// their own removed events may still arrive: libwayland drops events for/// destroyed proxies.fn destroyDevice(device: *Device) void { device.input.destroy(); if (device.libinput) |object| object.destroy(); if (device.keyboard) |object| object.destroy(); if (device.name) |name| gpa.free(name); device.libinput = null; device.keyboard = null; device.name = null;}
pub fn setRepeat(input: *Input, rate: i32, delay: i32) void { input.repeat_rate = rate; input.repeat_delay = delay; for (input.devices.items) |device| { if (device.kind != .keyboard) continue; device.input.setRepeatInfo(rate, delay); }}
/// Drop all stored input settings. Used before a config reload so removed/// settings stop applying to devices that arrive later.pub fn clearStoredConfigs(input: *Input) void { for (input.stored_configs.items) |stored| { gpa.free(stored.pattern); if (stored.category) |category| gpa.free(category); gpa.free(stored.setting); if (stored.value) |value| gpa.free(value); } input.stored_configs.clearRetainingCapacity();}
/// Remember an input setting so devices arriving later receive it when/// their libinput object pairs. Devices already present are configured by/// the input command that the config queues alongside. A setting with an/// invalid pattern is reported and not stored. Strings are duplicated. The/// input owns them until deinit.pub fn storeConfig( input: *Input, pattern: []const u8, category: ?[]const u8, setting: []const u8, value: ?[]const u8,) error{OutOfMemory}!void { Rule.validate(pattern) catch |err| { log.warn("ignoring input setting '{s}' with pattern '{s}': {s}", .{ setting, pattern, @errorName(err) }); return; }; const owned_pattern = try gpa.dupe(u8, pattern); errdefer gpa.free(owned_pattern); const owned_category = if (category) |text| try gpa.dupe(u8, text) else null; errdefer if (owned_category) |text| gpa.free(text); const owned_setting = try gpa.dupe(u8, setting); errdefer gpa.free(owned_setting); const owned_value = if (value) |text| try gpa.dupe(u8, text) else null; errdefer if (owned_value) |text| gpa.free(text); try input.stored_configs.append(gpa, .{ .pattern = owned_pattern, .category = owned_category, .setting = owned_setting, .value = owned_value, });}
/// Apply every stored input setting that matches a device whose libinput/// object just paired. storeConfig only keeps valid patterns.fn applyStoredConfigs(input: *Input, device: *Device) void { for (input.stored_configs.items) |stored| { if (!matches(device, stored.pattern, stored.category)) continue; configure(device, stored.setting, stored.value) catch |err| { const name = device.name orelse "(unnamed)"; log.warn("input setting '{s}' failed for {s}: {s}", .{ stored.setting, name, @errorName(err), }); }; }}
/// Match a device by glob over its name, with an optional category filter/// such as touchpad, pointer, keyboard or tablet. The pattern must be a/// valid glob, see Rule.validate().pub fn matches(device: *const Device, pattern: []const u8, category: ?[]const u8) bool { const name = device.name orelse return false; if (!Rule.match(name, pattern)) return false; const wanted = category orelse return true; return matchCategory(device, name, wanted);}
fn matchCategory(device: *const Device, name: []const u8, wanted: []const u8) bool { if (std.mem.eql(u8, wanted, "touchpad")) { return std.ascii.findIgnoreCase(name, "touchpad") != null; } if (std.mem.eql(u8, wanted, "pointer") or std.mem.eql(u8, wanted, "mouse")) { return device.kind == .pointer; } if (std.mem.eql(u8, wanted, "keyboard")) { return device.kind == .keyboard; } if (std.mem.eql(u8, wanted, "touch")) { return device.kind == .touch; } if (std.mem.eql(u8, wanted, "tablet")) { return device.kind == .tablet; } return false;}
pub const Error = error{ UnknownSetting, InvalidValue, NoLibinputDevice, CannotReadFile, CannotParseFile, OutOfMemory,};
/// Compile a keymap from xkb rule names and push it to all keyboards.pub fn setLayout( input: *Input, rules: ?[]const u8, model: ?[]const u8, layout: []const u8, variant: ?[]const u8, options: ?[]const u8,) Error!void { const context = xkb.Context.new(.no_flags) orelse return error.OutOfMemory; defer context.unref();
var arena = std.heap.ArenaAllocator.init(gpa); defer arena.deinit(); const allocator = arena.allocator(); const names = xkb.RuleNames{ .rules = try dupeZOptional(allocator, rules), .model = try dupeZOptional(allocator, model), .layout = try allocator.dupeSentinel(u8, layout, 0), .variant = try dupeZOptional(allocator, variant), .options = try dupeZOptional(allocator, options), }; const keymap = xkb.Keymap.newFromNames(context, &names, .no_flags) orelse { return error.InvalidValue; }; defer keymap.unref(); try input.submitKeymap(keymap);}
/// Read a keymap file and push it to all keyboards.pub fn setLayoutFile(input: *Input, path: []const u8) Error!void { const io = std.Io.Threaded.global_single_threaded.io(); const bytes = std.Io.Dir.cwd().readFileAlloc(io, path, gpa, .limited(1024 * 1024)) catch { return error.CannotReadFile; }; defer gpa.free(bytes);
const context = xkb.Context.new(.no_flags) orelse return error.OutOfMemory; defer context.unref(); const keymap = xkb.Keymap.newFromBuffer(context, bytes.ptr, bytes.len, .text_v1, .no_flags) orelse { return error.CannotParseFile; }; defer keymap.unref(); try input.submitKeymap(keymap);}
fn dupeZOptional(allocator: std.mem.Allocator, text: ?[]const u8) error{OutOfMemory}!?[*:0]const u8 { const bytes = text orelse return null; return try allocator.dupeSentinel(u8, bytes, 0);}
fn submitKeymap(input: *Input, keymap: *xkb.Keymap) Error!void { const config = input.xkb_config orelse return error.InvalidValue; const text = keymap.getAsString(.text_v1) orelse return error.OutOfMemory; defer std.c.free(text); const size = std.mem.len(text);
const file_descriptor = std.c.memfd_create( "river-keymap", std.c.MFD.CLOEXEC | std.c.MFD.ALLOW_SEALING, ); if (file_descriptor < 0) return error.OutOfMemory; errdefer _ = std.c.close(file_descriptor);
var written: usize = 0; while (written < size) { const bytes_written = std.c.write(file_descriptor, text[written..size].ptr, size - written); if (bytes_written < 0) return error.CannotReadFile; if (bytes_written == 0) return error.CannotReadFile; written += @intCast(bytes_written); } const seals: c_uint = std.c.F.SEAL_SHRINK | std.c.F.SEAL_GROW | std.c.F.SEAL_WRITE; if (std.c.fcntl(file_descriptor, std.c.F.ADD_SEALS, seals) < 0) return error.CannotReadFile;
const pending = gpa.create(PendingKeymap) catch return error.OutOfMemory; // SAFETY: The protocol object is assigned immediately after allocation. pending.* = .{ .owner = input, .file_descriptor = file_descriptor, .object = undefined }; const object = config.createKeymap(file_descriptor, .text_v1) catch { gpa.destroy(pending); return error.OutOfMemory; }; pending.object = object; object.setListener(*PendingKeymap, handleKeymapEvent, pending);}
const PendingKeymap = struct { owner: *Input, object: *river.XkbKeymapV1, file_descriptor: std.c.fd_t,};
fn handleKeymapEvent(_: *river.XkbKeymapV1, event: river.XkbKeymapV1.Event, pending: *PendingKeymap) void { defer { _ = std.c.close(pending.file_descriptor); gpa.destroy(pending); } switch (event) { .success => pending.owner.adoptKeymap(pending.object), .failure => |failure| { log.err("keymap rejected: {s}", .{failure.error_msg}); pending.object.destroy(); }, }}
fn adoptKeymap(input: *Input, object: *river.XkbKeymapV1) void { if (input.keymap) |old| old.destroy(); input.keymap = object; for (input.devices.items) |device| { const keyboard = device.keyboard orelse continue; keyboard.setKeymap(object); }}
pub fn configure(device: *Device, raw_setting: []const u8, value: ?[]const u8) Error!void { // Accept underscores alongside dashes so `click_method` and // `click-method` name the same setting. var buffer: [64]u8 = undefined; if (raw_setting.len > buffer.len) return error.UnknownSetting; for (raw_setting, 0..) |char, index| { buffer[index] = if (char == '_') '-' else char; } const setting = buffer[0..raw_setting.len]; const libinput = device.libinput orelse return error.NoLibinputDevice; if (std.mem.eql(u8, setting, "tap")) { try setResult(libinput.setTap(try parseToggle(river.LibinputDeviceV1.TapState, value))); } else if (std.mem.eql(u8, setting, "tap-button-map")) { const map: river.LibinputDeviceV1.TapButtonMap = if (equal(value, "lrm")) .lrm else if (equal(value, "lmr")) .lmr else return error.InvalidValue; try setResult(libinput.setTapButtonMap(map)); } else if (std.mem.eql(u8, setting, "drag")) { try setResult(libinput.setDrag(try parseToggle(river.LibinputDeviceV1.DragState, value))); } else if (std.mem.eql(u8, setting, "drag-lock")) { const state: river.LibinputDeviceV1.DragLockState = if (equal(value, "disabled")) .disabled else if (equal(value, "timeout")) .enabled_timeout else if (equal(value, "sticky")) .enabled_sticky else return error.InvalidValue; try setResult(libinput.setDragLock(state)); } else if (std.mem.eql(u8, setting, "three-finger-drag")) { const state: river.LibinputDeviceV1.ThreeFingerDragState = if (equal(value, "enabled")) .enabled_3fg else if (equal(value, "disabled")) .disabled else return error.InvalidValue; try setResult(libinput.setThreeFingerDrag(state)); } else if (std.mem.eql(u8, setting, "natural-scroll")) { try setResult(libinput.setNaturalScroll( try parseToggle(river.LibinputDeviceV1.NaturalScrollState, value), )); } else if (std.mem.eql(u8, setting, "left-handed")) { try setResult(libinput.setLeftHanded( try parseToggle(river.LibinputDeviceV1.LeftHandedState, value), )); } else if (std.mem.eql(u8, setting, "click-method")) { const method: river.LibinputDeviceV1.ClickMethod = if (equal(value, "none")) .none else if (equal(value, "button-areas")) .button_areas else if (equal(value, "clickfinger")) .clickfinger else return error.InvalidValue; try setResult(libinput.setClickMethod(method)); } else if (std.mem.eql(u8, setting, "clickfinger-button-map")) { const map: river.LibinputDeviceV1.ClickfingerButtonMap = if (equal(value, "lrm")) .lrm else if (equal(value, "lmr")) .lmr else return error.InvalidValue; try setResult(libinput.setClickfingerButtonMap(map)); } else if (std.mem.eql(u8, setting, "middle-emulation")) { try setResult(libinput.setMiddleEmulation( try parseToggle(river.LibinputDeviceV1.MiddleEmulationState, value), )); } else if (std.mem.eql(u8, setting, "scroll-method")) { const method: river.LibinputDeviceV1.ScrollMethod = if (equal(value, "none")) .no_scroll else if (equal(value, "two-finger")) .two_finger else if (equal(value, "edge")) .edge else if (equal(value, "button")) .on_button_down else return error.InvalidValue; try setResult(libinput.setScrollMethod(method)); } else if (std.mem.eql(u8, setting, "scroll-button")) { const text = value orelse return error.InvalidValue; const button = PointerBinding.parseButton(text) catch return error.InvalidValue; try setResult(libinput.setScrollButton(button)); } else if (std.mem.eql(u8, setting, "scroll-button-lock")) { try setResult(libinput.setScrollButtonLock( try parseToggle(river.LibinputDeviceV1.ScrollButtonLockState, value), )); } else if (std.mem.eql(u8, setting, "dwt")) { try setResult(libinput.setDwt(try parseToggle(river.LibinputDeviceV1.DwtState, value))); } else if (std.mem.eql(u8, setting, "dwtp")) { try setResult(libinput.setDwtp(try parseToggle(river.LibinputDeviceV1.DwtpState, value))); } else if (std.mem.eql(u8, setting, "send-events")) { const mode: river.LibinputDeviceV1.SendEventsModes = if (equal(value, "enabled")) .{} else if (equal(value, "disabled")) .{ .disabled = true } else if (equal(value, "disabled-on-external-mouse")) .{ .disabled_on_external_mouse = true } else return error.InvalidValue; try setResult(libinput.setSendEvents(mode)); } else if (std.mem.eql(u8, setting, "pointer-accel") or std.mem.eql(u8, setting, "accel-speed")) { const text = value orelse return error.InvalidValue; const speed = std.fmt.parseFloat(f64, text) catch return error.InvalidValue; if (!std.math.isFinite(speed) or speed < -1.0 or speed > 1.0) return error.InvalidValue; const Fn = @typeInfo(@TypeOf(river.LibinputDeviceV1.setAccelSpeed)).@"fn"; const ArrayT = @typeInfo(Fn.param_types[1] orelse return error.InvalidValue).pointer.child; var storage: [1]f64 = .{speed}; // SAFETY: All fields are assigned before the array is passed to the protocol call. var array: ArrayT = undefined; array.size = @sizeOf(f64); array.alloc = @sizeOf(f64); array.data = @ptrCast(&storage); try setResult(libinput.setAccelSpeed(&array)); } else if (std.mem.eql(u8, setting, "scroll-factor")) { const text = value orelse return error.InvalidValue; const factor = try parseScrollFactor(text); const Fn = @typeInfo(@TypeOf(river.InputDeviceV1.setScrollFactor)).@"fn"; const FixedT = Fn.param_types[1] orelse return error.InvalidValue; const fixed: FixedT = @fromBackingInt(@intCast(@as(i32, @intFromFloat(factor * 256.0)))); device.input.setScrollFactor(fixed); } else if (std.mem.eql(u8, setting, "accel-profile")) { const profile: river.LibinputDeviceV1.AccelProfile = if (equal(value, "none")) .none else if (equal(value, "flat")) .flat else if (equal(value, "adaptive")) .adaptive else return error.InvalidValue; try setResult(libinput.setAccelProfile(profile)); } else return error.UnknownSetting;}
fn equal(value: ?[]const u8, expected: []const u8) bool { const text = value orelse return false; return dashed(text, expected);}
/// Accept dashes and underscores interchangeably, and enable alongside/// enabled for boolean settings.fn dashed(text: []const u8, expected: []const u8) bool { if (text.len != expected.len) return false; for (text, expected) |a, b| { const left = if (a == '-') '_' else a; const right = if (b == '-') '_' else b; if (left != right) return false; } return true;}
/// Parse a scroll factor. Rejects NaN, negatives, and anything past the/// wl_fixed wire range so the intFromFloat at the call site cannot overflow.fn parseScrollFactor(text: []const u8) error{InvalidValue}!f64 { const factor = std.fmt.parseFloat(f64, text) catch return error.InvalidValue; if (!std.math.isFinite(factor) or factor < 0.0 or factor > 8388607.0) return error.InvalidValue; return factor;}
test "scroll factor rejects out-of-range values" { const testing = std.testing; try testing.expectEqual(@as(f64, 1.5), try parseScrollFactor("1.5")); try testing.expectEqual(@as(f64, 0.0), try parseScrollFactor("0")); try testing.expectError(error.InvalidValue, parseScrollFactor("-1")); try testing.expectError(error.InvalidValue, parseScrollFactor("nan")); try testing.expectError(error.InvalidValue, parseScrollFactor("inf")); try testing.expectError(error.InvalidValue, parseScrollFactor("1e30")); try testing.expectError(error.InvalidValue, parseScrollFactor("bogus"));}
fn parseToggle(comptime T: type, value: ?[]const u8) error{InvalidValue}!T { const text = value orelse return error.InvalidValue; if (equal(text, "enabled") or std.mem.eql(u8, text, "enable")) return .enabled; if (equal(text, "disabled") or std.mem.eql(u8, text, "disable")) return .disabled; return error.InvalidValue;}
fn setResult(result: anytype) Error!void { const object = result catch return error.OutOfMemory; object.setListener(?*anyopaque, handleResult, null);}