Merge branch 'master' of https://codeberg.org/river/river

Deprecate and ignore the riverctl commands for creating explicit
keyboard groups.

In my mind, the only reason to have more than one keyboard group is if
different keyboard devices are assigned different keymaps or repeat
rates. River does not currently allow such things to be configured
however.

When river eventually makes it possible to configure different keymaps
and repeat rates per keyboard device, there is no reason we can't 100%
automatically group keyboards based on the keymap/repeat rate.

Exposing this keyboard group abstraction to the user is just bad UX.

Failing to group keyboards automatically also creates confusing/buggy
behavior for the user if the hardware, for example, exposes some of the
the XF86 buttons on a laptop as a separate keyboard device from the main
keyboard. Creating keybindings for these XF86 buttons that use modifiers
doesn't work by default, but there's no reason it shouldn't just work.

Closes: https://codeberg.org/river/river/issues/1138

build.zig

@@ -100,11 +100,11 @@ pub fn build(b: *Build) !void {
     scanner.addSystemProtocol("unstable/pointer-gestures/pointer-gestures-unstable-v1.xml");
     scanner.addSystemProtocol("unstable/xdg-decoration/xdg-decoration-unstable-v1.xml");
 
-    scanner.addCustomProtocol("protocol/river-control-unstable-v1.xml");
-    scanner.addCustomProtocol("protocol/river-status-unstable-v1.xml");
-    scanner.addCustomProtocol("protocol/river-layout-v3.xml");
-    scanner.addCustomProtocol("protocol/wlr-layer-shell-unstable-v1.xml");
-    scanner.addCustomProtocol("protocol/wlr-output-power-management-unstable-v1.xml");
+    scanner.addCustomProtocol(b.path("protocol/river-control-unstable-v1.xml"));
+    scanner.addCustomProtocol(b.path("protocol/river-status-unstable-v1.xml"));
+    scanner.addCustomProtocol(b.path("protocol/river-layout-v3.xml"));
+    scanner.addCustomProtocol(b.path("protocol/wlr-layer-shell-unstable-v1.xml"));
+    scanner.addCustomProtocol(b.path("protocol/wlr-output-power-management-unstable-v1.xml"));
 
     // Some of these versions may be out of date with what wlroots implements.
     // This is not a problem in practice though as long as river successfully compiles.
@@ -185,9 +185,6 @@ pub fn build(b: *Build) !void {
             .flags = &.{ "-std=c99", "-O2" },
         });
 
-        // TODO: remove when zig issue #131 is implemented
-        scanner.addCSource(river);
-
         river.pie = pie;
         river.root_module.omit_frame_pointer = omit_frame_pointer;
 
@@ -211,8 +208,6 @@ pub fn build(b: *Build) !void {
         riverctl.linkLibC();
         riverctl.linkSystemLibrary("wayland-client");
 
-        scanner.addCSource(riverctl);
-
         riverctl.pie = pie;
         riverctl.root_module.omit_frame_pointer = omit_frame_pointer;
 
@@ -236,8 +231,6 @@ pub fn build(b: *Build) !void {
         rivertile.linkLibC();
         rivertile.linkSystemLibrary("wayland-client");
 
-        scanner.addCSource(rivertile);
-
         rivertile.pie = pie;
         rivertile.root_module.omit_frame_pointer = omit_frame_pointer;
 

build.zig.zon

@@ -8,12 +8,12 @@
             .hash = "12209db20ce873af176138b76632931def33a10539387cba745db72933c43d274d56",
         },
         .@"zig-wayland" = .{
-            .url = "https://codeberg.org/ifreund/zig-wayland/archive/v0.2.0.tar.gz",
-            .hash = "1220687c8c47a48ba285d26a05600f8700d37fc637e223ced3aa8324f3650bf52242",
+            .url = "https://codeberg.org/ifreund/zig-wayland/archive/bd8afd256fb6beed7d72e3580b00f33dea7155a1.tar.gz",
+            .hash = "1220218a0e5c2cd63a2311417f4d3f2411dd17d75815f67c704ee657bd846ecbc3e0",
         },
         .@"zig-wlroots" = .{
-            .url = "https://codeberg.org/ifreund/zig-wlroots/archive/e486223799648d27e8b91c5fe0ea4c088b74b707.tar.gz",
-            .hash = "1220aeb3317e16c38583839961c9d695fa60d23a3d506c8275fb0e8fa9849844f2f7",
+            .url = "https://codeberg.org/ifreund/zig-wlroots/archive/afbbbbe5579c750feed8de12b073fa50b0651137.tar.gz",
+            .hash = "122060ddef836b7872cb2088764a8bd2fb2e9254327673e8176b7f7a621ec897484f",
         },
         .@"zig-xkbcommon" = .{
             .url = "https://codeberg.org/ifreund/zig-xkbcommon/archive/v0.2.0.tar.gz",

completions/bash/riverctl

@@ -4,10 +4,6 @@ function __riverctl_completion ()
 	if [ "${COMP_CWORD}" -eq 1 ]
 	then
 		OPTS=" \
-			keyboard-group-create \
-			keyboard-group-destroy \
-			keyboard-group-add \
-			keyboard-group-remove \
 			keyboard-layout \
 			keyboard-layout-file \
 			close \

completions/fish/riverctl.fish

@@ -72,11 +72,6 @@ complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'hide-cursor'
 complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'set-repeat'             -d 'Set the keyboard repeat rate and repeat delay'
 complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'set-cursor-warp'        -d 'Set the cursor warp mode'
 complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'xcursor-theme'          -d 'Set the xcursor theme'
-# Keyboardgroups
-complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-group-create'  -d 'Create a keyboard group'
-complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-group-destroy' -d 'Destroy a keyboard group'
-complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-group-add'     -d 'Add a keyboard to a keyboard group'
-complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-group-remove'  -d 'Remove a keyboard from a keyboard group'
 complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-layout'        -d 'Set the keyboard layout'
 complete -c riverctl -n '__fish_riverctl_complete_arg 1' -a 'keyboard-layout-file'   -d 'Set the keyboard layout from a file.'
 

completions/zsh/_riverctl

@@ -62,11 +62,6 @@ _riverctl_commands()
         'set-repeat:Set the keyboard repeat rate and repeat delay'
         'set-cursor-warp:Set the cursor warp mode.'
         'xcursor-theme:Set the xcursor theme'
-        # Keyboard groups
-        'keyboard-group-create:Create a keyboard group'
-        'keyboard-group-destroy:Destroy a keyboard group'
-        'keyboard-group-add:Add a keyboard to a keyboard group'
-        'keyboard-group-remove:Remove a keyboard from a keyboard group'
         'keyboard-layout:Set the keyboard layout'
         'keyboard-layout-file:Set the keyboard layout from a file'
         # Input

doc/riverctl.1.scd

@@ -430,7 +430,8 @@ matches everything while _\*\*_ and the empty string are invalid.
 
 *set-repeat* _rate_ _delay_
 	Set the keyboard repeat rate to _rate_ key repeats per second and
-	repeat delay to _delay_ milliseconds.
+	repeat delay to _delay_ milliseconds. The default is a rate of 25
+	repeats per second and a delay of 600ms.
 
 *xcursor-theme* _theme_name_ [_size_]
 	Set the xcursor theme to _theme_name_ and optionally set the _size_.
@@ -461,25 +462,6 @@ matches everything while _\*\*_ and the empty string are invalid.
 	following URL:
 	https://xkbcommon.org/doc/current/keymap-text-format-v1.html
 
-*keyboard-group-create* _group_name_
-	Create a keyboard group. A keyboard group collects multiple keyboards in
-	a single logical keyboard. This means that all state, like the active
-	modifiers, is shared between the keyboards in a group.
-
-*keyboard-group-destroy* _group_name_
-	Destroy the keyboard group with the given name. All attached keyboards
-	will be released, making them act as separate devices again.
-
-*keyboard-group-add* _group_name_ _input_device_name_
-	Add a keyboard to a keyboard group, identified by the keyboard's
-	input device name. Any currently connected and future keyboards with
-	the given name will be added to the group. Simple globbing patterns are
-	supported, see the rules section for further information on globs.
-
-*keyboard-group-remove* _group_name_ _input_device_name_
-	Remove a keyboard from a keyboard group, identified by the keyboard's
-	input device name.
-
 The _input_ command can be used to create a configuration rule for an input
 device identified by its _name_.
 The _name_ of an input device consists of its type, its decimal vendor id,

river/Cursor.zig

@@ -108,6 +108,19 @@ const LayoutPoint = struct {
     ly: f64,
 };
 
+const Image = union(enum) {
+    /// No cursor image
+    none,
+    /// Name of the current Xcursor shape
+    xcursor: [*:0]const u8,
+    /// Cursor surface configured by a client
+    client: struct {
+        surface: *wlr.Surface,
+        hotspot_x: i32,
+        hotspot_y: i32,
+    },
+};
+
 const log = std.log.scoped(.cursor);
 
 /// Current cursor mode as well as any state needed to implement that mode
@@ -124,9 +137,8 @@ wlr_cursor: *wlr.Cursor,
 
 /// Xcursor manager for the currently configured Xcursor theme.
 xcursor_manager: *wlr.XcursorManager,
-/// Name of the current Xcursor shape, or null if a client has configured a
-/// surface to be used as the cursor shape instead.
-xcursor_name: ?[*:0]const u8 = null,
+image: Image = .none,
+image_surface_destroy: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleImageSurfaceDestroy),
 
 /// Number of distinct buttons currently pressed
 pressed_count: u32 = 0,
@@ -286,18 +298,40 @@ pub fn setTheme(cursor: *Cursor, theme: ?[*:0]const u8, _size: ?u32) !void {
     cursor.xcursor_manager.destroy();
     cursor.xcursor_manager = xcursor_manager;
 
-    if (cursor.xcursor_name) |name| {
-        cursor.setXcursor(name);
+    switch (cursor.image) {
+        .none, .client => {},
+        .xcursor => |name| cursor.wlr_cursor.setXcursor(xcursor_manager, name),
     }
 }
 
-pub fn setXcursor(cursor: *Cursor, name: [*:0]const u8) void {
-    cursor.wlr_cursor.setXcursor(cursor.xcursor_manager, name);
-    cursor.xcursor_name = name;
+pub fn setImage(cursor: *Cursor, image: Image) void {
+    switch (cursor.image) {
+        .none, .xcursor => {},
+        .client => {
+            cursor.image_surface_destroy.link.remove();
+        },
+    }
+    cursor.image = image;
+    switch (cursor.image) {
+        .none => cursor.wlr_cursor.unsetImage(),
+        .xcursor => |name| cursor.wlr_cursor.setXcursor(cursor.xcursor_manager, name),
+        .client => |client| {
+            cursor.wlr_cursor.setSurface(client.surface, client.hotspot_x, client.hotspot_y);
+            client.surface.events.destroy.add(&cursor.image_surface_destroy);
+        },
+    }
+}
+
+fn handleImageSurfaceDestroy(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
+    const cursor: *Cursor = @fieldParentPtr("image_surface_destroy", listener);
+    // wlroots calls wlr_cursor_unset_image() automatically
+    // when the cursor surface is destroyed.
+    cursor.image = .none;
+    cursor.image_surface_destroy.link.remove();
 }
 
 fn clearFocus(cursor: *Cursor) void {
-    cursor.setXcursor("default");
+    cursor.setImage(.{ .xcursor = "default" });
     cursor.seat.wlr_seat.pointerNotifyClearFocus();
 }
 
@@ -740,8 +774,15 @@ fn handleRequestSetCursor(
         // on the output that it's currently on and continue to do so as the
         // cursor moves between outputs.
         log.debug("focused client set cursor", .{});
-        cursor.wlr_cursor.setSurface(event.surface, event.hotspot_x, event.hotspot_y);
-        cursor.xcursor_name = null;
+        if (event.surface) |surface| {
+            cursor.setImage(.{ .client = .{
+                .surface = surface,
+                .hotspot_x = event.hotspot_x,
+                .hotspot_y = event.hotspot_y,
+            } });
+        } else {
+            cursor.setImage(.none);
+        }
     }
 }
 
@@ -757,8 +798,6 @@ pub fn hide(cursor: *Cursor) void {
 
     cursor.hidden = true;
     cursor.wlr_cursor.unsetImage();
-    cursor.xcursor_name = null;
-    cursor.seat.wlr_seat.pointerNotifyClearFocus();
     cursor.hide_cursor_timer.timerUpdate(0) catch {
         log.err("failed to update cursor hide timeout", .{});
     };
@@ -770,6 +809,7 @@ pub fn unhide(cursor: *Cursor) void {
     };
     if (!cursor.hidden) return;
     cursor.hidden = false;
+    cursor.setImage(cursor.image);
     cursor.updateState();
 }
 
@@ -868,7 +908,7 @@ fn computeEdges(cursor: *const Cursor, view: *const View) wlr.Edges {
     }
 }
 
-fn enterMode(cursor: *Cursor, mode: Mode, view: *View, xcursor_name: [*:0]const u8) void {
+fn enterMode(cursor: *Cursor, mode: Mode, view: *View, xcursor: [*:0]const u8) void {
     assert(cursor.mode == .passthrough or cursor.mode == .down);
     assert(mode == .move or mode == .resize);
 
@@ -884,7 +924,7 @@ fn enterMode(cursor: *Cursor, mode: Mode, view: *View, xcursor_name: [*:0]const
     }
 
     cursor.seat.wlr_seat.pointerNotifyClearFocus();
-    cursor.setXcursor(xcursor_name);
+    cursor.setImage(.{ .xcursor = xcursor });
 
     server.root.applyPending();
 }
@@ -1091,8 +1131,13 @@ pub fn updateState(cursor: *Cursor) void {
             if (!cursor.hidden) {
                 var now: posix.timespec = undefined;
                 posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
-                const msec: u32 = @intCast(now.tv_sec * std.time.ms_per_s +
-                    @divTrunc(now.tv_nsec, std.time.ns_per_ms));
+                // 2^32-1 milliseconds is ~50 days, which is a realistic uptime.
+                // This means that we must wrap if the monotonic time is greater than
+                // 2^32-1 milliseconds and hope that clients don't get too confused.
+                const msec: u32 = @intCast(@rem(
+                    now.tv_sec *% std.time.ms_per_s +% @divTrunc(now.tv_nsec, std.time.ns_per_ms),
+                    math.maxInt(u32),
+                ));
                 cursor.passthrough(msec);
             }
         },

river/Keyboard.zig

@@ -101,16 +101,9 @@ pub fn init(keyboard: *Keyboard, seat: *Seat, wlr_device: *wlr.InputDevice) !voi
     // wlroots will log a more detailed error if this fails.
     if (!wlr_keyboard.setKeymap(server.config.keymap)) return error.OutOfMemory;
 
-    // Add to keyboard-group, if applicable.
-    var group_it = seat.keyboard_groups.first;
-    outer: while (group_it) |group_node| : (group_it = group_node.next) {
-        for (group_node.data.globs.items) |glob| {
-            if (globber.match(glob, keyboard.device.identifier)) {
-                // wlroots will log an error if this fails explaining the reason.
-                _ = group_node.data.wlr_group.addKeyboard(wlr_keyboard);
-                break :outer;
-            }
-        }
+    if (wlr.KeyboardGroup.fromKeyboard(wlr_keyboard) == null) {
+        // wlroots will log an error on failure
+        _ = seat.keyboard_group.addKeyboard(wlr_keyboard);
     }
 
     wlr_keyboard.setRepeatInfo(server.config.repeat_rate, server.config.repeat_delay);

river/KeyboardGroup.zig

@@ -1,141 +0,0 @@
-// This file is part of river, a dynamic tiling wayland compositor.
-//
-// Copyright 2022 The River Developers
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 3.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-const KeyboardGroup = @This();
-
-const std = @import("std");
-const assert = std.debug.assert;
-const mem = std.mem;
-
-const globber = @import("globber");
-const wlr = @import("wlroots");
-const wl = @import("wayland").server.wl;
-const xkb = @import("xkbcommon");
-
-const log = std.log.scoped(.keyboard_group);
-
-const server = &@import("main.zig").server;
-const util = @import("util.zig");
-
-const Seat = @import("Seat.zig");
-const Keyboard = @import("Keyboard.zig");
-
-seat: *Seat,
-wlr_group: *wlr.KeyboardGroup,
-name: []const u8,
-globs: std.ArrayListUnmanaged([]const u8) = .{},
-
-pub fn create(seat: *Seat, name: []const u8) !void {
-    log.debug("new keyboard group: '{s}'", .{name});
-
-    const node = try util.gpa.create(std.TailQueue(KeyboardGroup).Node);
-    errdefer util.gpa.destroy(node);
-
-    const wlr_group = try wlr.KeyboardGroup.create();
-    errdefer wlr_group.destroy();
-
-    const owned_name = try util.gpa.dupe(u8, name);
-    errdefer util.gpa.free(owned_name);
-
-    node.data = .{
-        .wlr_group = wlr_group,
-        .name = owned_name,
-        .seat = seat,
-    };
-
-    seat.addDevice(&wlr_group.keyboard.base);
-    seat.keyboard_groups.append(node);
-}
-
-pub fn destroy(group: *KeyboardGroup) void {
-    log.debug("destroying keyboard group: '{s}'", .{group.name});
-
-    util.gpa.free(group.name);
-
-    for (group.globs.items) |glob| {
-        util.gpa.free(glob);
-    }
-    group.globs.deinit(util.gpa);
-
-    group.wlr_group.destroy();
-
-    const node: *std.TailQueue(KeyboardGroup).Node = @fieldParentPtr("data", group);
-    group.seat.keyboard_groups.remove(node);
-    util.gpa.destroy(node);
-}
-
-pub fn addIdentifier(group: *KeyboardGroup, new_id: []const u8) !void {
-    for (group.globs.items) |glob| {
-        if (mem.eql(u8, glob, new_id)) return;
-    }
-
-    log.debug("keyboard group '{s}' adding identifier: '{s}'", .{ group.name, new_id });
-
-    const owned_id = try util.gpa.dupe(u8, new_id);
-    errdefer util.gpa.free(owned_id);
-
-    // Glob is validated in the command handler.
-    try group.globs.append(util.gpa, owned_id);
-    errdefer {
-        // Not used now, but if at any point this function is modified to that
-        // it may return an error after the glob pattern is added to the list,
-        // the list will have a pointer to freed memory in its last position.
-        _ = group.globs.pop();
-    }
-
-    // Add any existing matching keyboards to the group.
-    var it = server.input_manager.devices.iterator(.forward);
-    while (it.next()) |device| {
-        if (device.seat != group.seat) continue;
-        if (device.wlr_device.type != .keyboard) continue;
-
-        if (globber.match(device.identifier, new_id)) {
-            log.debug("found existing matching keyboard; adding to group", .{});
-
-            if (!group.wlr_group.addKeyboard(device.wlr_device.toKeyboard())) {
-                // wlroots logs an error message to explain why this failed.
-                continue;
-            }
-        }
-
-        // Continue, because we may have more than one device with the exact
-        // same identifier. That is in fact one reason for the keyboard group
-        // feature to exist in the first place.
-    }
-}
-
-pub fn removeIdentifier(group: *KeyboardGroup, id: []const u8) !void {
-    for (group.globs.items, 0..) |glob, index| {
-        if (mem.eql(u8, glob, id)) {
-            _ = group.globs.orderedRemove(index);
-            break;
-        }
-    } else {
-        return;
-    }
-
-    var it = server.input_manager.devices.iterator(.forward);
-    while (it.next()) |device| {
-        if (device.seat != group.seat) continue;
-        if (device.wlr_device.type != .keyboard) continue;
-
-        if (globber.match(device.identifier, id)) {
-            const wlr_keyboard = device.wlr_device.toKeyboard();
-            assert(wlr_keyboard.group == group.wlr_group);
-            group.wlr_group.removeKeyboard(wlr_keyboard);
-        }
-    }
-}

river/Output.zig

@@ -542,6 +542,13 @@ fn handleFrame(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
 }
 
 fn renderAndCommit(output: *Output, scene_output: *wlr.SceneOutput) !void {
+    // TODO(wlroots): replace this with wlr_scene_output_needs_frame()
+    if (!output.wlr_output.needs_frame and !output.gamma_dirty and
+        !scene_output.pending_commit_damage.notEmpty())
+    {
+        return;
+    }
+
     var state = wlr.Output.State.init();
     defer state.finish();
 

river/Seat.zig

@@ -33,7 +33,6 @@ const InputDevice = @import("InputDevice.zig");
 const InputManager = @import("InputManager.zig");
 const InputRelay = @import("InputRelay.zig");
 const Keyboard = @import("Keyboard.zig");
-const KeyboardGroup = @import("KeyboardGroup.zig");
 const LayerSurface = @import("LayerSurface.zig");
 const LockSurface = @import("LockSurface.zig");
 const Mapping = @import("Mapping.zig");
@@ -84,7 +83,7 @@ mapping_repeat_timer: *wl.EventSource,
 /// Currently repeating mapping, if any
 repeating_mapping: ?*const Mapping = null,
 
-keyboard_groups: std.TailQueue(KeyboardGroup) = .{},
+keyboard_group: *wlr.KeyboardGroup,
 
 /// Currently focused output. Null only when there are no outputs at all.
 focused_output: ?*Output = null,
@@ -121,12 +120,15 @@ pub fn init(seat: *Seat, name: [*:0]const u8) !void {
         .cursor = undefined,
         .relay = undefined,
         .mapping_repeat_timer = mapping_repeat_timer,
+        .keyboard_group = try wlr.KeyboardGroup.create(),
     };
     seat.wlr_seat.data = @intFromPtr(seat);
 
     try seat.cursor.init(seat);
     seat.relay.init();
 
+    try seat.tryAddDevice(&seat.keyboard_group.keyboard.base);
+
     seat.wlr_seat.events.request_set_selection.add(&seat.request_set_selection);
     seat.wlr_seat.events.request_start_drag.add(&seat.request_start_drag);
     seat.wlr_seat.events.start_drag.add(&seat.start_drag);
@@ -142,9 +144,7 @@ pub fn deinit(seat: *Seat) void {
     seat.cursor.deinit();
     seat.mapping_repeat_timer.remove();
 
-    while (seat.keyboard_groups.first) |node| {
-        node.data.destroy();
-    }
+    seat.keyboard_group.destroy();
 
     seat.request_set_selection.link.remove();
     seat.request_start_drag.link.remove();

river/Server.zig

@@ -19,6 +19,7 @@ const Server = @This();
 const build_options = @import("build_options");
 const std = @import("std");
 const assert = std.debug.assert;
+const mem = std.mem;
 const posix = std.posix;
 const wlr = @import("wlroots");
 const wl = @import("wayland").server.wl;
@@ -86,6 +87,8 @@ foreign_toplevel_manager: *wlr.ForeignToplevelManagerV1,
 
 tearing_control_manager: *wlr.TearingControlManagerV1,
 
+alpha_modifier: *wlr.AlphaModifierV1,
+
 input_manager: InputManager,
 root: Root,
 config: Config,
@@ -163,6 +166,8 @@ pub fn init(server: *Server, runtime_xwayland: bool) !void {
 
         .tearing_control_manager = try wlr.TearingControlManagerV1.create(wl_server, 1),
 
+        .alpha_modifier = try wlr.AlphaModifierV1.create(wl_server),
+
         .config = try Config.init(),
 
         .root = undefined,
@@ -295,13 +300,16 @@ fn allowlist(server: *Server, global: *const wl.Global) bool {
     // such as wl_output and wl_seat since the wl_global_create() function will
     // advertise the global to clients and invoke this filter before returning
     // the new global pointer.
-    //
+    if ((mem.orderZ(u8, global.getInterface().name, "wl_output") == .eq) or
+        (mem.orderZ(u8, global.getInterface().name, "wl_seat") == .eq))
+    {
+        return true;
+    }
+
     // For other globals I like the current pointer comparison approach as it
     // should catch river accidentally exposing multiple copies of e.g. wl_shm
     // with an assertion failure.
-    return global.getInterface() == wl.Output.getInterface() or
-        global.getInterface() == wl.Seat.getInterface() or
-        global == server.shm.global or
+    return global == server.shm.global or
         global == server.single_pixel_buffer_manager.global or
         global == server.viewporter.global or
         global == server.fractional_scale_manager.global or
@@ -321,7 +329,8 @@ fn allowlist(server: *Server, global: *const wl.Global) bool {
         global == server.input_manager.tablet_manager.global or
         global == server.input_manager.pointer_gestures.global or
         global == server.idle_inhibit_manager.wlr_manager.global or
-        global == server.tearing_control_manager.global;
+        global == server.tearing_control_manager.global or
+        global == server.alpha_modifier.global;
 }
 
 /// Returns true if the global is blocked for security contexts
@@ -510,7 +519,7 @@ fn handleRequestSetCursorShape(
         // actually has pointer focus first.
         if (focused_client == event.seat_client) {
             const name = wlr.CursorShapeManagerV1.shapeName(event.shape);
-            seat.cursor.setXcursor(name);
+            seat.cursor.setImage(.{ .xcursor = name });
         }
     }
 }

river/command/keyboard_group.zig

@@ -24,77 +24,13 @@ const util = @import("../util.zig");
 
 const Error = @import("../command.zig").Error;
 const Seat = @import("../Seat.zig");
-const KeyboardGroup = @import("../KeyboardGroup.zig");
 
-pub fn keyboardGroupCreate(
-    seat: *Seat,
-    args: []const [:0]const u8,
-    out: *?[]const u8,
-) Error!void {
-    if (args.len < 2) return Error.NotEnoughArguments;
-    if (args.len > 2) return Error.TooManyArguments;
+pub const keyboardGroupCreate = keyboardGroupDeprecated;
+pub const keyboardGroupDestroy = keyboardGroupDeprecated;
+pub const keyboardGroupAdd = keyboardGroupDeprecated;
+pub const keyboardGroupRemove = keyboardGroupDeprecated;
 
-    if (keyboardGroupFromName(seat, args[1]) != null) {
-        const msg = try util.gpa.dupe(u8, "error: failed to create keybaord group: group of same name already exists\n");
-        out.* = msg;
-        return;
-    }
-
-    try KeyboardGroup.create(seat, args[1]);
-}
-
-pub fn keyboardGroupDestroy(
-    seat: *Seat,
-    args: []const [:0]const u8,
-    out: *?[]const u8,
-) Error!void {
-    if (args.len < 2) return Error.NotEnoughArguments;
-    if (args.len > 2) return Error.TooManyArguments;
-    const group = keyboardGroupFromName(seat, args[1]) orelse {
-        const msg = try util.gpa.dupe(u8, "error: no keyboard group with that name exists\n");
-        out.* = msg;
-        return;
-    };
-    group.destroy();
-}
-
-pub fn keyboardGroupAdd(
-    seat: *Seat,
-    args: []const [:0]const u8,
-    out: *?[]const u8,
-) Error!void {
-    if (args.len < 3) return Error.NotEnoughArguments;
-    if (args.len > 3) return Error.TooManyArguments;
-
-    const group = keyboardGroupFromName(seat, args[1]) orelse {
-        const msg = try util.gpa.dupe(u8, "error: no keyboard group with that name exists\n");
-        out.* = msg;
-        return;
-    };
-    try globber.validate(args[2]);
-    try group.addIdentifier(args[2]);
-}
-
-pub fn keyboardGroupRemove(
-    seat: *Seat,
-    args: []const [:0]const u8,
-    out: *?[]const u8,
-) Error!void {
-    if (args.len < 3) return Error.NotEnoughArguments;
-    if (args.len > 3) return Error.TooManyArguments;
-
-    const group = keyboardGroupFromName(seat, args[1]) orelse {
-        const msg = try util.gpa.dupe(u8, "error: no keyboard group with that name exists\n");
-        out.* = msg;
-        return;
-    };
-    try group.removeIdentifier(args[2]);
-}
-
-fn keyboardGroupFromName(seat: *Seat, name: []const u8) ?*KeyboardGroup {
-    var it = seat.keyboard_groups.first;
-    while (it) |node| : (it = node.next) {
-        if (mem.eql(u8, node.data.name, name)) return &node.data;
-    }
-    return null;
+fn keyboardGroupDeprecated(_: *Seat, _: []const [:0]const u8, out: *?[]const u8) Error!void {
+    out.* = try util.gpa.dupe(u8, "warning: explicit keyboard groups are deprecated, " ++
+        "all keyboards are now automatically added to a single group\n");
 }

river/main.zig

@@ -84,7 +84,7 @@ pub fn main() anyerror!void {
             posix.exit(1);
         }
     }
-    const enable_xwayland = !result.flags.@"no-xwayland";
+    const runtime_xwayland = !result.flags.@"no-xwayland";
     const startup_command = blk: {
         if (result.flags.c) |command| {
             break :blk try util.gpa.dupeZ(u8, command);
@@ -95,17 +95,25 @@ pub fn main() anyerror!void {
 
     log.info("river version {s}, initializing server", .{build_options.version});
 
-    process.setup();
-
     river_init_wlroots_log(switch (runtime_log_level) {
         .debug => .debug,
         .info => .info,
         .warn, .err => .err,
     });
 
-    try server.init(enable_xwayland);
+    try server.init(runtime_xwayland);
     defer server.deinit();
 
+    // wlroots starts the Xwayland process from an idle event source, the reasoning being that
+    // this gives the compositor time to set up event listeners before Xwayland is actually
+    // started. We want Xwayland to be started by wlroots before we modify our rlimits in
+    // process.setup() since wlroots does not offer a way for us to reset the rlimit post-fork.
+    if (build_options.xwayland and runtime_xwayland) {
+        server.wl_server.getEventLoop().dispatchIdle();
+    }
+
+    process.setup();
+
     try server.start();
 
     // Run the child in a new process group so that we can send SIGTERM to all

riverctl/main.zig

@@ -110,10 +110,10 @@ fn _main() !void {
 fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, globals: *Globals) void {
     switch (event) {
         .global => |global| {
-            if (mem.orderZ(u8, global.interface, wl.Seat.getInterface().name) == .eq) {
+            if (mem.orderZ(u8, global.interface, wl.Seat.interface.name) == .eq) {
                 assert(globals.seat == null); // TODO: support multiple seats
                 globals.seat = registry.bind(global.name, wl.Seat, 1) catch @panic("out of memory");
-            } else if (mem.orderZ(u8, global.interface, zriver.ControlV1.getInterface().name) == .eq) {
+            } else if (mem.orderZ(u8, global.interface, zriver.ControlV1.interface.name) == .eq) {
                 globals.control = registry.bind(global.name, zriver.ControlV1, 1) catch @panic("out of memory");
             }
         },

rivertile/main.zig

@@ -382,9 +382,9 @@ pub fn main() !void {
 fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, context: *Context) void {
     switch (event) {
         .global => |global| {
-            if (mem.orderZ(u8, global.interface, river.LayoutManagerV3.getInterface().name) == .eq) {
+            if (mem.orderZ(u8, global.interface, river.LayoutManagerV3.interface.name) == .eq) {
                 context.layout_manager = registry.bind(global.name, river.LayoutManagerV3, 1) catch return;
-            } else if (mem.orderZ(u8, global.interface, wl.Output.getInterface().name) == .eq) {
+            } else if (mem.orderZ(u8, global.interface, wl.Output.interface.name) == .eq) {
                 context.addOutput(registry, global.name) catch |err| fatal("failed to bind output: {}", .{err});
             }
         },