Implement river-xkb-config-v1

This commit adds support for the river-xkb-config-v1 protocol. There's
a new keyboard_layout block in config that can take options from
xkeyboard-config(7).

src/XkbConfig.zig

@@ -0,0 +1,242 @@
+// SPDX-FileCopyrightText: 2026 Ben Buhse <me@benbuhse.email>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+const XkbConfig = @This();
+
+context: *Context,
+
+xkb_config_v1: *river.XkbConfigV1,
+
+/// The keymap object sent to the compositor, if any.
+/// Only valid to use with set_keymap once xkb_keymap_confirmed is true.
+xkb_keymap_v1: ?*river.XkbKeymapV1 = null,
+/// True once xkb_keymap_v1 has received the success event.
+xkb_keymap_confirmed: bool = false,
+
+/// Tracked keyboards so we can apply keymaps to all of them.
+keyboards: wl.list.Head(Keyboard, .link),
+
+const Keyboard = struct {
+    xkb_keyboard_v1: *river.XkbKeyboardV1,
+    xkb_config: *XkbConfig,
+    link: wl.list.Link,
+
+    fn create(xkb_keyboard_v1: *river.XkbKeyboardV1, xkb_config: *XkbConfig) !*Keyboard {
+        const keyboard = try utils.gpa.create(Keyboard);
+        keyboard.* = .{
+            .xkb_keyboard_v1 = xkb_keyboard_v1,
+            .xkb_config = xkb_config,
+            .link = undefined,
+        };
+        xkb_keyboard_v1.setListener(*Keyboard, keyboardListener, keyboard);
+        xkb_config.keyboards.append(keyboard);
+
+        // Only apply if the keymap has been confirmed via the success event.
+        // Applying an unconfirmed keymap is a protocol error.
+        if (xkb_config.xkb_keymap_confirmed) {
+            xkb_keyboard_v1.setKeymap(xkb_config.xkb_keymap_v1.?);
+        }
+
+        return keyboard;
+    }
+
+    fn destroy(keyboard: *Keyboard) void {
+        keyboard.link.remove();
+        keyboard.xkb_keyboard_v1.destroy();
+        utils.gpa.destroy(keyboard);
+    }
+
+    fn keyboardListener(_: *river.XkbKeyboardV1, event: river.XkbKeyboardV1.Event, keyboard: *Keyboard) void {
+        switch (event) {
+            .removed => keyboard.destroy(),
+            .input_device, .layout, .capslock_enabled, .capslock_disabled, .numlock_enabled, .numlock_disabled => {},
+        }
+    }
+};
+
+pub fn create(context: *Context, xkb_config_v1: *river.XkbConfigV1) !*XkbConfig {
+    const xkb_config = try utils.gpa.create(XkbConfig);
+    errdefer utils.gpa.destroy(xkb_config);
+
+    xkb_config.* = .{
+        .context = context,
+        .xkb_config_v1 = xkb_config_v1,
+        .keyboards = undefined, // we will initialize this shortly
+    };
+    xkb_config.keyboards.init();
+
+    xkb_config_v1.setListener(*XkbConfig, riverXkbConfigV1Listener, xkb_config);
+
+    return xkb_config;
+}
+
+pub fn destroy(xkb_config: *XkbConfig) void {
+    var it = xkb_config.keyboards.safeIterator(.forward);
+    while (it.next()) |keyboard| {
+        keyboard.destroy();
+    }
+    if (xkb_config.xkb_keymap_v1) |keymap_v1| {
+        keymap_v1.destroy();
+    }
+    xkb_config.xkb_config_v1.destroy();
+    utils.gpa.destroy(xkb_config);
+}
+
+fn riverXkbConfigV1Listener(xkb_config_v1: *river.XkbConfigV1, event: river.XkbConfigV1.Event, xkb_config: *XkbConfig) void {
+    assert(xkb_config.xkb_config_v1 == xkb_config_v1);
+    switch (event) {
+        .finished => {
+            xkb_config.context.xkb_config = null;
+            xkb_config.destroy();
+        },
+        .xkb_keyboard => |ev| {
+            _ = Keyboard.create(ev.id, xkb_config) catch |e| {
+                log.err("Failed to create keyboard: {}", .{e});
+                return;
+            };
+        },
+    }
+}
+
+/// Build a keymap from the config's keyboard_layout settings and send it
+/// to the compositor. On success, apply it to all tracked keyboards.
+pub fn applyKeyboardLayout(xkb_config: *XkbConfig) void {
+    const layout_config = xkb_config.context.config.keyboard_layout;
+
+    // If nothing is configured and we haven't previously applied a custom keymap,
+    // there's nothing to do. If we did previously apply one, fall through to apply
+    // the system default, reverting the custom keymap.
+    if (layout_config.rules == null and
+        layout_config.model == null and
+        layout_config.layout == null and
+        layout_config.variant == null and
+        layout_config.options == null and
+        !xkb_config.xkb_keymap_confirmed)
+    {
+        return;
+    }
+
+    // Convert ?[]const u8 to ?[*:0]const u8 for xkbcommon
+    const rules_z = dupeZOrNull(layout_config.rules);
+    defer if (rules_z) |s| utils.gpa.free(s);
+    const model_z = dupeZOrNull(layout_config.model);
+    defer if (model_z) |s| utils.gpa.free(s);
+    const layout_z = dupeZOrNull(layout_config.layout);
+    defer if (layout_z) |s| utils.gpa.free(s);
+    const variant_z = dupeZOrNull(layout_config.variant);
+    defer if (variant_z) |s| utils.gpa.free(s);
+    const options_z = dupeZOrNull(layout_config.options);
+    defer if (options_z) |s| utils.gpa.free(s);
+
+    const names = xkbcommon.RuleNames{
+        .rules = if (rules_z) |s| s.ptr else null,
+        .model = if (model_z) |s| s.ptr else null,
+        .layout = if (layout_z) |s| s.ptr else null,
+        .variant = if (variant_z) |s| s.ptr else null,
+        .options = if (options_z) |s| s.ptr else null,
+    };
+
+    // Create xkb context and keymap
+    const xkb_context = xkbcommon.Context.new(.no_flags) orelse {
+        log.err("Failed to create XKB context", .{});
+        return;
+    };
+    defer xkb_context.unref();
+
+    const keymap = xkbcommon.Keymap.newFromNames(xkb_context, &names, .no_flags) orelse {
+        log.err("Invalid keyboard layout configuration", .{});
+        return;
+    };
+    defer keymap.unref();
+
+    // Serialize keymap to string
+    const keymap_str = keymap.getAsString(.text_v1) orelse {
+        log.err("Failed to serialize keymap", .{});
+        return;
+    };
+    const keymap_len = mem.len(keymap_str);
+    // Include the null terminator in the buffer sent to the compositor
+    const keymap_buf = keymap_str[0 .. keymap_len + 1];
+    defer utils.gpa.free(keymap_buf);
+
+    // Create memfd and write keymap
+    const fd = switch (builtin.target.os.tag) {
+        .linux => posix.memfd_createZ("beansprout-xkb-keymap", os.linux.MFD.CLOEXEC | os.linux.MFD.ALLOW_SEALING),
+        .freebsd => posix.memfd_createZ("beansprout-xkb-keymap", std.c.MFD.CLOEXEC | std.c.MFD.ALLOW_SEALING),
+        else => @compileError("target OS not supported"),
+    } catch |err| {
+        log.err("Failed to create memfd: {}", .{err});
+        return;
+    };
+    defer posix.close(fd);
+
+    _ = posix.write(fd, keymap_buf) catch |err| {
+        log.err("Failed to write keymap to fd: {}", .{err});
+        return;
+    };
+
+    // Send to compositor
+    const keymap_v1 = xkb_config.xkb_config_v1.createKeymap(fd, .text_v1) catch |err| {
+        log.err("Failed to create keymap object: {}", .{err});
+        return;
+    };
+
+    // Destroy old keymap if any
+    if (xkb_config.xkb_keymap_v1) |old| {
+        old.destroy();
+    }
+
+    xkb_config.xkb_keymap_confirmed = false;
+    keymap_v1.setListener(*XkbConfig, keymapListener, xkb_config);
+    xkb_config.xkb_keymap_v1 = keymap_v1;
+}
+
+fn keymapListener(_: *river.XkbKeymapV1, event: river.XkbKeymapV1.Event, xkb_config: *XkbConfig) void {
+    switch (event) {
+        .success => {
+            log.info("Keyboard layout applied successfully", .{});
+            xkb_config.xkb_keymap_confirmed = true;
+            // Apply to all tracked keyboards
+            var it = xkb_config.keyboards.iterator(.forward);
+            while (it.next()) |keyboard| {
+                keyboard.xkb_keyboard_v1.setKeymap(xkb_config.xkb_keymap_v1.?);
+            }
+        },
+        .failure => |ev| {
+            log.err("Failed to apply keyboard layout: {s}", .{ev.error_msg});
+            xkb_config.xkb_keymap_confirmed = false;
+            if (xkb_config.xkb_keymap_v1) |keymap| {
+                keymap.destroy();
+                xkb_config.xkb_keymap_v1 = null;
+            }
+        },
+    }
+}
+
+fn dupeZOrNull(opt: ?[]const u8) ?[:0]u8 {
+    const slice = opt orelse return null;
+    return utils.gpa.dupeZ(u8, slice) catch {
+        log.err("Out of memory", .{});
+        return null;
+    };
+}
+
+const builtin = @import("builtin");
+const std = @import("std");
+const mem = std.mem;
+const os = std.os;
+const posix = std.posix;
+const assert = std.debug.assert;
+
+const wayland = @import("wayland");
+const wl = wayland.client.wl;
+const river = wayland.client.river;
+
+const xkbcommon = @import("xkbcommon");
+
+const utils = @import("utils.zig");
+const Context = @import("Context.zig");
+const Seat = @import("Seat.zig");
+
+const log = std.log.scoped(.XkbConfig);