Merge branch 'main' of git.zander.im:Zander671/river

We should wait until the next "initial commit" before
sending a configure after a layer surface unmaps itself.

.builds/alpine.yml

@@ -14,6 +14,7 @@ packages:
   - xcb-util-wm-dev
   - pixman-dev
   - libevdev-dev
+  - wayland-dev
   - wayland-protocols
   - xwayland-dev
   - meson
@@ -22,19 +23,12 @@ packages:
   - wget
   - xz
 sources:
-  - https://codeberg.org/river/river
+  - https://codeberg.org/river/river-classic
-  - https://gitlab.freedesktop.org/wayland/wayland.git
   - https://gitlab.freedesktop.org/wlroots/wlroots.git
 tasks:
   - install_deps: |
-      cd wayland
-      git checkout 1.23.0
-      meson setup build -Ddocumentation=false -Dtests=false --prefix /usr
-      sudo ninja -C build install
-      cd ..
-
       cd wlroots
-      git checkout 0.18.0
+      git checkout 0.19.0
       meson setup build --auto-features=enabled -Drenderers=gles2 \
             -Dcolor-management=disabled -Dlibliftoff=disabled \
             -Dexamples=false -Dwerror=false -Db_ndebug=false \
@@ -43,20 +37,19 @@ tasks:
       cd ..
 
       # Eat Github's resources rather than the Zig Software Foundation's resources!
-      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.13.0/zig-linux-x86_64-0.13.0.tar.xz
+      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.15.1/zig-x86_64-linux-0.15.1.tar.xz
-      tar xf zig-linux-x86_64-0.13.0.tar.xz
+      tar xf zig-x86_64-linux-0.15.1.tar.xz
-      sudo mv zig-linux-x86_64-0.13.0/zig /usr/bin/
+      sudo mv zig-x86_64-linux-0.15.1/zig /usr/bin/
-      sudo mv zig-linux-x86_64-0.13.0/lib /usr/lib/zig
+      sudo mv zig-x86_64-linux-0.15.1/lib /usr/lib/zig
   - build: |
-      cd river
+      cd river-classic
       zig build --summary all
   - build_xwayland: |
-      cd river
+      cd river-classic
       zig build --summary all -Dxwayland
   - fmt: |
-      cd river
+      cd river-classic
       zig fmt --check river/
       zig fmt --check riverctl/
       zig fmt --check rivertile/
       zig fmt --check build.zig
-      zig fmt --check build.zig.zon

.builds/archlinux.yml

@@ -20,19 +20,12 @@ packages:
   - wget
   - xz
 sources:
-  - https://codeberg.org/river/river
+  - https://codeberg.org/river/river-classic
-  - https://gitlab.freedesktop.org/wayland/wayland.git
   - https://gitlab.freedesktop.org/wlroots/wlroots.git
 tasks:
   - install_deps: |
-      cd wayland
-      git checkout 1.23.0
-      meson setup build -Ddocumentation=false -Dtests=false --prefix /usr
-      sudo ninja -C build install
-      cd ..
-
       cd wlroots
-      git checkout 0.18.0
+      git checkout 0.19.0
       meson setup build --auto-features=enabled -Drenderers=gles2 \
             -Dcolor-management=disabled -Dlibliftoff=disabled \
             -Dexamples=false -Dwerror=false -Db_ndebug=false \
@@ -41,20 +34,19 @@ tasks:
       cd ..
 
       # Eat Github's resources rather than the Zig Software Foundation's resources!
-      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.13.0/zig-linux-x86_64-0.13.0.tar.xz
+      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.15.1/zig-x86_64-linux-0.15.1.tar.xz
-      tar xf zig-linux-x86_64-0.13.0.tar.xz
+      tar xf zig-x86_64-linux-0.15.1.tar.xz
-      sudo mv zig-linux-x86_64-0.13.0/zig /usr/bin/
+      sudo mv zig-x86_64-linux-0.15.1/zig /usr/bin/
-      sudo mv zig-linux-x86_64-0.13.0/lib /usr/lib/zig
+      sudo mv zig-x86_64-linux-0.15.1/lib /usr/lib/zig
   - build: |
-      cd river
+      cd river-classic
       zig build --summary all
   - build_xwayland: |
-      cd river
+      cd river-classic
       zig build --summary all -Dxwayland
   - fmt: |
-      cd river
+      cd river-classic
       zig fmt --check river/
       zig fmt --check riverctl/
       zig fmt --check rivertile/
       zig fmt --check build.zig
-      zig fmt --check build.zig.zon

.builds/freebsd.yml

@@ -7,6 +7,7 @@ packages:
   - devel/meson
   - devel/pkgconf
   - graphics/mesa-libs
+  - graphics/wayland
   - graphics/wayland-protocols
   - misc/hwdata
   - x11/libX11
@@ -25,20 +26,14 @@ packages:
   - scdoc
   - wget
 sources:
-  - https://codeberg.org/river/river
+  - https://codeberg.org/river/river-classic
-  - https://gitlab.freedesktop.org/wayland/wayland.git
   - https://gitlab.freedesktop.org/wlroots/wlroots.git
 tasks:
   - install_deps: |
-      cd wayland
-      git checkout 1.23.0
-      meson setup build -Ddocumentation=false -Dtests=false --prefix /usr
-      sudo ninja -C build install
-      cd ..
-
       cd wlroots
-      git checkout 0.18.0
+      git checkout 0.19.0
       meson setup build --auto-features=enabled -Drenderers=gles2 \
+            -Dallocators=gbm \
             -Dcolor-management=disabled -Dlibliftoff=disabled \
             -Dexamples=false -Dwerror=false -Db_ndebug=false \
             -Dxcb-errors=disabled --prefix /usr
@@ -46,18 +41,18 @@ tasks:
       cd ..
 
       # Eat Github's resources rather than the Zig Software Foundation's resources!
-      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.13.0/zig-freebsd-x86_64-0.13.0.tar.xz
+      wget -nv https://github.com/ifreund/zig-tarball-mirror/releases/download/0.15.1/zig-x86_64-freebsd-0.15.1.tar.xz
-      tar xf zig-freebsd-x86_64-0.13.0.tar.xz
+      tar xf zig-x86_64-freebsd-0.15.1.tar.xz
-      sudo mv zig-freebsd-x86_64-0.13.0/zig /usr/bin/
+      sudo mv zig-x86_64-freebsd-0.15.1/zig /usr/bin/
-      sudo mv zig-freebsd-x86_64-0.13.0/lib /usr/lib/zig
+      sudo mv zig-x86_64-freebsd-0.15.1/lib /usr/lib/zig
   - build: |
-      cd river
+      cd river-classic
       zig build --summary all
   - build_xwayland: |
-      cd river
+      cd river-classic
       zig build --summary all -Dxwayland
   - fmt: |
-      cd river
+      cd river-classic
       zig fmt --check river/
       zig fmt --check riverctl/
       zig fmt --check rivertile/

.gitignore

@@ -1,4 +1,2 @@
 .zig-cache/
-zig-cache/
 zig-out/
-deps/

PACKAGING.md

@@ -1,39 +1,39 @@
-# Packaging river for distribution
+# Packaging river-classic for distribution
 
-First of all, I apologize for writing river in Zig. It will likely make
+First of all, I apologize for writing river-classic in Zig. It will likely make
 your job harder until Zig is more mature/stable. I do however believe that
-writing my software in Zig allows me to deliver the best quality I can
+writing my software in Zig allows me to deliver the best quality I can despite
-despite the drawbacks of depending on a relatively immature language/toolchain.
+the drawbacks of depending on a relatively immature language/toolchain.
 
 ## Source tarballs
 
-Source tarballs with stable checksums and git submodule sources included may
+Source tarballs with stable checksums may be found on the
-be found on the [codeberg releases page](https://codeberg.org/river/river/releases).
+[codeberg releases page](https://codeberg.org/river/river-classic/releases).
 These tarballs are signed with the PGP key available on my website at
 <https://isaacfreund.com/public_key.txt>.
 
-For the 0.1.3 release for example, the tarball and signature URLs are:
+For the 0.3.12 release for example, the tarball and signature URLs are:
 ```
-https://codeberg.org/river/river/releases/download/v0.1.3/river-0.1.3.tar.gz
+https://codeberg.org/river/river-classic/releases/download/v0.1.3/river-classic-0.3.12.tar.gz
-https://codeberg.org/river/river/releases/download/v0.1.3/river-0.1.3.tar.gz.sig
+https://codeberg.org/river/river-classic/releases/download/v0.1.3/river-classic-0.3.12.tar.gz.sig
 ```
 
 ## Zig version
 
 Until Zig 1.0, Zig releases will often have breaking changes that prevent
-river from building. River tracks the latest minor version Zig release
+river-classic from building. river-classic tracks the latest minor version Zig
-and is only compatible with that release and any patch releases. At the time
+release and is only compatible with that release and any patch releases. At the
-of writing for example river is compatible with Zig 0.9.0 and 0.9.1 but
+time of writing for example river is compatible with Zig 0.9.0 and 0.9.1 but not
-not Zig 0.8.0 or 0.10.0.
+Zig 0.8.0 or 0.10.0.
 
 ## Zig Package Manager
 
-River uses the built-in Zig package manager for its (few) Zig dependencies.
+river-classic uses the built-in Zig package manager for its (few) Zig
-By default, running `zig build` will fetch river's Zig dependencies from the
+dependencies.  By default, running `zig build` will fetch river-classic's Zig
-internet and store them in the global zig cache before building river. Since
+dependencies from the internet and store them in the global zig cache before
-accessing the internet is forbidden or at least frowned upon by most distro
+building river-classic. Since accessing the internet is forbidden or at least
-packaging infrastructure, there are ways to fetch the Zig dependencies in a
+frowned upon by most distro packaging infrastructure, there are ways to fetch
-separate step before building river:
+the Zig dependencies in a separate step before building river-classic:
 
 1. Fetch step with internet access:
 
@@ -114,10 +114,10 @@ in the first place. For greatest effect, both may be used.
   - `-Doptimize=ReleaseSmall`: Optimize for binary size,
   disable all assertions and runtime safety checks.
 
-Please use `-Doptimize=ReleaseSafe` when building river for general
+Please use `-Doptimize=ReleaseSafe` when building river-classic for general use.
-use. CPU execution speed is not the performance bottleneck for river, the
+CPU execution speed is not the performance bottleneck for river-classic, the GPU
-GPU is. Additionally, the increased safety is more than worth the binary
+is. Additionally, the increased safety is more than worth the binary size
-size trade-off in my opinion.
+trade-off in my opinion.
 
 ## Build prefix and DESTDIR
 
@@ -126,7 +126,7 @@ environment variable. For example
 ```bash
 DESTDIR="/foo/bar" zig build --prefix /usr install
 ```
-will install river to `/foo/bar/usr/bin/river`.
+will install river-classic to `/foo/bar/usr/bin/river`.
 
 The Zig build system only has a single install step, there is no way to build
 artifacts for a given prefix and then install those artifacts to that prefix
@@ -147,7 +147,7 @@ install() {
 ## River specific suggestions
 
 I recommend installing the example init file found at `example/init` to
-`/usr/share/examples/river/init` or similar if your distribution has such
+`/usr/share/examples/river-classic/init` or similar if your distribution has such
 a convention.
 
 ## Examples

README.md

@@ -1,66 +1,59 @@
-<div align="center">
+# river-classic
-  <img src="logo/logo_text_adaptive_color.svg" width="600em">
-</div>
 
-## Overview
+river-classic is a dynamic tiling Wayland compositor with flexible runtime
-
-River is a dynamic tiling Wayland compositor with flexible runtime
 configuration.
 
-Check [packaging status](https://repology.org/project/river-compositor/versions) —
+It is a fork of [river](https://codeberg.org/river/river) 0.3 intended for users
+that are happy with how river 0.3 works and do not wish to deal with the majorly
+breaking changes planned for the river 0.4.0 release.
+
 Join us at [#river](https://web.libera.chat/?channels=#river) on irc.libera.chat —
-Read our man pages, [wiki](https://codeberg.org/river/wiki), and
+Read our man pages, [wiki](https://codeberg.org/river/wiki-classic), and
 [Code of Conduct](CODE_OF_CONDUCT.md)
 
-The main repository is on [codeberg](https://codeberg.org/river/river),
+The main repository is on [codeberg](https://codeberg.org/river/river-classic),
 which is where the issue tracker may be found and where contributions are accepted.
 
-Read-only mirrors exist on [sourcehut](https://git.sr.ht/~ifreund/river)
+Read-only mirrors exist on [sourcehut](https://git.sr.ht/~ifreund/river-classic)
-and [github](https://github.com/riverwm/river).
+and [github](https://github.com/riverwm/river-classic).
-
-*Note: river has not yet seen a stable 1.0 release and it will be necessary to
-make significant breaking changes before 1.0 to realize my longer term plans.
-That said, I do my best to avoid gratuitous breaking changes and bugs/crashes
-should be rare. If you find a bug don't hesitate to
-[open an issue](https://codeberg.org/river/river/issues/new/choose).*
 
 ## Features
 
-Currently river's window management style is quite similar to
+river-classic's window management style is quite similar to
 [dwm](http://dwm.suckless.org), [xmonad](https://xmonad.org), and other classic
 dynamic tiling X11 window managers. Windows are automatically arranged in a tiled
 layout and shifted around as windows are opened/closed.
 
 Rather than having the tiled layout logic built into the compositor process,
-river uses a [custom Wayland
+river-classic uses a [custom Wayland
-protocol](https://codeberg.org/river/river/src/branch/master/protocol/river-layout-v3.xml)
+protocol](https://codeberg.org/river/river-classic/src/branch/master/protocol/river-layout-v3.xml)
 and separate "layout generator" process. A basic layout generator, `rivertile`,
 is provided but users are encouraged to use community-developed [layout
 generators](https://codeberg.org/river/wiki/src/branch/master/pages/Community-Layouts.md)
 or write their own. Examples in C and Python may be found
-[here](https://codeberg.org/river/river/src/branch/master/contrib).
+[here](https://codeberg.org/river/river-classic/src/branch/master/contrib).
 
 Tags are used to organize windows rather than workspaces. A window may be
 assigned to one or more tags. Likewise, one or more tags may be displayed on a
 monitor at a time.
 
-River is configured at runtime using the `riverctl` tool. It can define
+river-classic is configured at runtime using the `riverctl` tool. It can define
 keybindings, set the active layout generator, configure input devices, and more.
-On startup, river runs a user-defined init script which usually runs `riverctl`
+On startup, river-classic runs a user-defined init script which usually runs
-commands to set up the user's configuration.
+`riverctl` commands to set up the user's configuration.
 
 ## Building
 
-Note: If you are packaging river for distribution, see [PACKAGING.md](PACKAGING.md).
+Note: If you are packaging river-classic for distribution, see [PACKAGING.md](PACKAGING.md).
 
-To compile river first ensure that you have the following dependencies
+To compile river-classic first ensure that you have the following dependencies
 installed. The "development" versions are required if applicable to your
 distribution.
 
-- [zig](https://ziglang.org/download/) 0.13
+- [zig](https://ziglang.org/download/) 0.15
 - wayland
 - wayland-protocols
-- [wlroots](https://gitlab.freedesktop.org/wlroots/wlroots) 0.18
+- [wlroots](https://gitlab.freedesktop.org/wlroots/wlroots) 0.19
 - xkbcommon
 - libevdev
 - pixman
@@ -79,7 +72,7 @@ Run `zig build -h` to see a list of all options.
 River can either be run nested in an X11/Wayland session or directly
 from a tty using KMS/DRM. Simply run the `river` command.
 
-On startup river will run an executable file at `$XDG_CONFIG_HOME/river/init`
+On startup river-classic will run an executable file at `$XDG_CONFIG_HOME/river/init`
 if such an executable exists. If `$XDG_CONFIG_HOME` is not set,
 `~/.config/river/init` will be used instead.
 
@@ -93,34 +86,14 @@ in the example directory.
 For complete documentation see the `river(1)`, `riverctl(1)`, and
 `rivertile(1)` man pages.
 
-## Future Plans
-
-Currently details such as how tags work across multiple monitors are not
-possible for users to configure. It would be possible to extend river's source
-code to allow more flexibility here but this comes at the cost of complexity and
-there will always be someone who prefers something slightly different.
-
-My long term plan to address this is to move as much window management policy as
-possible out of the river compositor process and into the "layout generator"
-process which will need to be renamed to "window manager." This will give users
-much more power and control over river's behavior and also enable some really
-cool workflows. For example, it would be possible to write a window manager in
-lisp and use hot code reloading to edit its behavior it while it is running.
-
-This is a non-trivial architectural change and will take a while to implement. I
-plan to focus on this change for the 0.4.0 release cycle. Unfortunately, it will
-almost certainly break existing river configurations as well. I think the
-benefits outweigh that downside though and I will do my best to offer a
-reasonable upgrade path.
-
 ## Donate
 
-If my work on river adds value to your life and you'd like to support me
+If my work on river-classic adds value to your life and you'd like to support me
 financially you can find donation information [here](https://isaacfreund.com/donate/).
 
 ## Licensing
 
-River is released under the GNU General Public License v3.0 only.
+river-classic is released under the GNU General Public License v3.0 only.
 
 The protocols in the `protocol` directory are released under various licenses by
 various parties. You should refer to the copyright block of each protocol for

build.zig

@@ -4,13 +4,7 @@ const Build = std.Build;
 const fs = std.fs;
 const mem = std.mem;
 
-const Scanner = @import("zig-wayland").Scanner;
+const Scanner = @import("wayland").Scanner;
-
-/// While a river release is in development, this string should contain the version in development
-/// with the "-dev" suffix.
-/// When a release is tagged, the "-dev" suffix should be removed for the commit that gets tagged.
-/// Directly after the tagged commit, the version should be bumped and the "-dev" suffix added.
-const version = "0.4.0-dev";
 
 pub fn build(b: *Build) !void {
     const target = b.standardTargetOptions(.{});
@@ -18,7 +12,6 @@ pub fn build(b: *Build) !void {
 
     const strip = b.option(bool, "strip", "Omit debug information") orelse false;
     const pie = b.option(bool, "pie", "Build a Position Independent Executable") orelse false;
-    const llvm = !(b.option(bool, "no-llvm", "(expirimental) Use non-LLVM x86 Zig backend") orelse false);
 
     const omit_frame_pointer = switch (optimize) {
         .Debug, .ReleaseSafe => false,
@@ -71,7 +64,7 @@ pub fn build(b: *Build) !void {
                 .Inherit,
             ) catch break :blk version;
 
-            var it = mem.split(u8, mem.trim(u8, git_describe_long, &std.ascii.whitespace), "-");
+            var it = mem.splitScalar(u8, mem.trim(u8, git_describe_long, &std.ascii.whitespace), '-');
             _ = it.next().?; // previous tag
             const commit_count = it.next().?;
             const commit_hash = it.next().?;
@@ -136,10 +129,10 @@ pub fn build(b: *Build) !void {
 
     const wayland = b.createModule(.{ .root_source_file = scanner.result });
 
-    const xkbcommon = b.dependency("zig-xkbcommon", .{}).module("xkbcommon");
+    const xkbcommon = b.dependency("xkbcommon", .{}).module("xkbcommon");
-    const pixman = b.dependency("zig-pixman", .{}).module("pixman");
+    const pixman = b.dependency("pixman", .{}).module("pixman");
 
-    const wlroots = b.dependency("zig-wlroots", .{}).module("wlroots");
+    const wlroots = b.dependency("wlroots", .{}).module("wlroots");
     wlroots.addImport("wayland", wayland);
     wlroots.addImport("xkbcommon", xkbcommon);
     wlroots.addImport("pixman", pixman);
@@ -148,7 +141,7 @@ pub fn build(b: *Build) !void {
     // exposed to the wlroots module for @cImport() to work. This seems to be
     // the best way to do so with the current std.Build API.
     wlroots.resolved_target = target;
-    wlroots.linkSystemLibrary("wlroots-0.18", .{});
+    wlroots.linkSystemLibrary("wlroots-0.19", .{});
 
     const flags = b.createModule(.{ .root_source_file = b.path("common/flags.zig") });
     const globber = b.createModule(.{ .root_source_file = b.path("common/globber.zig") });
@@ -156,12 +149,12 @@ pub fn build(b: *Build) !void {
     {
         const river = b.addExecutable(.{
             .name = "river",
-            .root_source_file = b.path("river/main.zig"),
+            .root_module = b.createModule(.{
-            .target = target,
+                .root_source_file = b.path("river/main.zig"),
-            .optimize = optimize,
+                .target = target,
-            .strip = strip,
+                .optimize = optimize,
-            .use_llvm = llvm,
+                .strip = strip,
-            .use_lld = llvm,
+            }),
         });
         river.root_module.addOptions("build_options", options);
 
@@ -169,7 +162,7 @@ pub fn build(b: *Build) !void {
         river.linkSystemLibrary("libevdev");
         river.linkSystemLibrary("libinput");
         river.linkSystemLibrary("wayland-server");
-        river.linkSystemLibrary("wlroots-0.18");
+        river.linkSystemLibrary("wlroots-0.19");
         river.linkSystemLibrary("xkbcommon");
         river.linkSystemLibrary("pixman-1");
 
@@ -194,12 +187,12 @@ pub fn build(b: *Build) !void {
     {
         const riverctl = b.addExecutable(.{
             .name = "riverctl",
-            .root_source_file = b.path("riverctl/main.zig"),
+            .root_module = b.createModule(.{
-            .target = target,
+                .root_source_file = b.path("riverctl/main.zig"),
-            .optimize = optimize,
+                .target = target,
-            .strip = strip,
+                .optimize = optimize,
-            .use_llvm = llvm,
+                .strip = strip,
-            .use_lld = llvm,
+            }),
         });
         riverctl.root_module.addOptions("build_options", options);
 
@@ -217,12 +210,12 @@ pub fn build(b: *Build) !void {
     {
         const rivertile = b.addExecutable(.{
             .name = "rivertile",
-            .root_source_file = b.path("rivertile/main.zig"),
+            .root_module = b.createModule(.{
-            .target = target,
+                .root_source_file = b.path("rivertile/main.zig"),
-            .optimize = optimize,
+                .target = target,
-            .strip = strip,
+                .optimize = optimize,
-            .use_llvm = llvm,
+                .strip = strip,
-            .use_lld = llvm,
+            }),
         });
         rivertile.root_module.addOptions("build_options", options);
 
@@ -281,9 +274,11 @@ pub fn build(b: *Build) !void {
 
     {
         const globber_test = b.addTest(.{
-            .root_source_file = b.path("common/globber.zig"),
+            .root_module = b.createModule(.{
-            .target = target,
+                .root_source_file = b.path("common/globber.zig"),
-            .optimize = optimize,
+                .target = target,
+                .optimize = optimize,
+            }),
         });
         const run_globber_test = b.addRunArtifact(globber_test);
 
@@ -291,3 +286,31 @@ pub fn build(b: *Build) !void {
         test_step.dependOn(&run_globber_test.step);
     }
 }
+
+const version = manifest.version;
+/// Getting rid of this wart requires upstream zig improvements.
+/// See: https://github.com/ziglang/zig/issues/22775
+const manifest: struct {
+    name: @Type(.enum_literal),
+    version: []const u8,
+    paths: []const []const u8,
+    dependencies: struct {
+        pixman: struct {
+            url: []const u8,
+            hash: []const u8,
+        },
+        wayland: struct {
+            url: []const u8,
+            hash: []const u8,
+        },
+        wlroots: struct {
+            url: []const u8,
+            hash: []const u8,
+        },
+        xkbcommon: struct {
+            url: []const u8,
+            hash: []const u8,
+        },
+    },
+    fingerprint: u64,
+} = @import("build.zig.zon");

build.zig.zon

@@ -1,23 +1,29 @@
 .{
-    .name = "river",
+    .name = .river_classic,
-    .version = "0.4.0-dev",
+    // While a river release is in development, this string should contain
+    // the version in development with the "-dev" suffix.
+    // When a release is tagged, the "-dev" suffix should be removed for the
+    // commit that gets tagged. Directly after the tagged commit, the version
+    // should be bumped and the "-dev" suffix added.
+    .version = "0.3.14-dev",
     .paths = .{""},
     .dependencies = .{
-        .@"zig-pixman" = .{
+        .pixman = .{
-            .url = "https://codeberg.org/ifreund/zig-pixman/archive/v0.2.0.tar.gz",
+            .url = "https://codeberg.org/ifreund/zig-pixman/archive/v0.3.0.tar.gz",
-            .hash = "12209db20ce873af176138b76632931def33a10539387cba745db72933c43d274d56",
+            .hash = "pixman-0.3.0-LClMnz2VAAAs7QSCGwLimV5VUYx0JFnX5xWU6HwtMuDX",
         },
-        .@"zig-wayland" = .{
+        .wayland = .{
-            .url = "https://codeberg.org/ifreund/zig-wayland/archive/bd8afd256fb6beed7d72e3580b00f33dea7155a1.tar.gz",
+            .url = "https://codeberg.org/ifreund/zig-wayland/archive/v0.4.0.tar.gz",
-            .hash = "1220218a0e5c2cd63a2311417f4d3f2411dd17d75815f67c704ee657bd846ecbc3e0",
+            .hash = "wayland-0.4.0-lQa1khbMAQAsLS2eBR7M5lofyEGPIbu2iFDmoz8lPC27",
         },
-        .@"zig-wlroots" = .{
+        .wlroots = .{
-            .url = "https://codeberg.org/ifreund/zig-wlroots/archive/afbbbbe5579c750feed8de12b073fa50b0651137.tar.gz",
+            .url = "https://codeberg.org/ifreund/zig-wlroots/archive/v0.19.3.tar.gz",
-            .hash = "122060ddef836b7872cb2088764a8bd2fb2e9254327673e8176b7f7a621ec897484f",
+            .hash = "wlroots-0.19.3-jmOlcuL_AwBHhLCwpFsXbTizE3q9BugFmGX-XIxqcPMc",
         },
-        .@"zig-xkbcommon" = .{
+        .xkbcommon = .{
-            .url = "https://codeberg.org/ifreund/zig-xkbcommon/archive/v0.2.0.tar.gz",
+            .url = "https://codeberg.org/ifreund/zig-xkbcommon/archive/v0.3.0.tar.gz",
-            .hash = "1220c90b2228d65fd8427a837d31b0add83e9fade1dcfa539bb56fd06f1f8461605f",
+            .hash = "xkbcommon-0.3.0-VDqIe3K9AQB2fG5ZeRcMC9i7kfrp5m2rWgLrmdNn9azr",
         },
     },
+    .fingerprint = 0x3dae7aba2ea52a3b,
 }

common/flags.zig

@@ -42,21 +42,21 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {
                         .boolean => .{
                             .name = flag.name,
                             .type = bool,
-                            .default_value = &false,
+                            .default_value_ptr = &false,
                             .is_comptime = false,
                             .alignment = @alignOf(bool),
                         },
                         .arg => .{
                             .name = flag.name,
                             .type = ?[:0]const u8,
-                            .default_value = &@as(?[:0]const u8, null),
+                            .default_value_ptr = &@as(?[:0]const u8, null),
                             .is_comptime = false,
                             .alignment = @alignOf(?[:0]const u8),
                         },
                     };
                     fields = fields ++ [_]std.builtin.Type.StructField{field};
                 }
-                break :flags_type @Type(.{ .Struct = .{
+                break :flags_type @Type(.{ .@"struct" = .{
                     .layout = .auto,
                     .fields = fields,
                     .decls = &.{},

river/Control.zig

@@ -84,7 +84,7 @@ fn handleRequest(control_v1: *zriver.ControlV1, request: zriver.ControlV1.Reques
             };
         },
         .run_command => |run_command| {
-            const seat: *Seat = @ptrFromInt(wlr.Seat.Client.fromWlSeat(run_command.seat).?.seat.data);
+            const seat: *Seat = @ptrCast(@alignCast(wlr.Seat.Client.fromWlSeat(run_command.seat).?.seat.data));
 
             const callback = zriver.CommandCallbackV1.create(
                 control_v1.getClient(),

river/Cursor.zig

@@ -26,7 +26,7 @@ const wayland = @import("wayland");
 const wl = wayland.server.wl;
 const zwlr = wayland.server.zwlr;
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 const server = &@import("main.zig").server;
 const util = @import("util.zig");
 
@@ -138,7 +138,7 @@ wlr_cursor: *wlr.Cursor,
 /// Xcursor manager for the currently configured Xcursor theme.
 xcursor_manager: *wlr.XcursorManager,
 image: Image = .none,
-image_surface_destroy: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleImageSurfaceDestroy),
+image_surface_destroy: wl.Listener(*wlr.Surface) = .init(handleImageSurfaceDestroy),
 
 /// Number of distinct buttons currently pressed
 pressed_count: u32 = 0,
@@ -255,6 +255,30 @@ pub fn init(cursor: *Cursor, seat: *Seat) !void {
 }
 
 pub fn deinit(cursor: *Cursor) void {
+    cursor.axis.link.remove();
+    cursor.button.link.remove();
+    cursor.frame.link.remove();
+    cursor.motion_absolute.link.remove();
+    cursor.motion.link.remove();
+    cursor.swipe_begin.link.remove();
+    cursor.swipe_update.link.remove();
+    cursor.swipe_end.link.remove();
+    cursor.pinch_begin.link.remove();
+    cursor.pinch_update.link.remove();
+    cursor.pinch_end.link.remove();
+    cursor.request_set_cursor.link.remove();
+
+    cursor.touch_down.link.remove();
+    cursor.touch_motion.link.remove();
+    cursor.touch_up.link.remove();
+    cursor.touch_cancel.link.remove();
+    cursor.touch_frame.link.remove();
+
+    cursor.tablet_tool_axis.link.remove();
+    cursor.tablet_tool_proximity.link.remove();
+    cursor.tablet_tool_tip.link.remove();
+    cursor.tablet_tool_button.link.remove();
+
     cursor.hide_cursor_timer.remove();
     cursor.xcursor_manager.destroy();
     cursor.wlr_cursor.destroy();
@@ -272,7 +296,7 @@ pub fn setTheme(cursor: *Cursor, theme: ?[*:0]const u8, _size: ?u32) !void {
     // If this cursor belongs to the default seat, set the xcursor environment
     // variables as well as the xwayland cursor theme.
     if (cursor.seat == server.input_manager.defaultSeat()) {
-        const size_str = try std.fmt.allocPrintZ(util.gpa, "{}", .{size});
+        const size_str = try std.fmt.allocPrintSentinel(util.gpa, "{}", .{size}, 0);
         defer util.gpa.free(size_str);
         if (c.setenv("XCURSOR_SIZE", size_str.ptr, 1) < 0) return error.OutOfMemory;
         if (theme) |t| if (c.setenv("XCURSOR_THEME", t, 1) < 0) return error.OutOfMemory;
@@ -338,7 +362,7 @@ fn clearFocus(cursor: *Cursor) void {
 /// Axis event is a scroll wheel or similiar
 fn handleAxis(listener: *wl.Listener(*wlr.Pointer.event.Axis), event: *wlr.Pointer.event.Axis) void {
     const cursor: *Cursor = @fieldParentPtr("axis", listener);
-    const device: *InputDevice = @ptrFromInt(event.device.data);
+    const device: *InputDevice = @ptrCast(@alignCast(event.device.data));
 
     cursor.seat.handleActivity();
     cursor.unhide();
@@ -354,8 +378,8 @@ fn handleAxis(listener: *wl.Listener(*wlr.Pointer.event.Axis), event: *wlr.Point
             // @intFromFloat() call safe due to the max/min i32 not being exactly representable
             // by an f32. Dividing by 2 is a low effort way to ensure the value is in bounds and
             // allow users to set their scroll-factor to inf without crashing river.
-            math.minInt(i32) / 2,
+            @as(f32, @floatFromInt(math.minInt(i32) / 2)),
-            math.maxInt(i32) / 2,
+            @as(f32, @floatFromInt(math.maxInt(i32) / 2)),
         )),
         event.source,
         event.relative_direction,
@@ -458,7 +482,7 @@ fn updateKeyboardFocus(cursor: Cursor, result: Root.AtResult) void {
 /// Requires a call to Root.applyPending()
 fn updateOutputFocus(cursor: Cursor, lx: f64, ly: f64) void {
     if (server.root.output_layout.outputAt(lx, ly)) |wlr_output| {
-        const output: *Output = @ptrFromInt(wlr_output.data);
+        const output: *Output = @ptrCast(@alignCast(wlr_output.data));
         cursor.seat.focusOutput(output);
     }
 }
@@ -635,7 +659,7 @@ fn handleTabletToolAxis(
     _: *wl.Listener(*wlr.Tablet.event.Axis),
     event: *wlr.Tablet.event.Axis,
 ) void {
-    const device: *InputDevice = @ptrFromInt(event.device.data);
+    const device: *InputDevice = @ptrCast(@alignCast(event.device.data));
     const tablet: *Tablet = @fieldParentPtr("device", device);
 
     device.seat.handleActivity();
@@ -649,7 +673,7 @@ fn handleTabletToolProximity(
     _: *wl.Listener(*wlr.Tablet.event.Proximity),
     event: *wlr.Tablet.event.Proximity,
 ) void {
-    const device: *InputDevice = @ptrFromInt(event.device.data);
+    const device: *InputDevice = @ptrCast(@alignCast(event.device.data));
     const tablet: *Tablet = @fieldParentPtr("device", device);
 
     device.seat.handleActivity();
@@ -663,7 +687,7 @@ fn handleTabletToolTip(
     _: *wl.Listener(*wlr.Tablet.event.Tip),
     event: *wlr.Tablet.event.Tip,
 ) void {
-    const device: *InputDevice = @ptrFromInt(event.device.data);
+    const device: *InputDevice = @ptrCast(@alignCast(event.device.data));
     const tablet: *Tablet = @fieldParentPtr("device", device);
 
     device.seat.handleActivity();
@@ -677,7 +701,7 @@ fn handleTabletToolButton(
     _: *wl.Listener(*wlr.Tablet.event.Button),
     event: *wlr.Tablet.event.Button,
 ) void {
-    const device: *InputDevice = @ptrFromInt(event.device.data);
+    const device: *InputDevice = @ptrCast(@alignCast(event.device.data));
     const tablet: *Tablet = @fieldParentPtr("device", device);
 
     device.seat.handleActivity();
@@ -798,6 +822,7 @@ pub fn hide(cursor: *Cursor) void {
 
     cursor.hidden = true;
     cursor.wlr_cursor.unsetImage();
+    cursor.seat.wlr_seat.pointerNotifyClearFocus();
     cursor.hide_cursor_timer.timerUpdate(0) catch {
         log.err("failed to update cursor hide timeout", .{});
     };
@@ -1129,13 +1154,12 @@ pub fn updateState(cursor: *Cursor) void {
         .passthrough => {
             cursor.updateFocusFollowsCursorTarget();
             if (!cursor.hidden) {
-                var now: posix.timespec = undefined;
+                const now = posix.clock_gettime(.MONOTONIC) catch @panic("CLOCK_MONOTONIC not supported");
-                posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
                 // 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),
+                    now.sec *% std.time.ms_per_s +% @divTrunc(now.nsec, std.time.ns_per_ms),
                     math.maxInt(u32),
                 ));
                 cursor.passthrough(msec);
@@ -1264,7 +1288,7 @@ fn warp(cursor: *Cursor) void {
     };
     if (!output_layout_box.containsPoint(cursor.wlr_cursor.x, cursor.wlr_cursor.y) or
         (usable_layout_box.containsPoint(cursor.wlr_cursor.x, cursor.wlr_cursor.y) and
-        !target_box.containsPoint(cursor.wlr_cursor.x, cursor.wlr_cursor.y)))
+            !target_box.containsPoint(cursor.wlr_cursor.x, cursor.wlr_cursor.y)))
     {
         const lx: f64 = @floatFromInt(target_box.x + @divTrunc(target_box.width, 2));
         const ly: f64 = @floatFromInt(target_box.y + @divTrunc(target_box.height, 2));
@@ -1277,7 +1301,7 @@ fn warp(cursor: *Cursor) void {
 fn updateDragIcons(cursor: *Cursor) void {
     var it = server.root.drag_icons.children.iterator(.forward);
     while (it.next()) |node| {
-        const icon = @as(*DragIcon, @ptrFromInt(node.data));
+        const icon: *DragIcon = @ptrCast(@alignCast(node.data));
 
         if (icon.wlr_drag_icon.drag.seat == cursor.seat.wlr_seat) {
             icon.updatePosition(cursor);

river/DragIcon.zig

@@ -42,7 +42,7 @@ pub fn create(wlr_drag_icon: *wlr.Drag.Icon, cursor: *Cursor) error{OutOfMemory}
         .wlr_drag_icon = wlr_drag_icon,
         .scene_drag_icon = scene_drag_icon,
     };
-    scene_drag_icon.node.data = @intFromPtr(drag_icon);
+    scene_drag_icon.node.data = drag_icon;
 
     drag_icon.updatePosition(cursor);
 

river/ForeignToplevelHandle.zig

@@ -89,7 +89,7 @@ fn handleForeignActivate(
 ) void {
     const handle: *ForeignToplevelHandle = @fieldParentPtr("foreign_activate", listener);
     const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
-    const seat: *Seat = @ptrFromInt(event.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(event.seat.data));
 
     seat.focus(view);
     server.root.applyPending();

river/IdleInhibitManager.zig

@@ -30,28 +30,29 @@ const View = @import("View.zig");
 wlr_manager: *wlr.IdleInhibitManagerV1,
 new_idle_inhibitor: wl.Listener(*wlr.IdleInhibitorV1) =
     wl.Listener(*wlr.IdleInhibitorV1).init(handleNewIdleInhibitor),
-inhibitors: std.TailQueue(IdleInhibitor) = .{},
+inhibitors: wl.list.Head(IdleInhibitor, .link),
 
 pub fn init(inhibit_manager: *IdleInhibitManager) !void {
     inhibit_manager.* = .{
         .wlr_manager = try wlr.IdleInhibitManagerV1.create(server.wl_server),
+        .inhibitors = undefined,
     };
+    inhibit_manager.inhibitors.init();
     inhibit_manager.wlr_manager.events.new_inhibitor.add(&inhibit_manager.new_idle_inhibitor);
 }
 
 pub fn deinit(inhibit_manager: *IdleInhibitManager) void {
-    while (inhibit_manager.inhibitors.pop()) |inhibitor| {
+    while (inhibit_manager.inhibitors.first()) |inhibitor| {
-        inhibitor.data.destroy.link.remove();
+        inhibitor.destroy();
-        util.gpa.destroy(inhibitor);
     }
     inhibit_manager.new_idle_inhibitor.link.remove();
 }
 
 pub fn checkActive(inhibit_manager: *IdleInhibitManager) void {
     var inhibited = false;
-    var it = inhibit_manager.inhibitors.first;
+    var it = inhibit_manager.inhibitors.iterator(.forward);
-    while (it) |node| : (it = node.next) {
+    while (it.next()) |inhibitor| {
-        const node_data = SceneNodeData.fromSurface(node.data.wlr_inhibitor.surface) orelse continue;
+        const node_data = SceneNodeData.fromSurface(inhibitor.wlr_inhibitor.surface) orelse continue;
         switch (node_data.data) {
             .view => |view| {
                 if (view.current.output != null and
@@ -79,13 +80,8 @@ pub fn checkActive(inhibit_manager: *IdleInhibitManager) void {
 
 fn handleNewIdleInhibitor(listener: *wl.Listener(*wlr.IdleInhibitorV1), inhibitor: *wlr.IdleInhibitorV1) void {
     const inhibit_manager: *IdleInhibitManager = @fieldParentPtr("new_idle_inhibitor", listener);
-    const inhibitor_node = util.gpa.create(std.TailQueue(IdleInhibitor).Node) catch return;
+    IdleInhibitor.create(inhibitor, inhibit_manager) catch {
-    inhibitor_node.data.init(inhibitor, inhibit_manager) catch {
+        std.log.err("out of memory", .{});
-        util.gpa.destroy(inhibitor_node);
         return;
     };
-
-    inhibit_manager.inhibitors.append(inhibitor_node);
-
-    inhibit_manager.checkActive();
 }

river/IdleInhibitor.zig

@@ -28,31 +28,38 @@ const IdleInhibitManager = @import("IdleInhibitManager.zig");
 inhibit_manager: *IdleInhibitManager,
 wlr_inhibitor: *wlr.IdleInhibitorV1,
 
-destroy: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleDestroy),
+listen_destroy: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleDestroy),
+
+link: wl.list.Link,
+
+pub fn create(wlr_inhibitor: *wlr.IdleInhibitorV1, inhibit_manager: *IdleInhibitManager) !void {
+    const inhibitor = try util.gpa.create(IdleInhibitor);
+    errdefer util.gpa.destroy(inhibitor);
 
-pub fn init(
-    inhibitor: *IdleInhibitor,
-    wlr_inhibitor: *wlr.IdleInhibitorV1,
-    inhibit_manager: *IdleInhibitManager,
-) !void {
     inhibitor.* = .{
         .inhibit_manager = inhibit_manager,
         .wlr_inhibitor = wlr_inhibitor,
+        .link = undefined,
     };
-    wlr_inhibitor.events.destroy.add(&inhibitor.destroy);
+    wlr_inhibitor.events.destroy.add(&inhibitor.listen_destroy);
+
+    inhibit_manager.inhibitors.append(inhibitor);
 
     inhibit_manager.checkActive();
 }
 
-fn handleDestroy(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
+pub fn destroy(inhibitor: *IdleInhibitor) void {
-    const inhibitor: *IdleInhibitor = @fieldParentPtr("destroy", listener);
+    inhibitor.listen_destroy.link.remove();
 
-    inhibitor.destroy.link.remove();
+    inhibitor.link.remove();
-
-    const node: *std.TailQueue(IdleInhibitor).Node = @fieldParentPtr("data", inhibitor);
-    server.idle_inhibit_manager.inhibitors.remove(node);
 
     inhibitor.inhibit_manager.checkActive();
 
-    util.gpa.destroy(node);
+    util.gpa.destroy(inhibitor);
+}
+
+fn handleDestroy(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
+    const inhibitor: *IdleInhibitor = @fieldParentPtr("listen_destroy", listener);
+
+    inhibitor.destroy();
 }

river/InputConfig.zig

@@ -25,7 +25,7 @@ const wlr = @import("wlroots");
 
 const log = std.log.scoped(.input_config);
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 
 const server = &@import("main.zig").server;
 const util = @import("util.zig");
@@ -307,7 +307,7 @@ pub fn apply(config: *const InputConfig, device: *InputDevice) void {
     const libinput_device: *c.libinput_device = @ptrCast(device.wlr_device.getLibinputDevice() orelse return);
     log.debug("applying input configuration '{s}' to device '{s}'.", .{ config.glob, device.identifier });
 
-    inline for (@typeInfo(InputConfig).Struct.fields) |field| {
+    inline for (@typeInfo(InputConfig).@"struct".fields) |field| {
         if (comptime mem.eql(u8, field.name, "glob")) continue;
 
         if (@field(config, field.name)) |setting| {
@@ -324,7 +324,7 @@ pub fn apply(config: *const InputConfig, device: *InputDevice) void {
 }
 
 pub fn parse(config: *InputConfig, setting: []const u8, value: []const u8) !void {
-    inline for (@typeInfo(InputConfig).Struct.fields) |field| {
+    inline for (@typeInfo(InputConfig).@"struct".fields) |field| {
         if (comptime mem.eql(u8, field.name, "glob")) continue;
 
         if (mem.eql(u8, setting, field.name)) {
@@ -358,8 +358,8 @@ pub fn parse(config: *InputConfig, setting: []const u8, value: []const u8) !void
                 }
                 config.@"map-to-output" = .{ .output_name = output_name_owned };
             } else {
-                const T = @typeInfo(field.type).Optional.child;
+                const T = @typeInfo(field.type).optional.child;
-                if (@typeInfo(T) != .Enum) {
+                if (@typeInfo(T) != .@"enum") {
                     @compileError("You forgot to implement parsing for an input configuration setting.");
                 }
                 @field(config, field.name) = meta.stringToEnum(T, value) orelse
@@ -373,10 +373,10 @@ pub fn parse(config: *InputConfig, setting: []const u8, value: []const u8) !void
     return error.UnknownCommand;
 }
 
-pub fn write(config: *InputConfig, writer: anytype) !void {
+pub fn write(config: *InputConfig, writer: *std.Io.Writer) !void {
     try writer.print("{s}\n", .{config.glob});
 
-    inline for (@typeInfo(InputConfig).Struct.fields) |field| {
+    inline for (@typeInfo(InputConfig).@"struct".fields) |field| {
         if (comptime mem.eql(u8, field.name, "glob")) continue;
 
         if (comptime mem.eql(u8, field.name, "map-to-output")) {
@@ -396,8 +396,8 @@ pub fn write(config: *InputConfig, writer: anytype) !void {
                     mem.sliceTo(c.libevdev_event_code_get_name(c.EV_KEY, setting.button), 0),
                 });
             } else {
-                const T = @typeInfo(field.type).Optional.child;
+                const T = @typeInfo(field.type).optional.child;
-                if (@typeInfo(T) != .Enum) {
+                if (@typeInfo(T) != .@"enum") {
                     @compileError("You forgot to implement listing for an input configuration setting.");
                 }
                 try writer.print("\t{s}: {s}\n", .{ field.name, @tagName(setting) });

river/InputDevice.zig

@@ -24,7 +24,7 @@ const wl = @import("wayland").server.wl;
 
 const globber = @import("globber");
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 const server = &@import("main.zig").server;
 const util = @import("util.zig");
 
@@ -86,7 +86,7 @@ pub fn init(device: *InputDevice, seat: *Seat, wlr_device: *wlr.InputDevice) !vo
         .link = undefined,
     };
 
-    wlr_device.data = @intFromPtr(device);
+    wlr_device.data = device;
 
     wlr_device.events.destroy.add(&device.destroy);
 
@@ -117,7 +117,7 @@ pub fn deinit(device: *InputDevice) void {
         device.seat.updateCapabilities();
     }
 
-    device.wlr_device.data = 0;
+    device.wlr_device.data = null;
 
     device.* = undefined;
 }

river/InputManager.zig

@@ -55,10 +55,10 @@ tablet_manager: *wlr.TabletManagerV2,
 
 /// List of input device configurations. Ordered by glob generality, with
 /// the most general towards the start and the most specific towards the end.
-configs: std.ArrayList(InputConfig),
+configs: std.ArrayList(InputConfig) = .{},
 
 devices: wl.list.Head(InputDevice, .link),
-seats: std.TailQueue(Seat) = .{},
+seats: wl.list.Head(Seat, .link),
 
 exclusive_client: ?*wl.Client = null,
 
@@ -74,9 +74,6 @@ new_text_input: wl.Listener(*wlr.TextInputV3) =
     wl.Listener(*wlr.TextInputV3).init(handleNewTextInput),
 
 pub fn init(input_manager: *InputManager) !void {
-    const seat_node = try util.gpa.create(std.TailQueue(Seat).Node);
-    errdefer util.gpa.destroy(seat_node);
-
     input_manager.* = .{
         // These are automatically freed when the display is destroyed
         .idle_notifier = try wlr.IdleNotifierV1.create(server.wl_server),
@@ -88,14 +85,14 @@ pub fn init(input_manager: *InputManager) !void {
         .input_method_manager = try wlr.InputMethodManagerV2.create(server.wl_server),
         .text_input_manager = try wlr.TextInputManagerV3.create(server.wl_server),
         .tablet_manager = try wlr.TabletManagerV2.create(server.wl_server),
-        .configs = std.ArrayList(InputConfig).init(util.gpa),
 
+        .seats = undefined,
         .devices = undefined,
     };
+    input_manager.seats.init();
     input_manager.devices.init();
 
-    input_manager.seats.prepend(seat_node);
+    try Seat.create(default_seat_name);
-    try seat_node.data.init(default_seat_name);
 
     if (build_options.xwayland) {
         if (server.xwayland) |xwayland| {
@@ -121,19 +118,18 @@ pub fn deinit(input_manager: *InputManager) void {
     input_manager.new_input_method.link.remove();
     input_manager.new_text_input.link.remove();
 
-    while (input_manager.seats.pop()) |seat_node| {
+    while (input_manager.seats.first()) |seat| {
-        seat_node.data.deinit();
+        seat.destroy();
-        util.gpa.destroy(seat_node);
     }
 
     for (input_manager.configs.items) |*config| {
         config.deinit();
     }
-    input_manager.configs.deinit();
+    input_manager.configs.deinit(util.gpa);
 }
 
-pub fn defaultSeat(input_manager: InputManager) *Seat {
+pub fn defaultSeat(input_manager: *InputManager) *Seat {
-    return &input_manager.seats.first.?.data;
+    return input_manager.seats.first().?;
 }
 
 /// Returns true if input is currently allowed on the passed surface.
@@ -160,7 +156,7 @@ pub fn reconfigureDevices(input_manager: *InputManager) void {
 fn handleNewInput(listener: *wl.Listener(*wlr.InputDevice), wlr_device: *wlr.InputDevice) void {
     const input_manager: *InputManager = @fieldParentPtr("new_input", listener);
 
-    input_manager.defaultSeat().addDevice(wlr_device);
+    input_manager.defaultSeat().addDevice(wlr_device, false);
 }
 
 fn handleNewVirtualPointer(
@@ -178,17 +174,53 @@ fn handleNewVirtualPointer(
         log.debug("Ignoring output suggestion from virtual pointer", .{});
     }
 
-    input_manager.defaultSeat().addDevice(&event.new_pointer.pointer.base);
+    input_manager.defaultSeat().addDevice(&event.new_pointer.pointer.base, true);
 }
 
 fn handleNewVirtualKeyboard(
     _: *wl.Listener(*wlr.VirtualKeyboardV1),
     virtual_keyboard: *wlr.VirtualKeyboardV1,
 ) void {
-    const seat: *Seat = @ptrFromInt(virtual_keyboard.seat.data);
+    const no_keymap = util.gpa.create(NoKeymapVirtKeyboard) catch {
-    seat.addDevice(&virtual_keyboard.keyboard.base);
+        log.err("out of memory", .{});
+        return;
+    };
+    errdefer util.gpa.destroy(no_keymap);
+
+    no_keymap.* = .{
+        .virtual_keyboard = virtual_keyboard,
+    };
+    virtual_keyboard.keyboard.base.events.destroy.add(&no_keymap.destroy);
+    virtual_keyboard.keyboard.events.keymap.add(&no_keymap.keymap);
 }
 
+/// Ignore virtual keyboards completely until the client sets a keymap
+/// Yes, wlroots should probably do this for us.
+const NoKeymapVirtKeyboard = struct {
+    virtual_keyboard: *wlr.VirtualKeyboardV1,
+    destroy: wl.Listener(*wlr.InputDevice) = .init(handleDestroy),
+    keymap: wl.Listener(*wlr.Keyboard) = .init(handleKeymap),
+
+    fn handleDestroy(listener: *wl.Listener(*wlr.InputDevice), _: *wlr.InputDevice) void {
+        const no_keymap: *NoKeymapVirtKeyboard = @fieldParentPtr("destroy", listener);
+
+        no_keymap.destroy.link.remove();
+        no_keymap.keymap.link.remove();
+
+        util.gpa.destroy(no_keymap);
+    }
+
+    fn handleKeymap(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void {
+        const no_keymap: *NoKeymapVirtKeyboard = @fieldParentPtr("keymap", listener);
+        const virtual_keyboard = no_keymap.virtual_keyboard;
+
+        handleDestroy(&no_keymap.destroy, &virtual_keyboard.keyboard.base);
+
+        const seat: *Seat = @ptrCast(@alignCast(virtual_keyboard.seat.data));
+        seat.addDevice(&virtual_keyboard.keyboard.base, true);
+    }
+};
+
 fn handleNewConstraint(
     _: *wl.Listener(*wlr.PointerConstraintV1),
     wlr_constraint: *wlr.PointerConstraintV1,
@@ -200,7 +232,7 @@ fn handleNewConstraint(
 }
 
 fn handleNewInputMethod(_: *wl.Listener(*wlr.InputMethodV2), input_method: *wlr.InputMethodV2) void {
-    const seat: *Seat = @ptrFromInt(input_method.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(input_method.seat.data));
 
     log.debug("new input method on seat {s}", .{seat.wlr_seat.name});
 

river/Keyboard.zig

@@ -54,41 +54,60 @@ pub const Pressed = struct {
         // Furthermore, wlroots will continue to forward key press/release events to river if more
         // than 32 keys are pressed. Therefore river chooses to ignore keypresses that would take
         // the keyboard beyond 32 simultaneously pressed keys.
-        assert(capacity == @typeInfo(std.meta.fieldInfo(wlr.Keyboard, .keycodes).type).Array.len);
+        assert(capacity == @typeInfo(std.meta.fieldInfo(wlr.Keyboard, .keycodes).type).array.len);
     }
 
-    keys: std.BoundedArray(Key, capacity) = .{},
+    keys: [capacity]Key,
+    len: usize,
+
+    const empty: Pressed = .{ .keys = undefined, .len = 0 };
+
+    pub fn slice(pressed: *Pressed) []Key {
+        return pressed.keys[0..pressed.len];
+    }
 
     fn contains(pressed: *Pressed, code: u32) bool {
-        for (pressed.keys.constSlice()) |item| {
+        for (pressed.slice()) |item| {
             if (item.code == code) return true;
         }
         return false;
     }
 
     fn addAssumeCapacity(pressed: *Pressed, new: Key) void {
+        assert(pressed.len < pressed.keys.len);
         assert(!pressed.contains(new.code));
-        pressed.keys.appendAssumeCapacity(new);
+        pressed.keys[pressed.len] = new;
+        pressed.len += 1;
     }
 
     fn remove(pressed: *Pressed, code: u32) ?KeyConsumer {
-        for (pressed.keys.constSlice(), 0..) |item, idx| {
+        for (pressed.slice(), 0..) |item, idx| {
-            if (item.code == code) return pressed.keys.swapRemove(idx).consumer;
+            if (item.code == code) return pressed.swapRemove(idx).consumer;
         }
 
         return null;
     }
+
+    fn swapRemove(pressed: *Pressed, index: usize) Key {
+        defer pressed.len -= 1;
+        if (index == pressed.len - 1) {
+            return pressed.keys[index];
+        }
+        const ret = pressed.keys[index];
+        pressed.keys[index] = pressed.keys[pressed.len - 1];
+        return ret;
+    }
 };
 
 device: InputDevice,
 
 /// Pressed keys along with where their press event has been sent
-pressed: Pressed = .{},
+pressed: Pressed = .empty,
 
 key: wl.Listener(*wlr.Keyboard.event.Key) = wl.Listener(*wlr.Keyboard.event.Key).init(handleKey),
 modifiers: wl.Listener(*wlr.Keyboard) = wl.Listener(*wlr.Keyboard).init(handleModifiers),
 
-pub fn init(keyboard: *Keyboard, seat: *Seat, wlr_device: *wlr.InputDevice) !void {
+pub fn init(keyboard: *Keyboard, seat: *Seat, wlr_device: *wlr.InputDevice, virtual: bool) !void {
     keyboard.* = .{
         .device = undefined,
     };
@@ -96,14 +115,16 @@ pub fn init(keyboard: *Keyboard, seat: *Seat, wlr_device: *wlr.InputDevice) !voi
     errdefer keyboard.device.deinit();
 
     const wlr_keyboard = keyboard.device.wlr_device.toKeyboard();
-    wlr_keyboard.data = @intFromPtr(keyboard);
+    wlr_keyboard.data = keyboard;
 
-    // wlroots will log a more detailed error if this fails.
+    if (!virtual) {
-    if (!wlr_keyboard.setKeymap(server.config.keymap)) return error.OutOfMemory;
+        // wlroots will log a more detailed error if this fails.
+        if (!wlr_keyboard.setKeymap(server.config.keymap)) return error.OutOfMemory;
 
-    if (wlr.KeyboardGroup.fromKeyboard(wlr_keyboard) == null) {
+        if (wlr.KeyboardGroup.fromKeyboard(wlr_keyboard) == null) {
-        // wlroots will log an error on failure
+            // wlroots will log an error on failure
-        _ = seat.keyboard_group.addKeyboard(wlr_keyboard);
+            _ = seat.keyboard_group.addKeyboard(wlr_keyboard);
+        }
     }
 
     wlr_keyboard.setRepeatInfo(server.config.repeat_rate, server.config.repeat_delay);
@@ -201,7 +222,9 @@ fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboa
         // Ignore key presses beyond 32 simultaneously pressed keys (see comments in Pressed).
         // We must ensure capacity before calling handleMapping() to ensure that we either run
         // both the press and release mapping for certain key or neither mapping.
-        keyboard.pressed.keys.ensureUnusedCapacity(1) catch return;
+        if (keyboard.pressed.len >= keyboard.pressed.keys.len) {
+            return;
+        }
 
         if (keyboard.device.seat.handleMapping(keycode, modifiers, released, xkb_state)) {
             break :blk .mapping;

river/LayerSurface.zig

@@ -36,6 +36,8 @@ wlr_layer_surface: *wlr.LayerSurfaceV1,
 scene_layer_surface: *wlr.SceneLayerSurfaceV1,
 popup_tree: *wlr.SceneTree,
 
+newly_mapped: bool = false,
+
 destroy: wl.Listener(*wlr.LayerSurfaceV1) = wl.Listener(*wlr.LayerSurfaceV1).init(handleDestroy),
 map: wl.Listener(void) = wl.Listener(void).init(handleMap),
 unmap: wl.Listener(void) = wl.Listener(void).init(handleUnmap),
@@ -43,7 +45,7 @@ commit: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleCommit)
 new_popup: wl.Listener(*wlr.XdgPopup) = wl.Listener(*wlr.XdgPopup).init(handleNewPopup),
 
 pub fn create(wlr_layer_surface: *wlr.LayerSurfaceV1) error{OutOfMemory}!void {
-    const output: *Output = @ptrFromInt(wlr_layer_surface.output.?.data);
+    const output: *Output = @ptrCast(@alignCast(wlr_layer_surface.output.?.data));
     const layer_surface = try util.gpa.create(LayerSurface);
     errdefer util.gpa.destroy(layer_surface);
 
@@ -59,7 +61,7 @@ pub fn create(wlr_layer_surface: *wlr.LayerSurfaceV1) error{OutOfMemory}!void {
     try SceneNodeData.attach(&layer_surface.scene_layer_surface.tree.node, .{ .layer_surface = layer_surface });
     try SceneNodeData.attach(&layer_surface.popup_tree.node, .{ .layer_surface = layer_surface });
 
-    wlr_layer_surface.surface.data = @intFromPtr(&layer_surface.scene_layer_surface.tree.node);
+    wlr_layer_surface.surface.data = &layer_surface.scene_layer_surface.tree.node;
 
     wlr_layer_surface.events.destroy.add(&layer_surface.destroy);
     wlr_layer_surface.surface.events.map.add(&layer_surface.map);
@@ -82,32 +84,33 @@ fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfa
     layer_surface.map.link.remove();
     layer_surface.unmap.link.remove();
     layer_surface.commit.link.remove();
+    layer_surface.new_popup.link.remove();
 
     layer_surface.destroyPopups();
 
     layer_surface.popup_tree.node.destroy();
 
     // The wlr_surface may outlive the wlr_layer_surface so we must clean up the user data.
-    layer_surface.wlr_layer_surface.surface.data = 0;
+    layer_surface.wlr_layer_surface.surface.data = null;
 
     util.gpa.destroy(layer_surface);
 }
 
 fn handleMap(listener: *wl.Listener(void)) void {
     const layer_surface: *LayerSurface = @fieldParentPtr("map", listener);
-    const wlr_surface = layer_surface.wlr_layer_surface;
+    const wlr_layer_surface = layer_surface.wlr_layer_surface;
 
-    log.debug("layer surface '{s}' mapped", .{wlr_surface.namespace});
+    log.debug("layer surface '{s}' mapped", .{wlr_layer_surface.namespace});
 
-    layer_surface.output.arrangeLayers();
+    // This is a bit of a hack, but layer surfaces are not part of the
-
+    // transaction system in river 0.3 so there's not a significantly cleaner
-    const consider = wlr_surface.current.keyboard_interactive == .on_demand and
+    // way I see to do this.
-        (wlr_surface.current.layer == .top or wlr_surface.current.layer == .overlay);
+    layer_surface.newly_mapped = true;
-    handleKeyboardInteractiveExclusive(
-        layer_surface.output,
-        if (consider) layer_surface else null,
-    );
 
+    // Beware: it is possible for arrangeLayers() to destroy this LayerSurface!
+    const output = layer_surface.output;
+    output.arrangeLayers();
+    handleKeyboardInteractiveExclusive(output);
     server.root.applyPending();
 }
 
@@ -116,8 +119,10 @@ fn handleUnmap(listener: *wl.Listener(void)) void {
 
     log.debug("layer surface '{s}' unmapped", .{layer_surface.wlr_layer_surface.namespace});
 
-    layer_surface.output.arrangeLayers();
+    // Beware: it is possible for arrangeLayers() to destroy this LayerSurface!
-    handleKeyboardInteractiveExclusive(layer_surface.output, null);
+    const output = layer_surface.output;
+    output.arrangeLayers();
+    handleKeyboardInteractiveExclusive(output);
     server.root.applyPending();
 }
 
@@ -136,46 +141,68 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
     if (wlr_layer_surface.initial_commit or
         @as(u32, @bitCast(wlr_layer_surface.current.committed)) != 0)
     {
-        layer_surface.output.arrangeLayers();
+        // Beware: it is possible for arrangeLayers() to destroy this LayerSurface!
-        handleKeyboardInteractiveExclusive(layer_surface.output, null);
+        const output = layer_surface.output;
+        output.arrangeLayers();
+        handleKeyboardInteractiveExclusive(output);
         server.root.applyPending();
     }
+
+    layer_surface.newly_mapped = false;
 }
 
-/// Focus topmost keyboard-interactivity-exclusive layer surface above normal
+fn handleKeyboardInteractiveExclusive(output: *Output) void {
-/// content, or if none found, focus the surface given as `consider`.
-/// Requires a call to Root.applyPending()
-fn handleKeyboardInteractiveExclusive(output: *Output, consider: ?*LayerSurface) void {
     if (server.lock_manager.state != .unlocked) return;
 
     // Find the topmost layer surface (if any) in the top or overlay layers which
     // requests exclusive keyboard interactivity.
-    const to_focus = outer: for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top }) |layer| {
+    // If none is found, check for a newly mapped surface in the same layers with
-        const tree = output.layerSurfaceTree(layer);
+    // on demand keyboard interactivity.
-        // Iterate in reverse to match rendering order.
+    const to_focus = blk: {
-        var it = tree.children.iterator(.reverse);
+        for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top }) |layer| {
-        while (it.next()) |node| {
+            const tree = output.layerSurfaceTree(layer);
-            assert(node.type == .tree);
+            // Iterate in reverse to match rendering order.
-            if (@as(?*SceneNodeData, @ptrFromInt(node.data))) |node_data| {
+            var it = tree.children.iterator(.reverse);
-                const layer_surface = node_data.data.layer_surface;
+            while (it.next()) |node| {
-                const wlr_layer_surface = layer_surface.wlr_layer_surface;
+                assert(node.type == .tree);
-                if (wlr_layer_surface.surface.mapped and
+                if (@as(?*SceneNodeData, @ptrCast(@alignCast(node.data)))) |node_data| {
-                    wlr_layer_surface.current.keyboard_interactive == .exclusive)
+                    const layer_surface = node_data.data.layer_surface;
-                {
+                    const wlr_layer_surface = layer_surface.wlr_layer_surface;
-                    break :outer layer_surface;
+                    if (wlr_layer_surface.surface.mapped and
+                        wlr_layer_surface.current.keyboard_interactive == .exclusive)
+                    {
+                        break :blk layer_surface;
+                    }
                 }
             }
         }
-    } else consider;
+        for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top }) |layer| {
+            const tree = output.layerSurfaceTree(layer);
+            // Iterate in reverse to match rendering order.
+            var it = tree.children.iterator(.reverse);
+            while (it.next()) |node| {
+                assert(node.type == .tree);
+                if (@as(?*SceneNodeData, @ptrCast(@alignCast(node.data)))) |node_data| {
+                    const layer_surface = node_data.data.layer_surface;
+                    const wlr_layer_surface = layer_surface.wlr_layer_surface;
+                    if (layer_surface.newly_mapped and
+                        wlr_layer_surface.surface.mapped and
+                        wlr_layer_surface.current.keyboard_interactive == .on_demand)
+                    {
+                        break :blk layer_surface;
+                    }
+                }
+            }
+        }
+        break :blk null;
+    };
 
     if (to_focus) |s| {
         assert(s.wlr_layer_surface.current.keyboard_interactive != .none);
     }
 
-    var it = server.input_manager.seats.first;
+    var it = server.input_manager.seats.iterator(.forward);
-    while (it) |node| : (it = node.next) {
+    while (it.next()) |seat| {
-        const seat = &node.data;
-
         if (seat.focused_output == output) {
             if (to_focus) |s| {
                 // If we found a surface on the output that requires focus, grab the focus of all

river/Layout.zig

@@ -38,6 +38,9 @@ layout_v3: *river.LayoutV3,
 namespace: []const u8,
 output: *Output,
 
+// Output.layouts
+link: wl.list.Link,
+
 pub fn create(client: *wl.Client, version: u32, id: u32, output: *Output, namespace: []const u8) !void {
     const layout_v3 = try river.LayoutV3.create(client, version, id);
 
@@ -47,21 +50,22 @@ pub fn create(client: *wl.Client, version: u32, id: u32, output: *Output, namesp
         return;
     }
 
-    const node = try util.gpa.create(std.TailQueue(Layout).Node);
+    const layout = try util.gpa.create(Layout);
-    errdefer util.gpa.destroy(node);
+    errdefer util.gpa.destroy(layout);
-    node.data = .{
+    layout.* = .{
         .layout_v3 = layout_v3,
         .namespace = try util.gpa.dupe(u8, namespace),
         .output = output,
+        .link = undefined,
     };
-    output.layouts.append(node);
+    output.layouts.append(layout);
 
-    layout_v3.setHandler(*Layout, handleRequest, handleDestroy, &node.data);
+    layout_v3.setHandler(*Layout, handleRequest, handleDestroy, layout);
 
     // If the namespace matches that of the output, set the layout as
     // the active one of the output and arrange it.
     if (mem.eql(u8, namespace, output.layoutNamespace())) {
-        output.layout = &node.data;
+        output.layout = layout;
         server.root.applyPending();
     }
 }
@@ -71,17 +75,17 @@ pub fn create(client: *wl.Client, version: u32, id: u32, output: *Output, namesp
 fn namespaceInUse(namespace: []const u8, output: *Output, client: *wl.Client) bool {
     var output_it = server.root.active_outputs.iterator(.forward);
     while (output_it.next()) |o| {
-        var layout_it = output.layouts.first;
+        var layout_it = output.layouts.iterator(.forward);
         if (o == output) {
             // On this output, no other layout can have our namespace.
-            while (layout_it) |layout_node| : (layout_it = layout_node.next) {
+            while (layout_it.next()) |layout| {
-                if (mem.eql(u8, namespace, layout_node.data.namespace)) return true;
+                if (mem.eql(u8, namespace, layout.namespace)) return true;
             }
         } else {
             // Layouts on other outputs may share the namespace, if they come from the same client.
-            while (layout_it) |layout_node| : (layout_it = layout_node.next) {
+            while (layout_it.next()) |layout| {
-                if (mem.eql(u8, namespace, layout_node.data.namespace) and
+                if (mem.eql(u8, namespace, layout.namespace) and
-                    client != layout_node.data.layout_v3.getClient()) return true;
+                    client != layout.layout_v3.getClient()) return true;
             }
         }
     }
@@ -185,9 +189,7 @@ pub fn destroy(layout: *Layout) void {
         .{ layout.namespace, layout.output.wlr_output.name },
     );
 
-    // Remove layout from the list
+    layout.link.remove();
-    const node: *std.TailQueue(Layout).Node = @fieldParentPtr("data", layout);
-    layout.output.layouts.remove(node);
 
     // If we are the currently active layout of an output, clean up.
     if (layout.output.layout == layout) {
@@ -208,5 +210,5 @@ pub fn destroy(layout: *Layout) void {
     layout.layout_v3.setHandler(?*anyopaque, handleRequestInert, null, null);
 
     util.gpa.free(layout.namespace);
-    util.gpa.destroy(node);
+    util.gpa.destroy(layout);
 }

river/LayoutManager.zig

@@ -68,7 +68,7 @@ fn handleRequest(
         .get_layout => |req| {
             // Ignore if the output is inert
             const wlr_output = wlr.Output.fromWlOutput(req.output) orelse return;
-            const output: *Output = @ptrFromInt(wlr_output.data);
+            const output: *Output = @ptrCast(@alignCast(wlr_output.data));
 
             log.debug("bind layout '{s}' on output '{s}'", .{ req.namespace, output.wlr_output.name });
 

river/LockManager.zig

@@ -110,9 +110,8 @@ fn handleLock(listener: *wl.Listener(*wlr.SessionLockV1), lock: *wlr.SessionLock
         };
 
         {
-            var it = server.input_manager.seats.first;
+            var it = server.input_manager.seats.iterator(.forward);
-            while (it) |node| : (it = node.next) {
+            while (it.next()) |seat| {
-                const seat = &node.data;
                 seat.setFocusRaw(.none);
 
                 // Enter locked mode
@@ -213,9 +212,8 @@ fn handleUnlock(listener: *wl.Listener(void)) void {
     }
 
     {
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |node| : (it = node.next) {
+        while (it.next()) |seat| {
-            const seat = &node.data;
             seat.setFocusRaw(.none);
 
             // Exit locked mode
@@ -266,7 +264,7 @@ pub fn updateLockSurfaceSize(manager: *LockManager, output: *Output) void {
 
     var it = lock.surfaces.iterator(.forward);
     while (it.next()) |wlr_lock_surface| {
-        const lock_surface: *LockSurface = @ptrFromInt(wlr_lock_surface.data);
+        const lock_surface: *LockSurface = @ptrCast(@alignCast(wlr_lock_surface.data));
         if (output == lock_surface.getOutput()) {
             lock_surface.configure();
         }

river/LockSurface.zig

@@ -44,7 +44,7 @@ pub fn create(wlr_lock_surface: *wlr.SessionLockSurfaceV1, lock: *wlr.SessionLoc
         .wlr_lock_surface = wlr_lock_surface,
         .lock = lock,
     };
-    wlr_lock_surface.data = @intFromPtr(lock_surface);
+    wlr_lock_surface.data = lock_surface;
 
     const output = lock_surface.getOutput();
     const tree = try output.locked_content.createSceneSubsurfaceTree(wlr_lock_surface.surface);
@@ -52,7 +52,7 @@ pub fn create(wlr_lock_surface: *wlr.SessionLockSurfaceV1, lock: *wlr.SessionLoc
 
     try SceneNodeData.attach(&tree.node, .{ .lock_surface = lock_surface });
 
-    wlr_lock_surface.surface.data = @intFromPtr(&tree.node);
+    wlr_lock_surface.surface.data = &tree.node;
 
     wlr_lock_surface.surface.events.map.add(&lock_surface.map);
     wlr_lock_surface.events.destroy.add(&lock_surface.surface_destroy);
@@ -65,12 +65,11 @@ pub fn destroy(lock_surface: *LockSurface) void {
         var surface_it = lock_surface.lock.surfaces.iterator(.forward);
         const new_focus: Seat.FocusTarget = while (surface_it.next()) |surface| {
             if (surface != lock_surface.wlr_lock_surface)
-                break .{ .lock_surface = @ptrFromInt(surface.data) };
+                break .{ .lock_surface = @ptrCast(@alignCast(surface.data)) };
         } else .none;
 
-        var seat_it = server.input_manager.seats.first;
+        var seat_it = server.input_manager.seats.iterator(.forward);
-        while (seat_it) |node| : (seat_it = node.next) {
+        while (seat_it.next()) |seat| {
-            const seat = &node.data;
             if (seat.focused == .lock_surface and seat.focused.lock_surface == lock_surface) {
                 seat.setFocusRaw(new_focus);
             }
@@ -86,13 +85,13 @@ pub fn destroy(lock_surface: *LockSurface) void {
     lock_surface.surface_destroy.link.remove();
 
     // The wlr_surface may outlive the wlr_lock_surface so we must clean up the user data.
-    lock_surface.wlr_lock_surface.surface.data = 0;
+    lock_surface.wlr_lock_surface.surface.data = null;
 
     util.gpa.destroy(lock_surface);
 }
 
 pub fn getOutput(lock_surface: *LockSurface) *Output {
-    return @ptrFromInt(lock_surface.wlr_lock_surface.output.data);
+    return @ptrCast(@alignCast(lock_surface.wlr_lock_surface.output.data));
 }
 
 pub fn configure(lock_surface: *LockSurface) void {
@@ -122,9 +121,8 @@ fn handleMap(listener: *wl.Listener(void)) void {
 }
 
 fn updateFocus(lock_surface: *LockSurface) void {
-    var it = server.input_manager.seats.first;
+    var it = server.input_manager.seats.iterator(.forward);
-    while (it) |node| : (it = node.next) {
+    while (it.next()) |seat| {
-        const seat = &node.data;
         if (seat.focused != .lock_surface) {
             seat.setFocusRaw(.{ .lock_surface = lock_surface });
         }

river/Output.zig

@@ -125,10 +125,6 @@ lock_render_state: enum {
     lock_surface,
 } = .blanked,
 
-/// Set to true if a gamma control client makes a set gamma request.
-/// This request is handled while rendering the next frame in handleFrame().
-gamma_dirty: bool = false,
-
 /// The state of the output that is directly acted upon/modified through user input.
 ///
 /// Pending state will be copied to the inflight state and communicated to clients
@@ -171,7 +167,7 @@ previous_tags: u32 = 1 << 0,
 attach_mode: ?Config.AttachMode = null,
 
 /// List of all layouts
-layouts: std.TailQueue(Layout) = .{},
+layouts: wl.list.Head(Layout, .link),
 
 /// The current layout namespace of the output. If null,
 /// config.default_layout_namespace should be used instead.
@@ -294,8 +290,11 @@ pub fn create(wlr_output: *wlr.Output) !void {
             .height = height,
         },
         .status = undefined,
+        .layouts = undefined,
     };
-    wlr_output.data = @intFromPtr(output);
+    wlr_output.data = output;
+
+    output.layouts.init();
 
     output.pending.focus_stack.init();
     output.pending.wm_stack.init();
@@ -364,10 +363,14 @@ fn sendLayerConfigures(
         var it = tree.children.safeIterator(.forward);
         while (it.next()) |node| {
             assert(node.type == .tree);
-            if (@as(?*SceneNodeData, @ptrFromInt(node.data))) |node_data| {
+            if (@as(?*SceneNodeData, @ptrCast(@alignCast(node.data)))) |node_data| {
                 const layer_surface = node_data.data.layer_surface;
 
-                if (!layer_surface.wlr_layer_surface.initialized) continue;
+                if (!layer_surface.wlr_layer_surface.surface.mapped and
+                    !layer_surface.wlr_layer_surface.initial_commit)
+                {
+                    continue;
+                }
 
                 const exclusive = layer_surface.wlr_layer_surface.current.exclusive_zone > 0;
                 if (exclusive != (mode == .exclusive)) {
@@ -420,7 +423,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
     assert(output.inflight.focus_stack.empty());
     assert(output.inflight.wm_stack.empty());
     assert(output.inflight.layout_demand == null);
-    assert(output.layouts.len == 0);
+    assert(output.layouts.length() == 0);
 
     output.all_link.remove();
 
@@ -433,7 +436,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
 
     if (output.layout_namespace) |namespace| util.gpa.free(namespace);
 
-    output.wlr_output.data = 0;
+    output.wlr_output.data = null;
 
     util.gpa.destroy(output);
 
@@ -456,7 +459,7 @@ fn handleRequestState(listener: *wl.Listener(*wlr.Output.event.RequestState), ev
 // TODO double buffer output state changes for frame perfection and cleaner code.
 // Schedule a frame and commit in the frame handler.
 // Get rid of this function.
-pub fn applyState(output: *Output, state: *wlr.Output.State) error{CommitFailed}!void {
+pub fn applyState(output: *Output, state: *const wlr.Output.State) error{CommitFailed}!void {
 
     // We need to be precise about this state change to make assertions
     // in updateLockRenderStateOnEnableDisable() possible.
@@ -480,7 +483,6 @@ pub fn applyState(output: *Output, state: *wlr.Output.State) error{CommitFailed}
 
 fn handleEnableDisable(output: *Output) void {
     output.updateLockRenderStateOnEnableDisable();
-    output.gamma_dirty = true;
 
     if (output.wlr_output.enabled) {
         // Add the output to root.active_outputs and the output layout if it has not
@@ -532,44 +534,21 @@ fn handleFrame(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
 
     // TODO this should probably be retried on failure
     output.renderAndCommit(scene_output) catch |err| switch (err) {
-        error.OutOfMemory => log.err("out of memory", .{}),
         error.CommitFailed => log.err("output commit failed for {s}", .{output.wlr_output.name}),
     };
 
-    var now: posix.timespec = undefined;
+    var now = posix.clock_gettime(.MONOTONIC) catch @panic("CLOCK_MONOTONIC not supported");
-    posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
     scene_output.sendFrameDone(&now);
 }
 
 fn renderAndCommit(output: *Output, scene_output: *wlr.SceneOutput) !void {
-    // TODO(wlroots): replace this with wlr_scene_output_needs_frame()
+    if (!scene_output.needsFrame()) return;
-    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();
 
     if (!scene_output.buildState(&state, null)) return error.CommitFailed;
 
-    if (output.gamma_dirty) {
-        const control = server.root.gamma_control_manager.getControl(output.wlr_output);
-        if (!wlr.GammaControlV1.apply(control, &state)) return error.OutOfMemory;
-
-        // TODO(wlroots): remove this isHeadless() workaround after upstream fix is available
-        // in a release: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4868
-        if (!output.wlr_output.testState(&state) or output.wlr_output.isHeadless()) {
-            wlr.GammaControlV1.sendFailedAndDestroy(control);
-            state.clearGammaLut();
-            // If the backend does not support gamma LUTs it will reject any
-            // state with the gamma LUT committed bit set even if the state
-            // has a null LUT. The wayland backend for example has this behavior.
-            state.committed.gamma_lut = false;
-        }
-    }
-
     if (output.current.fullscreen) |fullscreen| {
         if (fullscreen.allowTearing()) {
             state.tearing_page_flip = true;
@@ -584,8 +563,6 @@ fn renderAndCommit(output: *Output, scene_output: *wlr.SceneOutput) !void {
 
     if (!output.wlr_output.commitState(&state)) return error.CommitFailed;
 
-    output.gamma_dirty = false;
-
     if (server.lock_manager.state == .locked or
         (server.lock_manager.state == .waiting_for_lock_surfaces and output.locked_content.node.enabled) or
         server.lock_manager.state == .waiting_for_blank)
@@ -649,7 +626,7 @@ fn handlePresent(
 }
 
 fn setTitle(output: Output) void {
-    const title = fmt.allocPrintZ(util.gpa, "river - {s}", .{output.wlr_output.name}) catch return;
+    const title = fmt.allocPrintSentinel(util.gpa, "river - {s}", .{output.wlr_output.name}, 0) catch return;
     defer util.gpa.free(title);
     if (output.wlr_output.isWl()) {
         output.wlr_output.wlSetTitle(title);
@@ -661,9 +638,9 @@ fn setTitle(output: Output) void {
 pub fn handleLayoutNamespaceChange(output: *Output) void {
     // The user changed the layout namespace of this output. Try to find a
     // matching layout.
-    var it = output.layouts.first;
+    var it = output.layouts.iterator(.forward);
-    output.layout = while (it) |node| : (it = node.next) {
+    output.layout = while (it.next()) |layout| {
-        if (mem.eql(u8, output.layoutNamespace(), node.data.namespace)) break &node.data;
+        if (mem.eql(u8, output.layoutNamespace(), layout.namespace)) break layout;
     } else null;
     server.root.applyPending();
 }

river/PointerConstraint.zig

@@ -47,7 +47,7 @@ commit: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleCommit)
 node_destroy: wl.Listener(void) = wl.Listener(void).init(handleNodeDestroy),
 
 pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void {
-    const seat: *Seat = @ptrFromInt(wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(wlr_constraint.seat.data));
 
     const constraint = try util.gpa.create(PointerConstraint);
     errdefer util.gpa.destroy(constraint);
@@ -55,7 +55,7 @@ pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void
     constraint.* = .{
         .wlr_constraint = wlr_constraint,
     };
-    wlr_constraint.data = @intFromPtr(constraint);
+    wlr_constraint.data = constraint;
 
     wlr_constraint.events.destroy.add(&constraint.destroy);
     wlr_constraint.surface.events.commit.add(&constraint.commit);
@@ -70,7 +70,7 @@ pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void
 }
 
 pub fn maybeActivate(constraint: *PointerConstraint) void {
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     assert(seat.cursor.constraint == constraint);
 
@@ -102,7 +102,7 @@ pub fn maybeActivate(constraint: *PointerConstraint) void {
 
 /// Called when the cursor position or content in the scene graph changes
 pub fn updateState(constraint: *PointerConstraint) void {
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     constraint.maybeActivate();
 
@@ -154,7 +154,7 @@ pub fn confine(constraint: *PointerConstraint, dx: *f64, dy: *f64) void {
 }
 
 pub fn deactivate(constraint: *PointerConstraint) void {
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     assert(seat.cursor.constraint == constraint);
     assert(constraint.state == .active);
@@ -167,7 +167,7 @@ pub fn deactivate(constraint: *PointerConstraint) void {
 }
 
 fn warpToHintIfSet(constraint: *PointerConstraint) void {
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     if (constraint.wlr_constraint.current.cursor_hint.enabled) {
         var lx: i32 = undefined;
@@ -190,7 +190,7 @@ fn handleNodeDestroy(listener: *wl.Listener(void)) void {
 
 fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.PointerConstraintV1) void {
     const constraint: *PointerConstraint = @fieldParentPtr("destroy", listener);
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     if (constraint.state == .active) {
         // We can't simply call deactivate() here as it calls sendDeactivated(),
@@ -215,7 +215,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.Point
 // the surface changes.
 fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
     const constraint: *PointerConstraint = @fieldParentPtr("commit", listener);
-    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(constraint.wlr_constraint.seat.data));
 
     switch (constraint.state) {
         .active => |state| {

river/Root.zig

@@ -97,8 +97,6 @@ power_manager_set_mode: wl.Listener(*wlr.OutputPowerManagerV1.event.SetMode) =
     wl.Listener(*wlr.OutputPowerManagerV1.event.SetMode).init(handlePowerManagerSetMode),
 
 gamma_control_manager: *wlr.GammaControlManagerV1,
-gamma_control_set_gamma: wl.Listener(*wlr.GammaControlManagerV1.event.SetGamma) =
-    wl.Listener(*wlr.GammaControlManagerV1.event.SetGamma).init(handleSetGamma),
 
 /// A list of all outputs
 all_outputs: wl.list.Head(Output, .all_link),
@@ -123,6 +121,9 @@ pub fn init(root: *Root) !void {
     const scene = try wlr.Scene.create();
     errdefer scene.tree.node.destroy();
 
+    const gamma_control_manager = try wlr.GammaControlManagerV1.create(server.wl_server);
+    scene.setGammaControlManagerV1(gamma_control_manager);
+
     const interactive_content = try scene.tree.createSceneTree();
     const drag_icons = try scene.tree.createSceneTree();
     const hidden_tree = try scene.tree.createSceneTree();
@@ -163,11 +164,11 @@ pub fn init(root: *Root) !void {
         .all_outputs = undefined,
         .active_outputs = undefined,
 
-        .presentation = try wlr.Presentation.create(server.wl_server, server.backend),
+        .presentation = try wlr.Presentation.create(server.wl_server, server.backend, 2),
         .xdg_output_manager = try wlr.XdgOutputManagerV1.create(server.wl_server, output_layout),
         .output_manager = try wlr.OutputManagerV1.create(server.wl_server),
         .power_manager = try wlr.OutputPowerManagerV1.create(server.wl_server),
-        .gamma_control_manager = try wlr.GammaControlManagerV1.create(server.wl_server),
+        .gamma_control_manager = gamma_control_manager,
         .transaction_timeout = transaction_timeout,
     };
     root.hidden.pending.focus_stack.init();
@@ -187,10 +188,14 @@ pub fn init(root: *Root) !void {
     root.output_manager.events.@"test".add(&root.manager_test);
     root.output_layout.events.change.add(&root.layout_change);
     root.power_manager.events.set_mode.add(&root.power_manager_set_mode);
-    root.gamma_control_manager.events.set_gamma.add(&root.gamma_control_set_gamma);
 }
 
 pub fn deinit(root: *Root) void {
+    root.manager_apply.link.remove();
+    root.manager_test.link.remove();
+    root.layout_change.link.remove();
+    root.power_manager_set_mode.link.remove();
+
     root.output_layout.destroy();
     root.transaction_timeout.remove();
 }
@@ -323,16 +328,15 @@ pub fn deactivateOutput(root: *Root, output: *Output) void {
         var it = tree.children.safeIterator(.forward);
         while (it.next()) |scene_node| {
             assert(scene_node.type == .tree);
-            if (@as(?*SceneNodeData, @ptrFromInt(scene_node.data))) |node_data| {
+            if (@as(?*SceneNodeData, @ptrCast(@alignCast(scene_node.data)))) |node_data| {
                 node_data.data.layer_surface.wlr_layer_surface.destroy();
             }
         }
     }
 
     // If any seat has the removed output focused, focus the fallback one
-    var seat_it = server.input_manager.seats.first;
+    var seat_it = server.input_manager.seats.iterator(.forward);
-    while (seat_it) |seat_node| : (seat_it = seat_node.next) {
+    while (seat_it.next()) |seat| {
-        const seat = &seat_node.data;
         if (seat.focused_output == output) {
             seat.focusOutput(fallback_output);
         }
@@ -346,7 +350,7 @@ pub fn deactivateOutput(root: *Root, output: *Output) void {
         output.inflight.layout_demand = null;
         root.notifyLayoutDemandDone();
     }
-    while (output.layouts.first) |node| node.data.destroy();
+    while (output.layouts.first()) |layout| layout.destroy();
 
     // We must call reconfigureDevices here to unmap devices that might be mapped to this output
     // in order to prevent a segfault in wlroots.
@@ -390,9 +394,8 @@ pub fn activateOutput(root: *Root, output: *Output) void {
         }
         {
             // Focus the new output with all seats
-            var it = server.input_manager.seats.first;
+            var it = server.input_manager.seats.iterator(.forward);
-            while (it) |seat_node| : (it = seat_node.next) {
+            while (it.next()) |seat| {
-                const seat = &seat_node.data;
                 seat.focusOutput(output);
             }
         }
@@ -428,8 +431,8 @@ pub fn applyPending(root: *Root) void {
         // state consistent. Instead of having focus(null) calls spread all
         // around the codebase and risk forgetting one, always ensure focus
         // state is synchronized here.
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |node| : (it = node.next) node.data.focus(null);
+        while (it.next()) |seat| seat.focus(null);
     }
 
     // If there is already a transaction inflight, wait until it completes.
@@ -539,11 +542,9 @@ pub fn applyPending(root: *Root) void {
     }
 
     {
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |node| : (it = node.next) {
+        while (it.next()) |seat| {
-            const cursor = &node.data.cursor;
+            switch (seat.cursor.mode) {
-
-            switch (cursor.mode) {
                 .passthrough, .down => {},
                 inline .move, .resize => |data| {
                     if (data.view.inflight.output == null or
@@ -551,14 +552,14 @@ pub fn applyPending(root: *Root) void {
                         (!data.view.inflight.float and data.view.inflight.output.?.layout != null) or
                         data.view.inflight.fullscreen)
                     {
-                        cursor.mode = .passthrough;
+                        seat.cursor.mode = .passthrough;
                         data.view.pending.resizing = false;
                         data.view.inflight.resizing = false;
                     }
                 },
             }
 
-            cursor.inflight_mode = cursor.mode;
+            seat.cursor.inflight_mode = seat.cursor.mode;
         }
     }
 
@@ -703,10 +704,10 @@ fn commitTransaction(root: *Root) void {
     }
 
     {
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |node| : (it = node.next) {
+        while (it.next()) |seat| {
-            node.data.cursor.updateState();
+            seat.cursor.updateState();
-            node.data.sendFocusedView();
+            seat.sendFocusedView();
         }
     }
 
@@ -798,7 +799,7 @@ fn processOutputConfig(
     var it = config.heads.iterator(.forward);
     while (it.next()) |head| {
         const wlr_output = head.state.output;
-        const output: *Output = @ptrFromInt(wlr_output.data);
+        const output: *Output = @ptrCast(@alignCast(wlr_output.data));
 
         var proposed_state = wlr.Output.State.init();
         head.state.apply(&proposed_state);
@@ -850,7 +851,7 @@ fn handlePowerManagerSetMode(
     event: *wlr.OutputPowerManagerV1.event.SetMode,
 ) void {
     // The output may have been destroyed, in which case there is nothing to do
-    const output = @as(?*Output, @ptrFromInt(event.output.data)) orelse return;
+    const output: *Output = @ptrCast(@alignCast(event.output.data orelse return));
 
     std.log.debug("client requested dpms {s} for output {s}", .{
         @tagName(event.mode),
@@ -880,18 +881,4 @@ fn handlePowerManagerSetMode(
     }
 
     output.updateLockRenderStateOnEnableDisable();
-    output.gamma_dirty = true;
-}
-
-fn handleSetGamma(
-    _: *wl.Listener(*wlr.GammaControlManagerV1.event.SetGamma),
-    event: *wlr.GammaControlManagerV1.event.SetGamma,
-) void {
-    // The output may have been destroyed, in which case there is nothing to do
-    const output = @as(?*Output, @ptrFromInt(event.output.data)) orelse return;
-
-    std.log.debug("client requested to set gamma", .{});
-
-    output.gamma_dirty = true;
-    output.wlr_output.scheduleFrame();
 }

river/SceneNodeData.zig

@@ -46,7 +46,7 @@ pub fn attach(node: *wlr.SceneNode, data: Data) error{OutOfMemory}!void {
         .node = node,
         .data = data,
     };
-    node.data = @intFromPtr(scene_node_data);
+    node.data = scene_node_data;
 
     node.events.destroy.add(&scene_node_data.destroy);
 }
@@ -54,7 +54,7 @@ pub fn attach(node: *wlr.SceneNode, data: Data) error{OutOfMemory}!void {
 pub fn fromNode(node: *wlr.SceneNode) ?*SceneNodeData {
     var n = node;
     while (true) {
-        if (@as(?*SceneNodeData, @ptrFromInt(n.data))) |scene_node_data| {
+        if (@as(?*SceneNodeData, @ptrCast(@alignCast(n.data)))) |scene_node_data| {
             return scene_node_data;
         }
         if (n.parent) |parent_tree| {
@@ -66,7 +66,7 @@ pub fn fromNode(node: *wlr.SceneNode) ?*SceneNodeData {
 }
 
 pub fn fromSurface(surface: *wlr.Surface) ?*SceneNodeData {
-    if (@as(?*wlr.SceneNode, @ptrFromInt(surface.getRootSurface().data))) |node| {
+    if (@as(?*wlr.SceneNode, @ptrCast(@alignCast(surface.getRootSurface().data)))) |node| {
         return fromNode(node);
     }
     return null;
@@ -76,7 +76,7 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
     const scene_node_data: *SceneNodeData = @fieldParentPtr("destroy", listener);
 
     scene_node_data.destroy.link.remove();
-    scene_node_data.node.data = 0;
+    scene_node_data.node.data = null;
 
     util.gpa.destroy(scene_node_data);
 }

river/Seat.zig

@@ -91,7 +91,7 @@ focused_output: ?*Output = null,
 focused: FocusTarget = .none,
 
 /// List of status tracking objects relaying changes to this seat to clients.
-status_trackers: std.SinglyLinkedList(SeatStatus) = .{},
+status_trackers: wl.list.Head(SeatStatus, .link),
 
 /// The currently in progress drag operation type.
 drag: enum {
@@ -109,7 +109,13 @@ drag_destroy: wl.Listener(*wlr.Drag) = wl.Listener(*wlr.Drag).init(handleDragDes
 request_set_primary_selection: wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection) =
     wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection).init(handleRequestSetPrimarySelection),
 
-pub fn init(seat: *Seat, name: [*:0]const u8) !void {
+// InputManager.seats
+link: wl.list.Link = undefined,
+
+pub fn create(name: [*:0]const u8) !void {
+    const seat = try util.gpa.create(Seat);
+    errdefer util.gpa.destroy(seat);
+
     const event_loop = server.wl_server.getEventLoop();
     const mapping_repeat_timer = try event_loop.addTimer(*Seat, handleMappingRepeatTimeout, seat);
     errdefer mapping_repeat_timer.remove();
@@ -121,13 +127,18 @@ pub fn init(seat: *Seat, name: [*:0]const u8) !void {
         .relay = undefined,
         .mapping_repeat_timer = mapping_repeat_timer,
         .keyboard_group = try wlr.KeyboardGroup.create(),
+        .status_trackers = undefined,
+        .link = undefined,
     };
-    seat.wlr_seat.data = @intFromPtr(seat);
+    seat.wlr_seat.data = seat;
+
+    server.input_manager.seats.append(seat);
+    seat.status_trackers.init();
 
     try seat.cursor.init(seat);
     seat.relay.init();
 
-    try seat.tryAddDevice(&seat.keyboard_group.keyboard.base);
+    try seat.tryAddDevice(&seat.keyboard_group.keyboard.base, false);
 
     seat.wlr_seat.events.request_set_selection.add(&seat.request_set_selection);
     seat.wlr_seat.events.request_start_drag.add(&seat.request_start_drag);
@@ -135,7 +146,7 @@ pub fn init(seat: *Seat, name: [*:0]const u8) !void {
     seat.wlr_seat.events.request_set_primary_selection.add(&seat.request_set_primary_selection);
 }
 
-pub fn deinit(seat: *Seat) void {
+pub fn destroy(seat: *Seat) void {
     {
         var it = server.input_manager.devices.iterator(.forward);
         while (it.next()) |device| assert(device.seat != seat);
@@ -151,6 +162,10 @@ pub fn deinit(seat: *Seat) void {
     seat.start_drag.link.remove();
     if (seat.drag != .none) seat.drag_destroy.link.remove();
     seat.request_set_primary_selection.link.remove();
+
+    seat.link.remove();
+
+    util.gpa.destroy(seat);
 }
 
 /// Set the current focus. If a visible view is passed it will be focused.
@@ -228,8 +243,8 @@ pub fn focus(seat: *Seat, _target: ?*View) void {
 }
 
 pub fn sendFocusedView(seat: *Seat) void {
-    var it = seat.status_trackers.first;
+    var it = seat.status_trackers.iterator(.forward);
-    while (it) |node| : (it = node.next) node.data.sendFocusedView();
+    while (it.next()) |tracker| tracker.sendFocusedView();
 }
 
 /// Switch focus to the target, handling unfocus and input inhibition
@@ -289,7 +304,7 @@ pub fn setFocusRaw(seat: *Seat, new_focus: FocusTarget) void {
             if (seat.cursor.constraint) |constraint| {
                 assert(constraint.wlr_constraint == wlr_constraint);
             } else {
-                seat.cursor.constraint = @ptrFromInt(wlr_constraint.data);
+                seat.cursor.constraint = @ptrCast(@alignCast(wlr_constraint.data));
                 assert(seat.cursor.constraint != null);
             }
         }
@@ -300,7 +315,10 @@ pub fn setFocusRaw(seat: *Seat, new_focus: FocusTarget) void {
     seat.cursor.may_need_warp = true;
 
     // Inform any clients tracking status of the change
-    seat.sendFocusedView();
+    var it = seat.status_trackers.iterator(.forward);
+    while (it.next()) |tracker| {
+        tracker.sendFocusedView();
+    }
 }
 
 /// Send keyboard enter/leave events and handle pointer constraints
@@ -316,16 +334,17 @@ pub fn keyboardEnterOrLeave(seat: *Seat, target_surface: ?*wlr.Surface) void {
 
 fn keyboardNotifyEnter(seat: *Seat, wlr_surface: *wlr.Surface) void {
     if (seat.wlr_seat.getKeyboard()) |wlr_keyboard| {
-        const keyboard: *Keyboard = @ptrFromInt(wlr_keyboard.data);
+        const keyboard: *Keyboard = @ptrCast(@alignCast(wlr_keyboard.data));
 
-        var keycodes: std.BoundedArray(u32, Keyboard.Pressed.capacity) = .{};
+        var buffer: [Keyboard.Pressed.capacity]u32 = undefined;
-        for (keyboard.pressed.keys.constSlice()) |item| {
+        var keycodes: std.ArrayList(u32) = .initBuffer(&buffer);
+        for (keyboard.pressed.slice()) |item| {
             if (item.consumer == .focus) keycodes.appendAssumeCapacity(item.code);
         }
 
         seat.wlr_seat.keyboardNotifyEnter(
             wlr_surface,
-            keycodes.constSlice(),
+            keycodes.items,
             &wlr_keyboard.modifiers,
         );
     } else {
@@ -338,15 +357,15 @@ pub fn focusOutput(seat: *Seat, output: ?*Output) void {
     if (seat.focused_output == output) return;
 
     if (seat.focused_output) |old| {
-        var it = seat.status_trackers.first;
+        var it = seat.status_trackers.iterator(.forward);
-        while (it) |node| : (it = node.next) node.data.sendOutput(old, .unfocused);
+        while (it.next()) |tracker| tracker.sendOutput(old, .unfocused);
     }
 
     seat.focused_output = output;
 
     if (seat.focused_output) |new| {
-        var it = seat.status_trackers.first;
+        var it = seat.status_trackers.iterator(.forward);
-        while (it) |node| : (it = node.next) node.data.sendOutput(new, .focused);
+        while (it.next()) |tracker| tracker.sendOutput(new, .focused);
     }
 
     // Depending on configuration and cursor position, changing output focus
@@ -361,9 +380,9 @@ pub fn handleActivity(seat: Seat) void {
 pub fn enterMode(seat: *Seat, mode_id: u32) void {
     seat.mode_id = mode_id;
 
-    var it = seat.status_trackers.first;
+    var it = seat.status_trackers.iterator(.forward);
-    while (it) |node| : (it = node.next) {
+    while (it.next()) |tracker| {
-        node.data.sendMode(server.config.modes.items[mode_id].name);
+        tracker.sendMode(server.config.modes.items[mode_id].name);
     }
 }
 
@@ -457,8 +476,8 @@ pub fn runCommand(seat: *Seat, args: []const [:0]const u8) void {
         return;
     };
     if (out) |s| {
-        const stdout = std.io.getStdOut().writer();
+        var stdout = std.fs.File.stdout().writer(&.{});
-        stdout.print("{s}", .{s}) catch |err| {
+        stdout.interface.print("{s}", .{s}) catch |err| {
             std.log.scoped(.command).err("{s}: write to stdout failed {}", .{ args[0], err });
         };
     }
@@ -484,19 +503,19 @@ fn handleMappingRepeatTimeout(seat: *Seat) c_int {
     return 0;
 }
 
-pub fn addDevice(seat: *Seat, wlr_device: *wlr.InputDevice) void {
+pub fn addDevice(seat: *Seat, wlr_device: *wlr.InputDevice, virtual: bool) void {
-    seat.tryAddDevice(wlr_device) catch |err| switch (err) {
+    seat.tryAddDevice(wlr_device, virtual) catch |err| switch (err) {
         error.OutOfMemory => log.err("out of memory", .{}),
     };
 }
 
-fn tryAddDevice(seat: *Seat, wlr_device: *wlr.InputDevice) !void {
+fn tryAddDevice(seat: *Seat, wlr_device: *wlr.InputDevice, virtual: bool) !void {
     switch (wlr_device.type) {
         .keyboard => {
             const keyboard = try util.gpa.create(Keyboard);
             errdefer util.gpa.destroy(keyboard);
 
-            try keyboard.init(seat, wlr_device);
+            try keyboard.init(seat, wlr_device, virtual);
 
             seat.wlr_seat.setKeyboard(keyboard.device.wlr_device.toKeyboard());
             if (seat.wlr_seat.keyboard_state.focused_surface) |wlr_surface| {

river/SeatStatus.zig

@@ -33,8 +33,19 @@ const View = @import("View.zig");
 seat: *Seat,
 seat_status_v1: *zriver.SeatStatusV1,
 
-pub fn init(seat_status: *SeatStatus, seat: *Seat, seat_status_v1: *zriver.SeatStatusV1) void {
+link: wl.list.Link,
-    seat_status.* = .{ .seat = seat, .seat_status_v1 = seat_status_v1 };
+
+pub fn create(seat: *Seat, seat_status_v1: *zriver.SeatStatusV1) !void {
+    const seat_status = try util.gpa.create(SeatStatus);
+    errdefer util.gpa.destroy(seat_status);
+
+    seat_status.* = .{
+        .seat = seat,
+        .seat_status_v1 = seat_status_v1,
+        .link = undefined,
+    };
+    seat.status_trackers.append(seat_status);
+    errdefer comptime unreachable;
 
     seat_status_v1.setHandler(*SeatStatus, handleRequest, handleDestroy, seat_status);
 
@@ -51,9 +62,8 @@ fn handleRequest(seat_status_v1: *zriver.SeatStatusV1, request: zriver.SeatStatu
 }
 
 fn handleDestroy(_: *zriver.SeatStatusV1, seat_status: *SeatStatus) void {
-    const node: *std.SinglyLinkedList(SeatStatus).Node = @fieldParentPtr("data", seat_status);
+    seat_status.link.remove();
-    seat_status.seat.status_trackers.remove(node);
+    util.gpa.destroy(seat_status);
-    util.gpa.destroy(node);
 }
 
 pub fn sendOutput(seat_status: SeatStatus, output: *Output, state: enum { focused, unfocused }) void {
@@ -71,8 +81,12 @@ pub fn sendFocusedView(seat_status: SeatStatus) void {
     if (seat_status.seat_status_v1.getVersion() >= 4) {
         switch (seat_status.seat.focused) {
             .view => |view| {
-                //assert(view.inflight.tags == view.current.tags);
+                if (view.current.tags != 0) {
-                seat_status.seat_status_v1.sendFocusedView(view.getTitle() orelse "", view.current.tags);
+                    // A view can't be on no tags, so we need to wait for the
+                    // layout to update. There is probably a better way to do
+                    // this, but this way seems to work.
+                    seat_status.seat_status_v1.sendFocusedView(view.getTitle() orelse "", view.current.tags);
+                }
             },
             else => seat_status.seat_status_v1.sendFocusedView("", 0),
         }

river/Server.zig

@@ -24,7 +24,7 @@ const posix = std.posix;
 const wlr = @import("wlroots");
 const wl = @import("wayland").server.wl;
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 const util = @import("util.zig");
 
 const Config = @import("Config.zig");
@@ -61,8 +61,8 @@ allocator: *wlr.Allocator,
 security_context_manager: *wlr.SecurityContextManagerV1,
 
 shm: *wlr.Shm,
-drm: ?*wlr.Drm = null,
 linux_dmabuf: ?*wlr.LinuxDmabufV1 = null,
+linux_drm_syncobj_manager: ?*wlr.LinuxDrmSyncobjManagerV1 = null,
 single_pixel_buffer_manager: *wlr.SinglePixelBufferManagerV1,
 
 viewporter: *wlr.Viewporter,
@@ -85,6 +85,8 @@ screencopy_manager: *wlr.ScreencopyManagerV1,
 
 foreign_toplevel_manager: *wlr.ForeignToplevelManagerV1,
 
+foreign_toplevel_list: *wlr.ExtForeignToplevelListV1,
+
 tearing_control_manager: *wlr.TearingControlManagerV1,
 
 alpha_modifier: *wlr.AlphaModifierV1,
@@ -164,6 +166,8 @@ pub fn init(server: *Server, runtime_xwayland: bool) !void {
 
         .foreign_toplevel_manager = try wlr.ForeignToplevelManagerV1.create(wl_server),
 
+        .foreign_toplevel_list = try wlr.ExtForeignToplevelListV1.create(wl_server, 1),
+
         .tearing_control_manager = try wlr.TearingControlManagerV1.create(wl_server, 1),
 
         .alpha_modifier = try wlr.AlphaModifierV1.create(wl_server),
@@ -180,14 +184,14 @@ pub fn init(server: *Server, runtime_xwayland: bool) !void {
     };
 
     if (renderer.getTextureFormats(@intFromEnum(wlr.BufferCap.dmabuf)) != null) {
-        // wl_drm is a legacy interface and all clients should switch to linux_dmabuf.
-        // However, enough widely used clients still rely on wl_drm that the pragmatic option
-        // is to keep it around for the near future.
-        // TODO remove wl_drm support
-        server.drm = try wlr.Drm.create(wl_server, renderer);
-
         server.linux_dmabuf = try wlr.LinuxDmabufV1.createWithRenderer(wl_server, 4, renderer);
     }
+    if (renderer.features.timeline and backend.features.timeline) {
+        const drm_fd = renderer.getDrmFd();
+        if (drm_fd >= 0) {
+            server.linux_drm_syncobj_manager = wlr.LinuxDrmSyncobjManagerV1.create(wl_server, 1, drm_fd);
+        }
+    }
 
     if (build_options.xwayland and runtime_xwayland) {
         server.xwayland = try wlr.Xwayland.create(wl_server, compositor, false);
@@ -233,6 +237,8 @@ pub fn deinit(server: *Server) void {
 
     server.wl_server.destroyClients();
 
+    server.input_manager.new_input.link.remove();
+    server.root.new_output.link.remove();
     server.backend.destroy();
 
     // The scene graph needs to be destroyed after the backend but before the renderer
@@ -293,8 +299,12 @@ fn globalFilter(client: *const wl.Client, global: *const wl.Global, server: *Ser
 
 /// Returns true if the global is allowlisted for security contexts
 fn allowlist(server: *Server, global: *const wl.Global) bool {
-    if (server.drm) |drm| if (global == drm.global) return true;
+    if (server.linux_dmabuf) |linux_dmabuf| {
-    if (server.linux_dmabuf) |linux_dmabuf| if (global == linux_dmabuf.global) return true;
+        if (global == linux_dmabuf.global) return true;
+    }
+    if (server.linux_drm_syncobj_manager) |linux_drm_syncobj_manager| {
+        if (global == linux_drm_syncobj_manager.global) return true;
+    }
 
     // We must use the getInterface() approach for dynamically created globals
     // such as wl_output and wl_seat since the wl_global_create() function will
@@ -338,6 +348,7 @@ fn blocklist(server: *Server, global: *const wl.Global) bool {
     return global == server.security_context_manager.global or
         global == server.layer_shell.global or
         global == server.foreign_toplevel_manager.global or
+        global == server.foreign_toplevel_list.global or
         global == server.screencopy_manager.global or
         global == server.export_dmabuf_manager.global or
         global == server.data_control_manager.global or
@@ -499,7 +510,7 @@ fn handleRequestSetCursorShape(
     _: *wl.Listener(*wlr.CursorShapeManagerV1.event.RequestSetShape),
     event: *wlr.CursorShapeManagerV1.event.RequestSetShape,
 ) void {
-    const seat: *Seat = @ptrFromInt(event.seat_client.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(event.seat_client.seat.data));
 
     if (event.tablet_tool) |wp_tool| {
         assert(event.device_type == .tablet_tool);

river/StatusManager.zig

@@ -69,7 +69,7 @@ fn handleRequest(
         .get_river_output_status => |req| {
             // ignore if the output is inert
             const wlr_output = wlr.Output.fromWlOutput(req.output) orelse return;
-            const output: *Output = @ptrFromInt(wlr_output.data);
+            const output: *Output = @ptrCast(@alignCast(wlr_output.data));
 
             const resource = zriver.OutputStatusV1.create(
                 status_manager_v1.getClient(),
@@ -86,13 +86,7 @@ fn handleRequest(
         .get_river_seat_status => |req| {
             // ignore if the seat is inert
             const wlr_seat = wlr.Seat.Client.fromWlSeat(req.seat) orelse return;
-            const seat: *Seat = @ptrFromInt(wlr_seat.seat.data);
+            const seat: *Seat = @ptrCast(@alignCast(wlr_seat.seat.data));
-
-            const node = util.gpa.create(std.SinglyLinkedList(SeatStatus).Node) catch {
-                status_manager_v1.getClient().postNoMemory();
-                log.err("out of memory", .{});
-                return;
-            };
 
             const seat_status = zriver.SeatStatusV1.create(
                 status_manager_v1.getClient(),
@@ -100,13 +94,15 @@ fn handleRequest(
                 req.id,
             ) catch {
                 status_manager_v1.getClient().postNoMemory();
-                util.gpa.destroy(node);
                 log.err("out of memory", .{});
                 return;
             };
 
-            node.data.init(seat, seat_status);
+            SeatStatus.create(seat, seat_status) catch {
-            seat.status_trackers.prepend(node);
+                status_manager_v1.getClient().postNoMemory();
+                log.err("out of memory", .{});
+                return;
+            };
         },
     }
 }

river/TabletTool.zig

@@ -59,7 +59,7 @@ set_cursor: wl.Listener(*wlr.TabletV2TabletTool.event.SetCursor) =
     wl.Listener(*wlr.TabletV2TabletTool.event.SetCursor).init(handleSetCursor),
 
 pub fn get(wlr_seat: *wlr.Seat, wlr_tool: *wlr.TabletTool) error{OutOfMemory}!*TabletTool {
-    if (@as(?*TabletTool, @ptrFromInt(wlr_tool.data))) |tool| {
+    if (@as(?*TabletTool, @ptrCast(@alignCast(wlr_tool.data)))) |tool| {
         return tool;
     } else {
         return TabletTool.create(wlr_seat, wlr_tool);
@@ -81,7 +81,7 @@ fn create(wlr_seat: *wlr.Seat, wlr_tool: *wlr.TabletTool) error{OutOfMemory}!*Ta
         .wlr_cursor = wlr_cursor,
     };
 
-    wlr_tool.data = @intFromPtr(tool);
+    wlr_tool.data = tool;
 
     wlr_tool.events.destroy.add(&tool.destroy);
     tool.wp_tool.events.set_cursor.add(&tool.set_cursor);
@@ -92,7 +92,7 @@ fn create(wlr_seat: *wlr.Seat, wlr_tool: *wlr.TabletTool) error{OutOfMemory}!*Ta
 fn handleDestroy(listener: *wl.Listener(*wlr.TabletTool), _: *wlr.TabletTool) void {
     const tool: *TabletTool = @fieldParentPtr("destroy", listener);
 
-    tool.wp_tool.wlr_tool.data = 0;
+    tool.wp_tool.wlr_tool.data = null;
 
     tool.wlr_cursor.destroy();
 

river/TextInput.zig

@@ -43,7 +43,7 @@ destroy: wl.Listener(*wlr.TextInputV3) =
     wl.Listener(*wlr.TextInputV3).init(handleDestroy),
 
 pub fn create(wlr_text_input: *wlr.TextInputV3) !void {
-    const seat: *Seat = @ptrFromInt(wlr_text_input.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(wlr_text_input.seat.data));
 
     const text_input = try util.gpa.create(TextInput);
 
@@ -64,7 +64,7 @@ pub fn create(wlr_text_input: *wlr.TextInputV3) !void {
 
 fn handleEnable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
     const text_input: *TextInput = @fieldParentPtr("enable", listener);
-    const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(text_input.wlr_text_input.seat.data));
 
     if (text_input.wlr_text_input.focused_surface == null) {
         log.err("client requested to enable text input without focus, ignoring request", .{});
@@ -91,7 +91,7 @@ fn handleEnable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) v
 
 fn handleCommit(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
     const text_input: *TextInput = @fieldParentPtr("commit", listener);
-    const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(text_input.wlr_text_input.seat.data));
 
     if (seat.relay.text_input != text_input) {
         log.err("inactive text input tried to commit an update, client bug?", .{});
@@ -105,7 +105,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) v
 
 fn handleDisable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
     const text_input: *TextInput = @fieldParentPtr("disable", listener);
-    const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(text_input.wlr_text_input.seat.data));
 
     if (seat.relay.text_input == text_input) {
         seat.relay.disableTextInput();
@@ -114,7 +114,7 @@ fn handleDisable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3)
 
 fn handleDestroy(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
     const text_input: *TextInput = @fieldParentPtr("destroy", listener);
-    const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(text_input.wlr_text_input.seat.data));
 
     if (seat.relay.text_input == text_input) {
         seat.relay.disableTextInput();

river/View.zig

@@ -181,6 +181,8 @@ post_fullscreen_box: wlr.Box = undefined,
 
 foreign_toplevel_handle: ForeignToplevelHandle = .{},
 
+ext_foreign_toplevel_handle: ?*wlr.ExtForeignToplevelHandleV1 = null,
+
 /// Connector name of the output this view occupied before an evacuation.
 output_before_evac: ?[]const u8 = null,
 
@@ -275,11 +277,12 @@ pub fn resizeUpdatePosition(view: *View, width: i32, height: i32) void {
     assert(view.inflight.resizing);
 
     const data = blk: {
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |node| : (it = node.next) {
+        while (it.next()) |seat| {
-            const cursor = &node.data.cursor;
+            if (seat.cursor.inflight_mode == .resize and
-            if (cursor.inflight_mode == .resize and cursor.inflight_mode.resize.view == view) {
+                seat.cursor.inflight_mode.resize.view == view)
-                break :blk cursor.inflight_mode.resize;
+            {
+                break :blk seat.cursor.inflight_mode.resize;
             }
         } else {
             // The view resizing state should never be set when the view is
@@ -446,7 +449,11 @@ pub fn updateSceneState(view: *View) void {
         for (&view.borders, &border_boxes) |border, *border_box| {
             border_box.x += box.x;
             border_box.y += box.y;
-            _ = border_box.intersection(border_box, &output_box);
+            if (!border_box.intersection(border_box, &output_box)) {
+                // TODO(wlroots): remove this redundant code after fixed upstream
+                // https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/5084
+                border_box.* = .{ .x = 0, .y = 0, .width = 0, .height = 0 };
+            }
             border_box.x -= box.x;
             border_box.y -= box.y;
 
@@ -482,8 +489,7 @@ pub fn rootSurface(view: View) ?*wlr.Surface {
 pub fn sendFrameDone(view: View) void {
     assert(view.mapped and !view.destroying);
 
-    var now: posix.timespec = undefined;
+    const now = posix.clock_gettime(.MONOTONIC) catch @panic("CLOCK_MONOTONIC not supported");
-    posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
     view.rootSurface().?.sendFrameDone(&now);
 }
 
@@ -589,7 +595,7 @@ pub fn allowTearing(view: *View) bool {
         .window_hint => {
             if (server.config.allow_tearing) {
                 if (view.rootSurface()) |root_surface| {
-                    return server.tearing_control_manager.hintFromSurface(root_surface) == .@"async";
+                    return server.tearing_control_manager.hintFromSurface(root_surface) == .async;
                 }
             }
             return false;
@@ -653,6 +659,15 @@ pub fn map(view: *View) !void {
     assert(!view.mapped and !view.destroying);
     view.mapped = true;
 
+    if (wlr.ExtForeignToplevelHandleV1.create(server.foreign_toplevel_list, &.{
+        .title = view.getTitle(),
+        .app_id = view.getAppId(),
+    })) |handle| {
+        view.ext_foreign_toplevel_handle = handle;
+    } else |_| {
+        log.err("failed to create ext foreign toplevel handle", .{});
+    }
+
     view.foreign_toplevel_handle.map();
 
     if (server.config.rules.float.match(view)) |float| {
@@ -706,8 +721,8 @@ pub fn map(view: *View) !void {
     if (output) |o| {
         view.setPendingOutput(o);
 
-        var it = server.input_manager.seats.first;
+        var it = server.input_manager.seats.iterator(.forward);
-        while (it) |seat_node| : (it = seat_node.next) seat_node.data.focus(view);
+        while (it.next()) |seat| seat.focus(view);
     } else {
         log.debug("no output available for newly mapped view, adding to fallback stacks", .{});
 
@@ -752,6 +767,10 @@ pub fn unmap(view: *View) void {
     assert(view.mapped and !view.destroying);
     view.mapped = false;
 
+    if (view.ext_foreign_toplevel_handle) |handle| {
+        handle.destroy();
+        view.ext_foreign_toplevel_handle = null;
+    }
     view.foreign_toplevel_handle.unmap();
 
     server.root.applyPending();
@@ -761,13 +780,20 @@ pub fn notifyState(view: *const View) void {
     if (view.foreign_toplevel_handle.wlr_handle) |wlr_handle| {
         if (view.getTitle()) |title| wlr_handle.setTitle(title);
     }
+    // Send title to all status listeners attached to a seat which focuses this view
+    if (view.ext_foreign_toplevel_handle) |handle| {
+        handle.updateState(&.{
+            .title = view.getTitle(),
+            .app_id = view.getAppId(),
+        });
+    }
     // Send title and tags to all status listeners attached to a seat which focuses this view
-    var seat_it = server.input_manager.seats.first;
+    var seat_it = server.input_manager.seats.iterator(.forward);
-    while (seat_it) |seat_node| : (seat_it = seat_node.next) {
+    while (seat_it.next()) |seat| {
-        if (seat_node.data.focused == .view and seat_node.data.focused.view == view) {
+        if (seat.focused == .view and seat.focused.view == view) {
-            var client_it = seat_node.data.status_trackers.first;
+            var it = seat.status_trackers.iterator(.forward);
-            while (client_it) |client_node| : (client_it = client_node.next) {
+            while (it.next()) |tracker| {
-                client_node.data.sendFocusedView();
+                tracker.sendFocusedView();
             }
         }
     }
@@ -777,4 +803,11 @@ pub fn notifyAppId(view: View) void {
     if (view.foreign_toplevel_handle.wlr_handle) |wlr_handle| {
         if (view.getAppId()) |app_id| wlr_handle.setAppId(app_id);
     }
+
+    if (view.ext_foreign_toplevel_handle) |handle| {
+        handle.updateState(&.{
+            .title = view.getTitle(),
+            .app_id = view.getAppId(),
+        });
+    }
 }

river/XdgDecoration.zig

@@ -34,7 +34,7 @@ request_mode: wl.Listener(*wlr.XdgToplevelDecorationV1) =
     wl.Listener(*wlr.XdgToplevelDecorationV1).init(handleRequestMode),
 
 pub fn init(wlr_decoration: *wlr.XdgToplevelDecorationV1) void {
-    const toplevel: *XdgToplevel = @ptrFromInt(wlr_decoration.toplevel.base.data);
+    const toplevel: *XdgToplevel = @ptrCast(@alignCast(wlr_decoration.toplevel.base.data));
 
     toplevel.decoration = .{ .wlr_decoration = wlr_decoration };
     const decoration = &toplevel.decoration.?;
@@ -48,7 +48,7 @@ pub fn init(wlr_decoration: *wlr.XdgToplevelDecorationV1) void {
 }
 
 pub fn deinit(decoration: *XdgDecoration) void {
-    const toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.toplevel.base.data);
+    const toplevel: *XdgToplevel = @ptrCast(@alignCast(decoration.wlr_decoration.toplevel.base.data));
 
     decoration.destroy.link.remove();
     decoration.request_mode.link.remove();
@@ -72,7 +72,7 @@ fn handleRequestMode(
 ) void {
     const decoration: *XdgDecoration = @fieldParentPtr("request_mode", listener);
 
-    const toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.toplevel.base.data);
+    const toplevel: *XdgToplevel = @ptrCast(@alignCast(decoration.wlr_decoration.toplevel.base.data));
     const view = toplevel.view;
 
     const ssd = server.config.rules.ssd.match(toplevel.view) orelse

river/XdgToplevel.zig

@@ -100,8 +100,8 @@ pub fn create(wlr_toplevel: *wlr.XdgToplevel) error{OutOfMemory}!void {
 
     toplevel.view = view;
 
-    wlr_toplevel.base.data = @intFromPtr(toplevel);
+    wlr_toplevel.base.data = toplevel;
-    wlr_toplevel.base.surface.data = @intFromPtr(&view.tree.node);
+    wlr_toplevel.base.surface.data = &view.tree.node;
 
     // Add listeners that are active over the toplevel's entire lifetime
     wlr_toplevel.events.destroy.add(&toplevel.destroy);
@@ -216,7 +216,7 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
     toplevel.new_popup.link.remove();
 
     // The wlr_surface may outlive the wlr_xdg_toplevel so we must clean up the user data.
-    toplevel.wlr_toplevel.base.surface.data = 0;
+    toplevel.wlr_toplevel.base.surface.data = null;
 
     const view = toplevel.view;
     view.impl = .none;
@@ -235,7 +235,7 @@ fn handleMap(listener: *wl.Listener(void)) void {
     toplevel.wlr_toplevel.events.set_title.add(&toplevel.set_title);
     toplevel.wlr_toplevel.events.set_app_id.add(&toplevel.set_app_id);
 
-    toplevel.wlr_toplevel.base.getGeometry(&toplevel.geometry);
+    toplevel.geometry = toplevel.wlr_toplevel.base.geometry;
 
     view.pending.box = .{
         .x = 0,
@@ -338,7 +338,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
     switch (toplevel.configure_state) {
         .idle, .committed, .timed_out => {
             const old_geometry = toplevel.geometry;
-            toplevel.wlr_toplevel.base.getGeometry(&toplevel.geometry);
+            toplevel.geometry = toplevel.wlr_toplevel.base.geometry;
 
             const size_changed = toplevel.geometry.width != old_geometry.width or
                 toplevel.geometry.height != old_geometry.height;
@@ -381,7 +381,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
         // stashed buffer from when the transaction started.
         .inflight => view.sendFrameDone(),
         .acked, .timed_out_acked => {
-            toplevel.wlr_toplevel.base.getGeometry(&toplevel.geometry);
+            toplevel.geometry = toplevel.wlr_toplevel.base.geometry;
 
             if (view.inflight.resizing) {
                 view.resizeUpdatePosition(toplevel.geometry.width, toplevel.geometry.height);
@@ -423,7 +423,7 @@ fn handleRequestMove(
     event: *wlr.XdgToplevel.event.Move,
 ) void {
     const toplevel: *XdgToplevel = @fieldParentPtr("request_move", listener);
-    const seat: *Seat = @ptrFromInt(event.seat.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(event.seat.seat.data));
     const view = toplevel.view;
 
     if (view.pending.fullscreen) return;
@@ -446,7 +446,7 @@ fn handleRequestMove(
 
 fn handleRequestResize(listener: *wl.Listener(*wlr.XdgToplevel.event.Resize), event: *wlr.XdgToplevel.event.Resize) void {
     const toplevel: *XdgToplevel = @fieldParentPtr("request_resize", listener);
-    const seat: *Seat = @ptrFromInt(event.seat.seat.data);
+    const seat: *Seat = @ptrCast(@alignCast(event.seat.seat.data));
     const view = toplevel.view;
 
     if (view.pending.fullscreen) return;

river/XwaylandOverrideRedirect.zig

@@ -120,7 +120,7 @@ fn mapImpl(override_redirect: *XwaylandOverrideRedirect) error{OutOfMemory}!void
         .override_redirect = override_redirect,
     });
 
-    surface.data = @intFromPtr(&override_redirect.surface_tree.?.node);
+    surface.data = &override_redirect.surface_tree.?.node;
 
     override_redirect.surface_tree.?.node.setPosition(
         override_redirect.xwayland_surface.x,
@@ -159,15 +159,14 @@ fn handleUnmap(listener: *wl.Listener(void)) void {
 
     override_redirect.set_geometry.link.remove();
 
-    override_redirect.xwayland_surface.surface.?.data = 0;
+    override_redirect.xwayland_surface.surface.?.data = null;
     override_redirect.surface_tree.?.node.destroy();
     override_redirect.surface_tree = null;
 
     // If the unmapped surface is currently focused, pass keyboard focus
     // to the most appropriate surface.
-    var seat_it = server.input_manager.seats.first;
+    var seat_it = server.input_manager.seats.iterator(.forward);
-    while (seat_it) |seat_node| : (seat_it = seat_node.next) {
+    while (seat_it.next()) |seat| {
-        const seat = &seat_node.data;
         if (seat.focused == .view and seat.focused.view.impl == .xwayland_view and
             seat.focused.view.impl.xwayland_view.xwayland_surface.pid == override_redirect.xwayland_surface.pid and
             seat.wlr_seat.keyboard_state.focused_surface == override_redirect.xwayland_surface.surface)

river/XwaylandView.zig

@@ -100,7 +100,7 @@ pub fn configure(xwayland_view: XwaylandView) bool {
         xwayland_view.xwayland_surface.height == inflight.box.height and
         (inflight.focus != 0) == (current.focus != 0) and
         (output.inflight.fullscreen == xwayland_view.view) ==
-        (current.output != null and current.output.?.current.fullscreen == xwayland_view.view))
+            (current.output != null and current.output.?.current.fullscreen == xwayland_view.view))
     {
         return false;
     }
@@ -164,7 +164,7 @@ pub fn handleMap(listener: *wl.Listener(void)) void {
 
     const xwayland_surface = xwayland_view.xwayland_surface;
     const surface = xwayland_surface.surface.?;
-    surface.data = @intFromPtr(&view.tree.node);
+    surface.data = &view.tree.node;
 
     // Add listeners that are only active while mapped
     xwayland_surface.events.set_title.add(&xwayland_view.set_title);
@@ -215,11 +215,12 @@ pub fn handleMap(listener: *wl.Listener(void)) void {
 fn handleUnmap(listener: *wl.Listener(void)) void {
     const xwayland_view: *XwaylandView = @fieldParentPtr("unmap", listener);
 
-    xwayland_view.xwayland_surface.surface.?.data = 0;
+    xwayland_view.xwayland_surface.surface.?.data = null;
 
     // Remove listeners that are only active while mapped
     xwayland_view.set_title.link.remove();
     xwayland_view.set_class.link.remove();
+    xwayland_view.set_decorations.link.remove();
     xwayland_view.request_fullscreen.link.remove();
     xwayland_view.request_minimize.link.remove();
 

river/c.zig

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-pub usingnamespace @cImport({
+pub const c = @cImport({
     @cDefine("_POSIX_C_SOURCE", "200809L");
 
     @cInclude("stdlib.h");

river/command.zig

@@ -122,6 +122,7 @@ pub const Error = error{
     CannotParseFile,
     UnknownOption,
     ConflictingOptions,
+    WriteFailed,
     OutOfMemory,
     Other,
 };
@@ -165,7 +166,7 @@ pub fn errToMsg(err: Error) [:0]const u8 {
         Error.InvalidValue => "invalid value",
         Error.CannotReadFile => "cannot read file",
         Error.CannotParseFile => "cannot parse file",
-        Error.OutOfMemory => "out of memory",
+        Error.WriteFailed, Error.OutOfMemory => "out of memory",
         Error.Other => unreachable,
     };
 }

river/command/cursor.zig

@@ -35,9 +35,8 @@ pub fn cursor(
         if (args.len < 3) return Error.NotEnoughArguments;
         if (args.len > 3) return Error.TooManyArguments;
         server.config.cursor_hide_timeout = try std.fmt.parseInt(u31, args[2], 10);
-        var seat_it = server.input_manager.seats.first;
+        var seat_it = server.input_manager.seats.iterator(.forward);
-        while (seat_it) |seat_node| : (seat_it = seat_node.next) {
+        while (seat_it.next()) |seat| {
-            const seat = &seat_node.data;
             seat.cursor.unhide();
         }
     } else if (std.mem.eql(u8, "when-typing", args[1])) {

river/command/input.zig

@@ -34,8 +34,8 @@ pub fn listInputs(
 ) Error!void {
     if (args.len > 1) return error.TooManyArguments;
 
-    var input_list = std.ArrayList(u8).init(util.gpa);
+    var aw: std.Io.Writer.Allocating = .init(util.gpa);
-    const writer = input_list.writer();
+
     var prev = false;
 
     var it = server.input_manager.devices.iterator(.forward);
@@ -46,16 +46,16 @@ pub fn listInputs(
             }
         } else false;
 
-        if (prev) try input_list.appendSlice("\n");
+        if (prev) try aw.writer.writeByte('\n');
         prev = true;
 
-        try writer.print("{s}\n\tconfigured: {}\n", .{
+        try aw.writer.print("{s}\n\tconfigured: {}\n", .{
             device.identifier,
             configured,
         });
     }
 
-    out.* = try input_list.toOwnedSlice();
+    out.* = try aw.toOwnedSlice();
 }
 
 pub fn listInputConfigs(
@@ -65,15 +65,14 @@ pub fn listInputConfigs(
 ) Error!void {
     if (args.len > 1) return error.TooManyArguments;
 
-    var input_list = std.ArrayList(u8).init(util.gpa);
+    var aw: std.Io.Writer.Allocating = .init(util.gpa);
-    const writer = input_list.writer();
 
     for (server.input_manager.configs.items, 0..) |*input_config, i| {
-        if (i > 0) try writer.writeByte('\n');
+        if (i > 0) try aw.writer.writeByte('\n');
-        try input_config.write(writer);
+        try input_config.write(&aw.writer);
     }
 
-    out.* = try input_list.toOwnedSlice();
+    out.* = try aw.toOwnedSlice();
 }
 
 pub fn input(
@@ -99,7 +98,7 @@ pub fn input(
         };
         errdefer util.gpa.free(input_config.glob);
 
-        try server.input_manager.configs.ensureUnusedCapacity(1);
+        try server.input_manager.configs.ensureUnusedCapacity(util.gpa, 1);
 
         try input_config.parse(args[2], args[3]);
 

river/command/layout.zig

@@ -71,9 +71,8 @@ pub fn sendLayoutCmd(
     const output = seat.focused_output orelse return;
     const target_namespace = args[1];
 
-    var it = output.layouts.first;
+    var it = output.layouts.iterator(.forward);
-    const layout = while (it) |node| : (it = node.next) {
+    const layout = while (it.next()) |layout| {
-        const layout = &node.data;
         if (mem.eql(u8, layout.namespace, target_namespace)) break layout;
     } else return;
 

river/command/map.zig

@@ -22,7 +22,7 @@ const wlr = @import("wlroots");
 const xkb = @import("xkbcommon");
 const flags = @import("flags");
 
-const c = @import("../c.zig");
+const c = @import("../c.zig").c;
 const server = &@import("../main.zig").server;
 const util = @import("../util.zig");
 
@@ -285,7 +285,7 @@ fn parseKeysym(name: [:0]const u8, out: *?[]const u8) !xkb.Keysym {
 }
 
 fn parseModifiers(modifiers_str: []const u8, out: *?[]const u8) !wlr.Keyboard.ModifierMask {
-    var it = mem.split(u8, modifiers_str, "+");
+    var it = mem.splitScalar(u8, modifiers_str, '+');
     var modifiers = wlr.Keyboard.ModifierMask{};
     outer: while (it.next()) |mod_name| {
         if (mem.eql(u8, mod_name, "None")) continue;

river/command/output.zig

@@ -109,7 +109,7 @@ fn getOutput(seat: *Seat, str: []const u8) !?*Output {
                 .previous => link.prev.?,
             };
         }
-        return @as(*Output, @fieldParentPtr("active_link", link));
+        return @fieldParentPtr("active_link", link);
     } else if (std.meta.stringToEnum(wlr.OutputLayout.Direction, str)) |direction| { // Spacial direction
         var focus_box: wlr.Box = undefined;
         server.root.output_layout.getBox(seat.focused_output.?.wlr_output, &focus_box);
@@ -121,7 +121,7 @@ fn getOutput(seat: *Seat, str: []const u8) !?*Output {
             @floatFromInt(focus_box.x + @divTrunc(focus_box.width, 2)),
             @floatFromInt(focus_box.y + @divTrunc(focus_box.height, 2)),
         ) orelse return null;
-        return @as(*Output, @ptrFromInt(wlr_output.data));
+        return @ptrCast(@alignCast(wlr_output.data));
     } else {
         // Check if an output matches by name
         var it = server.root.active_outputs.iterator(.forward);

river/command/rule.zig

@@ -15,6 +15,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const assert = std.debug.assert;
 const fmt = std.fmt;
 
 const globber = @import("globber");
@@ -27,6 +28,7 @@ const Error = @import("../command.zig").Error;
 const Seat = @import("../Seat.zig");
 const View = @import("../View.zig");
 const Anchor = @import("../Config.zig").Anchor;
+const RuleGlobs = @import("../rule_list.zig").RuleGlobs;
 
 const Action = enum {
     float,
@@ -187,7 +189,7 @@ pub fn ruleDel(_: *Seat, args: []const [:0]const u8, _: *?[]const u8) Error!void
 
     const action = std.meta.stringToEnum(Action, result.args[0]) orelse return Error.UnknownOption;
 
-    const rule = .{
+    const rule: RuleGlobs = .{
         .app_id_glob = result.flags.@"app-id" orelse "*",
         .title_glob = result.flags.title orelse "*",
     };
@@ -249,6 +251,12 @@ fn apply_tearing_rules() void {
     }
 }
 
+fn alignLeft(buf: []const u8, width: usize, writer: *std.io.Writer) Error!void {
+    assert(buf.len <= width);
+    try writer.writeAll(buf);
+    try writer.splatByteAll(' ', width - buf.len);
+}
+
 pub fn listRules(_: *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;
@@ -270,11 +278,12 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
     const app_id_column_max = 2 + @max("app-id".len, max_glob_len.app_id);
     const title_column_max = 2 + @max("title".len, max_glob_len.title);
 
-    var buffer = std.ArrayList(u8).init(util.gpa);
+    var buffer = std.io.Writer.Allocating.init(util.gpa);
-    const writer = buffer.writer();
+    defer buffer.deinit();
+    const writer = &buffer.writer;
 
-    try fmt.formatBuf("title", .{ .width = title_column_max, .alignment = .left }, writer);
+    try alignLeft("title", title_column_max, writer);
-    try fmt.formatBuf("app-id", .{ .width = app_id_column_max, .alignment = .left }, writer);
+    try alignLeft("app-id", app_id_column_max, writer);
     try writer.writeAll("action\n");
 
     switch (rule_list) {
@@ -289,8 +298,8 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
                 else => unreachable,
             };
             for (rules) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.title_glob, title_column_max, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.app_id_glob, app_id_column_max, writer);
                 try writer.print("{s}\n", .{switch (list) {
                     .float => if (rule.value) "float" else "no-float",
                     .ssd => if (rule.value) "ssd" else "csd",
@@ -304,22 +313,22 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
         },
         .tags => {
             for (server.config.rules.tags.rules.items) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.title_glob, title_column_max, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.app_id_glob, app_id_column_max, writer);
                 try writer.print("{b}\n", .{rule.value});
             }
         },
         .position => {
             for (server.config.rules.position.rules.items) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.title_glob, title_column_max, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.app_id_glob, app_id_column_max, writer);
-                try writer.print("{s},{d},{d}", .{ @tagName(rule.value.anchor), rule.value.x, rule.value.y });
+                try writer.print("{s},{d},{d}\n", .{ @tagName(rule.value.anchor), rule.value.x, rule.value.y });
             }
         },
         .dimensions => {
             for (server.config.rules.dimensions.rules.items) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.title_glob, title_column_max, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
+                try alignLeft(rule.app_id_glob, app_id_column_max, writer);
                 try writer.print("{d}x{d}\n", .{ rule.value.width, rule.value.height });
             }
         },

river/command/spawn.zig

@@ -17,7 +17,7 @@
 const std = @import("std");
 const posix = std.posix;
 
-const c = @import("../c.zig");
+const c = @import("../c.zig").c;
 const util = @import("../util.zig");
 const process = @import("../process.zig");
 

river/command/view_operations.zig

@@ -78,12 +78,7 @@ fn getTarget(seat: *Seat, direction_str: []const u8, target_mode: TargetMode) !?
     if (seat.focused.view.pending.fullscreen) return null;
     if (target_mode == .skip_float and seat.focused.view.pending.float) return null;
     const output = seat.focused_output orelse return null;
-
+    if (seat.focused.view.pending.output != output) return null;
-    // If no currently view is focused, focus the first in the stack.
-    if (seat.focused != .view) {
-        var it = output.pending.wm_stack.iterator(.forward);
-        return it.next();
-    }
 
     // Logical direction, based on the view stack.
     if (std.meta.stringToEnum(Direction, direction_str)) |direction| {

river/main.zig

@@ -18,14 +18,13 @@ const build_options = @import("build_options");
 const std = @import("std");
 const mem = std.mem;
 const fs = std.fs;
-const io = std.io;
 const log = std.log;
 const posix = std.posix;
 const builtin = @import("builtin");
 const wlr = @import("wlroots");
 const flags = @import("flags");
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 const util = @import("util.zig");
 const process = @import("process.zig");
 
@@ -52,21 +51,21 @@ pub fn main() anyerror!void {
         .{ .name = "log-level", .kind = .arg },
         .{ .name = "no-xwayland", .kind = .boolean },
     }).parse(std.os.argv[1..]) catch {
-        try io.getStdErr().writeAll(usage);
+        try fs.File.stderr().writeAll(usage);
         posix.exit(1);
     };
     if (result.flags.h) {
-        try io.getStdOut().writeAll(usage);
+        try fs.File.stdout().writeAll(usage);
         posix.exit(0);
     }
     if (result.args.len != 0) {
         log.err("unknown option '{s}'", .{result.args[0]});
-        try io.getStdErr().writeAll(usage);
+        try fs.File.stderr().writeAll(usage);
         posix.exit(1);
     }
 
     if (result.flags.version) {
-        try io.getStdOut().writeAll(build_options.version ++ "\n");
+        try fs.File.stdout().writeAll(build_options.version ++ "\n");
         posix.exit(0);
     }
     if (result.flags.@"log-level") |level| {
@@ -80,7 +79,7 @@ pub fn main() anyerror!void {
             runtime_log_level = .debug;
         } else {
             log.err("invalid log level '{s}'", .{level});
-            try io.getStdErr().writeAll(usage);
+            try fs.File.stderr().writeAll(usage);
             posix.exit(1);
         }
     }
@@ -189,7 +188,10 @@ pub fn logFn(
 
     const scope_prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
 
-    const stderr = io.getStdErr().writer();
+    var buffer: [256]u8 = undefined;
+    const stderr = std.debug.lockStderrWriter(&buffer);
+    defer std.debug.unlockStderrWriter();
+
     stderr.print(level.asText() ++ scope_prefix ++ format ++ "\n", args) catch {};
 }
 

river/process.zig

@@ -17,7 +17,7 @@
 const std = @import("std");
 const posix = std.posix;
 
-const c = @import("c.zig");
+const c = @import("c.zig").c;
 
 var original_rlimit: ?posix.rlimit = null;
 
@@ -26,10 +26,10 @@ pub fn setup() void {
     // has had its read end closed by another process.
     const sig_ign = posix.Sigaction{
         .handler = .{ .handler = posix.SIG.IGN },
-        .mask = posix.empty_sigset,
+        .mask = posix.sigemptyset(),
         .flags = 0,
     };
-    posix.sigaction(posix.SIG.PIPE, &sig_ign, null) catch unreachable;
+    posix.sigaction(posix.SIG.PIPE, &sig_ign, null);
 
     // Most unix systems have a default limit of 1024 file descriptors and it
     // seems unlikely for this default to be universally raised due to the
@@ -61,14 +61,14 @@ pub fn setup() void {
 
 pub fn cleanupChild() void {
     if (c.setsid() < 0) unreachable;
-    if (posix.system.sigprocmask(posix.SIG.SETMASK, &posix.empty_sigset, null) < 0) unreachable;
+    if (posix.system.sigprocmask(posix.SIG.SETMASK, &posix.sigemptyset(), null) < 0) unreachable;
 
     const sig_dfl = posix.Sigaction{
         .handler = .{ .handler = posix.SIG.DFL },
-        .mask = posix.empty_sigset,
+        .mask = posix.sigemptyset(),
         .flags = 0,
     };
-    posix.sigaction(posix.SIG.PIPE, &sig_dfl, null) catch unreachable;
+    posix.sigaction(posix.SIG.PIPE, &sig_dfl, null);
 
     if (original_rlimit) |original| {
         posix.setrlimit(.NOFILE, original) catch {

river/rule_list.zig

@@ -23,6 +23,11 @@ const util = @import("util.zig");
 
 const View = @import("View.zig");
 
+pub const RuleGlobs = struct {
+    app_id_glob: []const u8,
+    title_glob: []const u8,
+};
+
 pub const MaxGlobLen = struct {
     app_id: usize,
     title: usize,
@@ -83,7 +88,7 @@ pub fn RuleList(comptime T: type) type {
             });
         }
 
-        pub fn del(list: *List, rule: struct { app_id_glob: []const u8, title_glob: []const u8 }) ?T {
+        pub fn del(list: *List, rule: RuleGlobs) ?T {
             for (list.rules.items, 0..) |existing, i| {
                 if (mem.eql(u8, rule.app_id_glob, existing.app_id_glob) and
                     mem.eql(u8, rule.title_glob, existing.title_glob))

riverctl/main.zig

@@ -16,7 +16,7 @@
 
 const std = @import("std");
 const mem = std.mem;
-const io = std.io;
+const fs = std.fs;
 const posix = std.posix;
 const assert = std.debug.assert;
 const builtin = @import("builtin");
@@ -73,15 +73,15 @@ fn _main() !void {
         .{ .name = "h", .kind = .boolean },
         .{ .name = "version", .kind = .boolean },
     }).parse(std.os.argv[1..]) catch {
-        try io.getStdErr().writeAll(usage);
+        try fs.File.stderr().writeAll(usage);
         posix.exit(1);
     };
     if (result.flags.h) {
-        try io.getStdOut().writeAll(usage);
+        try fs.File.stdout().writeAll(usage);
         posix.exit(0);
     }
     if (result.flags.version) {
-        try io.getStdOut().writeAll(@import("build_options").version ++ "\n");
+        try fs.File.stdout().writeAll(@import("build_options").version ++ "\n");
         posix.exit(0);
     }
 
@@ -125,8 +125,8 @@ fn callbackListener(_: *zriver.CommandCallbackV1, event: zriver.CommandCallbackV
     switch (event) {
         .success => |success| {
             if (mem.len(success.output) > 0) {
-                const stdout = io.getStdOut().writer();
+                var stdout = fs.File.stdout().writer(&.{});
-                stdout.print("{s}\n", .{success.output}) catch @panic("failed to write to stdout");
+                stdout.interface.print("{s}\n", .{success.output}) catch @panic("failed to write to stdout");
             }
             posix.exit(0);
         },
@@ -134,7 +134,7 @@ fn callbackListener(_: *zriver.CommandCallbackV1, event: zriver.CommandCallbackV
             // A small hack to provide usage text when river reports an unknown command.
             if (mem.orderZ(u8, failure.failure_message, "unknown command") == .eq) {
                 std.log.err("unknown command", .{});
-                io.getStdErr().writeAll(usage) catch {};
+                fs.File.stderr().writeAll(usage) catch {};
                 posix.exit(1);
             }
             fatal("{s}", .{failure.failure_message});

rivertile/main.zig

@@ -91,15 +91,12 @@ const gpa = std.heap.c_allocator;
 const Context = struct {
     initialized: bool = false,
     layout_manager: ?*river.LayoutManagerV3 = null,
-    outputs: std.TailQueue(Output) = .{},
+    outputs: wl.list.Head(Output, .link),
 
     fn addOutput(context: *Context, registry: *wl.Registry, name: u32) !void {
         const wl_output = try registry.bind(name, wl.Output, 3);
         errdefer wl_output.release();
-        const node = try gpa.create(std.TailQueue(Output).Node);
+        try Output.create(context, wl_output, name);
-        errdefer gpa.destroy(node);
-        try node.data.init(context, wl_output, name);
-        context.outputs.append(node);
     }
 };
 
@@ -113,15 +110,21 @@ const Output = struct {
 
     layout: *river.LayoutV3 = undefined,
 
-    fn init(output: *Output, context: *Context, wl_output: *wl.Output, name: u32) !void {
+    link: wl.list.Link,
+
+    fn create(context: *Context, wl_output: *wl.Output, name: u32) !void {
+        const output = try gpa.create(Output);
+        errdefer gpa.destroy(output);
         output.* = .{
             .wl_output = wl_output,
             .name = name,
             .main_location = default_main_location,
             .main_count = default_main_count,
             .main_ratio = default_main_ratio,
+            .link = undefined,
         };
         if (context.initialized) try output.getLayout(context);
+        context.outputs.append(output);
     }
 
     fn getLayout(output: *Output, context: *Context) !void {
@@ -130,9 +133,11 @@ const Output = struct {
         output.layout.setListener(*Output, layoutListener, output);
     }
 
-    fn deinit(output: *Output) void {
+    fn destroy(output: *Output) void {
         output.wl_output.release();
         output.layout.destroy();
+        output.link.remove();
+        gpa.destroy(output);
     }
 
     fn layoutListener(layout: *river.LayoutV3, event: river.LayoutV3.Event, output: *Output) void {
@@ -140,7 +145,7 @@ const Output = struct {
             .namespace_in_use => fatal("namespace 'rivertile' already in use.", .{}),
 
             .user_command => |ev| {
-                var it = mem.tokenize(u8, mem.span(ev.command), " ");
+                var it = mem.tokenizeScalar(u8, mem.span(ev.command), ' ');
                 const raw_cmd = it.next() orelse {
                     std.log.err("not enough arguments", .{});
                     return;
@@ -312,17 +317,17 @@ pub fn main() !void {
         .{ .name = "main-count", .kind = .arg },
         .{ .name = "main-ratio", .kind = .arg },
     }).parse(std.os.argv[1..]) catch {
-        try std.io.getStdErr().writeAll(usage);
+        try std.fs.File.stderr().writeAll(usage);
         posix.exit(1);
     };
     if (result.flags.h) {
-        try std.io.getStdOut().writeAll(usage);
+        try std.fs.File.stdout().writeAll(usage);
         posix.exit(0);
     }
     if (result.args.len != 0) fatalPrintUsage("unknown option '{s}'", .{result.args[0]});
 
     if (result.flags.version) {
-        try std.io.getStdOut().writeAll(@import("build_options").version ++ "\n");
+        try std.fs.File.stdout().writeAll(@import("build_options").version ++ "\n");
         posix.exit(0);
     }
     if (result.flags.@"view-padding") |raw| {
@@ -356,7 +361,10 @@ pub fn main() !void {
     };
     defer display.disconnect();
 
-    var context: Context = .{};
+    var context: Context = .{
+        .outputs = undefined,
+    };
+    context.outputs.init();
 
     const registry = try display.getRegistry();
     registry.setListener(*Context, registryListener, &context);
@@ -368,9 +376,8 @@ pub fn main() !void {
 
     context.initialized = true;
 
-    var it = context.outputs.first;
+    var it = context.outputs.iterator(.forward);
-    while (it) |node| : (it = node.next) {
+    while (it.next()) |output| {
-        const output = &node.data;
         try output.getLayout(&context);
     }
 
@@ -389,13 +396,10 @@ fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, context: *
             }
         },
         .global_remove => |ev| {
-            var it = context.outputs.first;
+            var it = context.outputs.safeIterator(.forward);
-            while (it) |node| : (it = node.next) {
+            while (it.next()) |output| {
-                const output = &node.data;
                 if (output.name == ev.name) {
-                    context.outputs.remove(node);
+                    output.destroy();
-                    output.deinit();
-                    gpa.destroy(node);
                     break;
                 }
             }
@@ -410,7 +414,7 @@ fn fatal(comptime format: []const u8, args: anytype) noreturn {
 
 fn fatalPrintUsage(comptime format: []const u8, args: anytype) noreturn {
     std.log.err(format, args);
-    std.io.getStdErr().writeAll(usage) catch {};
+    std.fs.File.stderr().writeAll(usage) catch {};
     posix.exit(1);
 }