Zander671/river
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

build: update to Zig 0.12

Browse Source
This commit is contained in:
Isaac Freund 2024-03-07 16:19:22 +01:00
parent 680cb8ef69
commit 033cad47bf
No known key found for this signature in database
GPG Key ID: 86DED400DDFD7A11
51 changed files with 285 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.builds/alpine.yml
View File

@ -40,11 +40,11 @@ tasks:
sudo ninja -C build/ install sudo ninja -C build/ install
cd .. cd ..
wget -nv https://ziglang.org/download/0.11.0/zig-linux-x86_64-0.11.0.tar.xz wget -nv https://ziglang.org/download/0.12.0/zig-linux-x86_64-0.12.0.tar.xz
# Remove a lot of useless lines from tar output. # Remove a lot of useless lines from tar output.
tar -xvf zig-linux-x86_64-0.11.0.tar.xz 1>/dev/null tar -xvf zig-linux-x86_64-0.12.0.tar.xz 1>/dev/null
sudo mv zig-linux-x86_64-0.11.0/zig /usr/bin/ sudo mv zig-linux-x86_64-0.12.0/zig /usr/bin/
sudo mv zig-linux-x86_64-0.11.0/lib /usr/lib/zig sudo mv zig-linux-x86_64-0.12.0/lib /usr/lib/zig
- build: | - build: |
cd river cd river
zig build zig build

8
.builds/archlinux.yml
View File

@ -38,11 +38,11 @@ tasks:
sudo ninja -C build/ install sudo ninja -C build/ install
cd .. cd ..
wget -nv https://ziglang.org/download/0.11.0/zig-linux-x86_64-0.11.0.tar.xz wget -nv https://ziglang.org/download/0.12.0/zig-linux-x86_64-0.12.0.tar.xz
# Remove a lot of useless lines from tar output. # Remove a lot of useless lines from tar output.
tar -xvf zig-linux-x86_64-0.11.0.tar.xz 1>/dev/null tar -xvf zig-linux-x86_64-0.12.0.tar.xz 1>/dev/null
sudo mv zig-linux-x86_64-0.11.0/zig /usr/bin/ sudo mv zig-linux-x86_64-0.12.0/zig /usr/bin/
sudo mv zig-linux-x86_64-0.11.0/lib /usr/lib/zig sudo mv zig-linux-x86_64-0.12.0/lib /usr/lib/zig
- build: | - build: |
cd river cd river
zig build zig build

8
.builds/freebsd.yml
View File

@ -42,11 +42,11 @@ tasks:
sudo ninja -C build/ install sudo ninja -C build/ install
cd .. cd ..
wget -nv https://ziglang.org/download/0.11.0/zig-freebsd-x86_64-0.11.0.tar.xz wget -nv https://ziglang.org/download/0.12.0/zig-freebsd-x86_64-0.12.0.tar.xz
# Remove a lot of useless lines from tar output. # Remove a lot of useless lines from tar output.
tar -xvf zig-freebsd-x86_64-0.11.0.tar.xz 1>/dev/null tar -xvf zig-freebsd-x86_64-0.12.0.tar.xz 1>/dev/null
sudo mv zig-freebsd-x86_64-0.11.0/zig /usr/bin/ sudo mv zig-freebsd-x86_64-0.12.0/zig /usr/bin/
sudo mv zig-freebsd-x86_64-0.11.0/lib /usr/lib/zig sudo mv zig-freebsd-x86_64-0.12.0/lib /usr/lib/zig
- build: | - build: |
cd river cd river
zig build zig build

2
README.md
View File

@ -62,7 +62,7 @@ To compile river first ensure that you have the following dependencies
installed. The "development" versions are required if applicable to your installed. The "development" versions are required if applicable to your
distribution. distribution.
- [zig](https://ziglang.org/download/) 0.11 - [zig](https://ziglang.org/download/) 0.12
- wayland - wayland
- wayland-protocols - wayland-protocols
- [wlroots](https://gitlab.freedesktop.org/wlroots/wlroots) 0.17.2 - [wlroots](https://gitlab.freedesktop.org/wlroots/wlroots) 0.17.2

83
build.zig
View File

@ -64,7 +64,7 @@ pub fn build(b: *Build) !void {
if (mem.endsWith(u8, version, "-dev")) { if (mem.endsWith(u8, version, "-dev")) {
var ret: u8 = undefined; var ret: u8 = undefined;
const git_describe_long = b.execAllowFail( const git_describe_long = b.runAllowFail(
&.{ "git", "-C", b.build_root.path orelse ".", "describe", "--long" }, &.{ "git", "-C", b.build_root.path orelse ".", "describe", "--long" },
&ret, &ret,
.Inherit, .Inherit,
@ -91,12 +91,12 @@ pub fn build(b: *Build) !void {
const scanner = Scanner.create(b, .{}); const scanner = Scanner.create(b, .{});
scanner.addSystemProtocol("stable/xdg-shell/xdg-shell.xml"); scanner.addSystemProtocol("stable/xdg-shell/xdg-shell.xml");
scanner.addSystemProtocol("staging/ext-session-lock/ext-session-lock-v1.xml");
scanner.addSystemProtocol("unstable/pointer-gestures/pointer-gestures-unstable-v1.xml");
scanner.addSystemProtocol("unstable/pointer-constraints/pointer-constraints-unstable-v1.xml");
scanner.addSystemProtocol("unstable/xdg-decoration/xdg-decoration-unstable-v1.xml");
scanner.addSystemProtocol("unstable/tablet/tablet-unstable-v2.xml");
scanner.addSystemProtocol("staging/cursor-shape/cursor-shape-v1.xml"); scanner.addSystemProtocol("staging/cursor-shape/cursor-shape-v1.xml");
scanner.addSystemProtocol("staging/ext-session-lock/ext-session-lock-v1.xml");
scanner.addSystemProtocol("unstable/pointer-constraints/pointer-constraints-unstable-v1.xml");
scanner.addSystemProtocol("unstable/pointer-gestures/pointer-gestures-unstable-v1.xml");
scanner.addSystemProtocol("unstable/tablet/tablet-unstable-v2.xml");
scanner.addSystemProtocol("unstable/xdg-decoration/xdg-decoration-unstable-v1.xml");
scanner.addCustomProtocol("protocol/river-control-unstable-v1.xml"); scanner.addCustomProtocol("protocol/river-control-unstable-v1.xml");
scanner.addCustomProtocol("protocol/river-status-unstable-v1.xml"); scanner.addCustomProtocol("protocol/river-status-unstable-v1.xml");
@ -131,24 +131,36 @@ pub fn build(b: *Build) !void {
scanner.generate("zwlr_layer_shell_v1", 4); scanner.generate("zwlr_layer_shell_v1", 4);
scanner.generate("zwlr_output_power_manager_v1", 1); scanner.generate("zwlr_output_power_manager_v1", 1);
const wayland = b.createModule(.{ .source_file = scanner.result }); const wayland = b.createModule(.{
.root_source_file = scanner.result,
.target = target,
});
const xkbcommon = b.createModule(.{ const xkbcommon = b.createModule(.{
.source_file = .{ .path = "deps/zig-xkbcommon/src/xkbcommon.zig" }, .root_source_file = .{ .path = "deps/zig-xkbcommon/src/xkbcommon.zig" },
.target = target,
}); });
xkbcommon.linkSystemLibrary("xkbcommon", .{});
const pixman = b.createModule(.{ const pixman = b.createModule(.{
.source_file = .{ .path = "deps/zig-pixman/pixman.zig" }, .root_source_file = .{ .path = "deps/zig-pixman/pixman.zig" },
.target = target,
}); });
pixman.linkSystemLibrary("pixman-1", .{});
const wlroots = b.createModule(.{ const wlroots = b.createModule(.{
.source_file = .{ .path = "deps/zig-wlroots/src/wlroots.zig" }, .root_source_file = .{ .path = "deps/zig-wlroots/src/wlroots.zig" },
.dependencies = &.{ .imports = &.{
.{ .name = "wayland", .module = wayland }, .{ .name = "wayland", .module = wayland },
.{ .name = "xkbcommon", .module = xkbcommon }, .{ .name = "xkbcommon", .module = xkbcommon },
.{ .name = "pixman", .module = pixman }, .{ .name = "pixman", .module = pixman },
}, },
.target = target,
}); });
wlroots.linkSystemLibrary("wlroots", .{});
const flags = b.createModule(.{ .source_file = .{ .path = "common/flags.zig" } }); const flags = b.createModule(.{ .root_source_file = .{ .path = "common/flags.zig" } });
const globber = b.createModule(.{ .source_file = .{ .path = "common/globber.zig" } }); const globber = b.createModule(.{ .root_source_file = .{ .path = "common/globber.zig" } });
{ {
const river = b.addExecutable(.{ const river = b.addExecutable(.{
@ -156,38 +168,33 @@ pub fn build(b: *Build) !void {
.root_source_file = .{ .path = "river/main.zig" }, .root_source_file = .{ .path = "river/main.zig" },
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
.strip = strip,
}); });
river.addOptions("build_options", options); river.root_module.addOptions("build_options", options);
river.linkLibC(); river.linkLibC();
river.linkSystemLibrary("libevdev"); river.linkSystemLibrary("libevdev");
river.linkSystemLibrary("libinput"); river.linkSystemLibrary("libinput");
river.addModule("wayland", wayland);
river.linkSystemLibrary("wayland-server"); river.linkSystemLibrary("wayland-server");
river.addModule("xkbcommon", xkbcommon); river.root_module.addImport("wayland", wayland);
river.linkSystemLibrary("xkbcommon"); river.root_module.addImport("xkbcommon", xkbcommon);
river.root_module.addImport("pixman", pixman);
river.root_module.addImport("wlroots", wlroots);
river.root_module.addImport("flags", flags);
river.root_module.addImport("globber", globber);
river.addModule("pixman", pixman);
river.linkSystemLibrary("pixman-1");
river.addModule("wlroots", wlroots);
river.linkSystemLibrary("wlroots");
river.addModule("flags", flags);
river.addModule("globber", globber);
river.addCSourceFile(.{ river.addCSourceFile(.{
.file = .{ .path = "river/wlroots_log_wrapper.c" }, .file = .{ .path = "river/wlroots_log_wrapper.c" },
.flags = &.{ "-std=c99", "-O2" }, .flags = &.{ "-std=c99", "-O2" },
}); });
river.linkSystemLibrary("wlroots");
// TODO: remove when zig issue #131 is implemented // TODO: remove when zig issue #131 is implemented
scanner.addCSource(river); scanner.addCSource(river);
river.strip = strip;
river.pie = pie; river.pie = pie;
river.omit_frame_pointer = omit_frame_pointer; river.root_module.omit_frame_pointer = omit_frame_pointer;
b.installArtifact(river); b.installArtifact(river);
} }
@ -198,19 +205,19 @@ pub fn build(b: *Build) !void {
.root_source_file = .{ .path = "riverctl/main.zig" }, .root_source_file = .{ .path = "riverctl/main.zig" },
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
.strip = strip,
}); });
riverctl.addOptions("build_options", options); riverctl.root_module.addOptions("build_options", options);
riverctl.addModule("flags", flags); riverctl.root_module.addImport("flags", flags);
riverctl.addModule("wayland", wayland); riverctl.root_module.addImport("wayland", wayland);
riverctl.linkLibC(); riverctl.linkLibC();
riverctl.linkSystemLibrary("wayland-client"); riverctl.linkSystemLibrary("wayland-client");
scanner.addCSource(riverctl); scanner.addCSource(riverctl);
riverctl.strip = strip;
riverctl.pie = pie; riverctl.pie = pie;
riverctl.omit_frame_pointer = omit_frame_pointer; riverctl.root_module.omit_frame_pointer = omit_frame_pointer;
b.installArtifact(riverctl); b.installArtifact(riverctl);
} }
@ -221,19 +228,19 @@ pub fn build(b: *Build) !void {
.root_source_file = .{ .path = "rivertile/main.zig" }, .root_source_file = .{ .path = "rivertile/main.zig" },
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
.strip = strip,
}); });
rivertile.addOptions("build_options", options); rivertile.root_module.addOptions("build_options", options);
rivertile.addModule("flags", flags); rivertile.root_module.addImport("flags", flags);
rivertile.addModule("wayland", wayland); rivertile.root_module.addImport("wayland", wayland);
rivertile.linkLibC(); rivertile.linkLibC();
rivertile.linkSystemLibrary("wayland-client"); rivertile.linkSystemLibrary("wayland-client");
scanner.addCSource(rivertile); scanner.addCSource(rivertile);
rivertile.strip = strip;
rivertile.pie = pie; rivertile.pie = pie;
rivertile.omit_frame_pointer = omit_frame_pointer; rivertile.root_module.omit_frame_pointer = omit_frame_pointer;
b.installArtifact(rivertile); b.installArtifact(rivertile);
} }

6
common/flags.zig
View File

@ -18,7 +18,7 @@ const std = @import("std");
const mem = std.mem; const mem = std.mem;
pub const Flag = struct { pub const Flag = struct {
name: []const u8, name: [:0]const u8,
kind: enum { boolean, arg }, kind: enum { boolean, arg },
}; };
@ -37,7 +37,7 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {
pub const Flags = flags_type: { pub const Flags = flags_type: {
var fields: []const std.builtin.Type.StructField = &.{}; var fields: []const std.builtin.Type.StructField = &.{};
inline for (flags) |flag| { for (flags) |flag| {
const field: std.builtin.Type.StructField = switch (flag.kind) { const field: std.builtin.Type.StructField = switch (flag.kind) {
.boolean => .{ .boolean => .{
.name = flag.name, .name = flag.name,
@ -57,7 +57,7 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {
fields = fields ++ [_]std.builtin.Type.StructField{field}; fields = fields ++ [_]std.builtin.Type.StructField{field};
} }
break :flags_type @Type(.{ .Struct = .{ break :flags_type @Type(.{ .Struct = .{
.layout = .Auto, .layout = .auto,
.fields = fields, .fields = fields,
.decls = &.{}, .decls = &.{},
.is_tuple = false, .is_tuple = false,

2
deps/zig-wayland vendored

@ -1 +1 @@
Subproject commit 73fed093301b2e5f58998aa4797ce952bd148676 Subproject commit 6be3eb9bff878bbf3f83a7c6862f1e14233606f5

2
deps/zig-wlroots vendored

@ -1 +1 @@
Subproject commit 5bc01a9f597e051c0dfab6dd9991f08697794e3d Subproject commit 941859cd842b68cc5d20757e8708eb70295e9344

2
deps/zig-xkbcommon vendored

@ -1 +1 @@
Subproject commit 7e09b389373b060148c0ca050e0b525e118d91e7 Subproject commit 3a2eefdad6b4d48757274061dd2b5df3b89a2bfd

2
river/Control.zig
View File

@ -48,7 +48,7 @@ pub fn init(control: *Control) !void {
} }
fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void { fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void {
const control = @fieldParentPtr(Control, "server_destroy", listener); const control: *Control = @fieldParentPtr("server_destroy", listener);
control.global.destroy(); control.global.destroy();
control.args_map.deinit(); control.args_map.deinit();
} }

48
river/Cursor.zig
View File

@ -19,7 +19,7 @@ const Cursor = @This();
const build_options = @import("build_options"); const build_options = @import("build_options");
const std = @import("std"); const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const os = std.os; const posix = std.posix;
const math = std.math; const math = std.math;
const wlr = @import("wlroots"); const wlr = @import("wlroots");
const wayland = @import("wayland"); const wayland = @import("wayland");
@ -303,7 +303,7 @@ fn clearFocus(cursor: *Cursor) void {
/// Axis event is a scroll wheel or similiar /// Axis event is a scroll wheel or similiar
fn handleAxis(listener: *wl.Listener(*wlr.Pointer.event.Axis), event: *wlr.Pointer.event.Axis) void { fn handleAxis(listener: *wl.Listener(*wlr.Pointer.event.Axis), event: *wlr.Pointer.event.Axis) void {
const cursor = @fieldParentPtr(Cursor, "axis", listener); const cursor: *Cursor = @fieldParentPtr("axis", listener);
const device: *InputDevice = @ptrFromInt(event.device.data); const device: *InputDevice = @ptrFromInt(event.device.data);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -328,7 +328,7 @@ fn handleAxis(listener: *wl.Listener(*wlr.Pointer.event.Axis), event: *wlr.Point
} }
fn handleButton(listener: *wl.Listener(*wlr.Pointer.event.Button), event: *wlr.Pointer.event.Button) void { fn handleButton(listener: *wl.Listener(*wlr.Pointer.event.Button), event: *wlr.Pointer.event.Button) void {
const cursor = @fieldParentPtr(Cursor, "button", listener); const cursor: *Cursor = @fieldParentPtr("button", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
cursor.unhide(); cursor.unhide();
@ -432,7 +432,7 @@ fn handlePinchBegin(
listener: *wl.Listener(*wlr.Pointer.event.PinchBegin), listener: *wl.Listener(*wlr.Pointer.event.PinchBegin),
event: *wlr.Pointer.event.PinchBegin, event: *wlr.Pointer.event.PinchBegin,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "pinch_begin", listener); const cursor: *Cursor = @fieldParentPtr("pinch_begin", listener);
server.input_manager.pointer_gestures.sendPinchBegin( server.input_manager.pointer_gestures.sendPinchBegin(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -444,7 +444,7 @@ fn handlePinchUpdate(
listener: *wl.Listener(*wlr.Pointer.event.PinchUpdate), listener: *wl.Listener(*wlr.Pointer.event.PinchUpdate),
event: *wlr.Pointer.event.PinchUpdate, event: *wlr.Pointer.event.PinchUpdate,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "pinch_update", listener); const cursor: *Cursor = @fieldParentPtr("pinch_update", listener);
server.input_manager.pointer_gestures.sendPinchUpdate( server.input_manager.pointer_gestures.sendPinchUpdate(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -459,7 +459,7 @@ fn handlePinchEnd(
listener: *wl.Listener(*wlr.Pointer.event.PinchEnd), listener: *wl.Listener(*wlr.Pointer.event.PinchEnd),
event: *wlr.Pointer.event.PinchEnd, event: *wlr.Pointer.event.PinchEnd,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "pinch_end", listener); const cursor: *Cursor = @fieldParentPtr("pinch_end", listener);
server.input_manager.pointer_gestures.sendPinchEnd( server.input_manager.pointer_gestures.sendPinchEnd(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -471,7 +471,7 @@ fn handleSwipeBegin(
listener: *wl.Listener(*wlr.Pointer.event.SwipeBegin), listener: *wl.Listener(*wlr.Pointer.event.SwipeBegin),
event: *wlr.Pointer.event.SwipeBegin, event: *wlr.Pointer.event.SwipeBegin,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "swipe_begin", listener); const cursor: *Cursor = @fieldParentPtr("swipe_begin", listener);
server.input_manager.pointer_gestures.sendSwipeBegin( server.input_manager.pointer_gestures.sendSwipeBegin(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -483,7 +483,7 @@ fn handleSwipeUpdate(
listener: *wl.Listener(*wlr.Pointer.event.SwipeUpdate), listener: *wl.Listener(*wlr.Pointer.event.SwipeUpdate),
event: *wlr.Pointer.event.SwipeUpdate, event: *wlr.Pointer.event.SwipeUpdate,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "swipe_update", listener); const cursor: *Cursor = @fieldParentPtr("swipe_update", listener);
server.input_manager.pointer_gestures.sendSwipeUpdate( server.input_manager.pointer_gestures.sendSwipeUpdate(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -496,7 +496,7 @@ fn handleSwipeEnd(
listener: *wl.Listener(*wlr.Pointer.event.SwipeEnd), listener: *wl.Listener(*wlr.Pointer.event.SwipeEnd),
event: *wlr.Pointer.event.SwipeEnd, event: *wlr.Pointer.event.SwipeEnd,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "swipe_end", listener); const cursor: *Cursor = @fieldParentPtr("swipe_end", listener);
server.input_manager.pointer_gestures.sendSwipeEnd( server.input_manager.pointer_gestures.sendSwipeEnd(
cursor.seat.wlr_seat, cursor.seat.wlr_seat,
event.time_msec, event.time_msec,
@ -508,7 +508,7 @@ fn handleTouchDown(
listener: *wl.Listener(*wlr.Touch.event.Down), listener: *wl.Listener(*wlr.Touch.event.Down),
event: *wlr.Touch.event.Down, event: *wlr.Touch.event.Down,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "touch_down", listener); const cursor: *Cursor = @fieldParentPtr("touch_down", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -544,7 +544,7 @@ fn handleTouchMotion(
listener: *wl.Listener(*wlr.Touch.event.Motion), listener: *wl.Listener(*wlr.Touch.event.Motion),
event: *wlr.Touch.event.Motion, event: *wlr.Touch.event.Motion,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "touch_motion", listener); const cursor: *Cursor = @fieldParentPtr("touch_motion", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -563,7 +563,7 @@ fn handleTouchUp(
listener: *wl.Listener(*wlr.Touch.event.Up), listener: *wl.Listener(*wlr.Touch.event.Up),
event: *wlr.Touch.event.Up, event: *wlr.Touch.event.Up,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "touch_up", listener); const cursor: *Cursor = @fieldParentPtr("touch_up", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -576,7 +576,7 @@ fn handleTouchCancel(
listener: *wl.Listener(*wlr.Touch.event.Cancel), listener: *wl.Listener(*wlr.Touch.event.Cancel),
_: *wlr.Touch.event.Cancel, _: *wlr.Touch.event.Cancel,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "touch_cancel", listener); const cursor: *Cursor = @fieldParentPtr("touch_cancel", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -612,7 +612,7 @@ fn handleTouchCancel(
} }
fn handleTouchFrame(listener: *wl.Listener(void)) void { fn handleTouchFrame(listener: *wl.Listener(void)) void {
const cursor = @fieldParentPtr(Cursor, "touch_frame", listener); const cursor: *Cursor = @fieldParentPtr("touch_frame", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -624,7 +624,7 @@ fn handleTabletToolAxis(
event: *wlr.Tablet.event.Axis, event: *wlr.Tablet.event.Axis,
) void { ) void {
const device: *InputDevice = @ptrFromInt(event.device.data); const device: *InputDevice = @ptrFromInt(event.device.data);
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
device.seat.handleActivity(); device.seat.handleActivity();
@ -638,7 +638,7 @@ fn handleTabletToolProximity(
event: *wlr.Tablet.event.Proximity, event: *wlr.Tablet.event.Proximity,
) void { ) void {
const device: *InputDevice = @ptrFromInt(event.device.data); const device: *InputDevice = @ptrFromInt(event.device.data);
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
device.seat.handleActivity(); device.seat.handleActivity();
@ -652,7 +652,7 @@ fn handleTabletToolTip(
event: *wlr.Tablet.event.Tip, event: *wlr.Tablet.event.Tip,
) void { ) void {
const device: *InputDevice = @ptrFromInt(event.device.data); const device: *InputDevice = @ptrFromInt(event.device.data);
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
device.seat.handleActivity(); device.seat.handleActivity();
@ -666,7 +666,7 @@ fn handleTabletToolButton(
event: *wlr.Tablet.event.Button, event: *wlr.Tablet.event.Button,
) void { ) void {
const device: *InputDevice = @ptrFromInt(event.device.data); const device: *InputDevice = @ptrFromInt(event.device.data);
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
device.seat.handleActivity(); device.seat.handleActivity();
@ -706,7 +706,7 @@ fn handlePointerMapping(cursor: *Cursor, event: *wlr.Pointer.event.Button, view:
/// events together. For instance, two axis events may happen at the same /// events together. For instance, two axis events may happen at the same
/// time, in which case a frame event won't be sent in between. /// time, in which case a frame event won't be sent in between.
fn handleFrame(listener: *wl.Listener(*wlr.Cursor), _: *wlr.Cursor) void { fn handleFrame(listener: *wl.Listener(*wlr.Cursor), _: *wlr.Cursor) void {
const cursor = @fieldParentPtr(Cursor, "frame", listener); const cursor: *Cursor = @fieldParentPtr("frame", listener);
cursor.seat.wlr_seat.pointerNotifyFrame(); cursor.seat.wlr_seat.pointerNotifyFrame();
} }
@ -720,7 +720,7 @@ fn handleMotionAbsolute(
listener: *wl.Listener(*wlr.Pointer.event.MotionAbsolute), listener: *wl.Listener(*wlr.Pointer.event.MotionAbsolute),
event: *wlr.Pointer.event.MotionAbsolute, event: *wlr.Pointer.event.MotionAbsolute,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "motion_absolute", listener); const cursor: *Cursor = @fieldParentPtr("motion_absolute", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -739,7 +739,7 @@ fn handleMotion(
listener: *wl.Listener(*wlr.Pointer.event.Motion), listener: *wl.Listener(*wlr.Pointer.event.Motion),
event: *wlr.Pointer.event.Motion, event: *wlr.Pointer.event.Motion,
) void { ) void {
const cursor = @fieldParentPtr(Cursor, "motion", listener); const cursor: *Cursor = @fieldParentPtr("motion", listener);
cursor.seat.handleActivity(); cursor.seat.handleActivity();
@ -751,7 +751,7 @@ fn handleRequestSetCursor(
event: *wlr.Seat.event.RequestSetCursor, event: *wlr.Seat.event.RequestSetCursor,
) void { ) void {
// This event is rasied by the seat when a client provides a cursor image // This event is rasied by the seat when a client provides a cursor image
const cursor = @fieldParentPtr(Cursor, "request_set_cursor", listener); const cursor: *Cursor = @fieldParentPtr("request_set_cursor", listener);
const focused_client = cursor.seat.wlr_seat.pointer_state.focused_client; const focused_client = cursor.seat.wlr_seat.pointer_state.focused_client;
// This can be sent by any client, so we check to make sure this one is // This can be sent by any client, so we check to make sure this one is
@ -1111,8 +1111,8 @@ pub fn updateState(cursor: *Cursor) void {
.passthrough => { .passthrough => {
cursor.updateFocusFollowsCursorTarget(); cursor.updateFocusFollowsCursorTarget();
if (!cursor.hidden) { if (!cursor.hidden) {
var now: os.timespec = undefined; var now: posix.timespec = undefined;
os.clock_gettime(os.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported"); posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
const msec: u32 = @intCast(now.tv_sec * std.time.ms_per_s + const msec: u32 = @intCast(now.tv_sec * std.time.ms_per_s +
@divTrunc(now.tv_nsec, std.time.ns_per_ms)); @divTrunc(now.tv_nsec, std.time.ns_per_ms));
cursor.passthrough(msec); cursor.passthrough(msec);

2
river/DragIcon.zig
View File

@ -71,7 +71,7 @@ pub fn updatePosition(drag_icon: *DragIcon, cursor: *Cursor) void {
} }
fn handleDestroy(listener: *wl.Listener(*wlr.Drag.Icon), _: *wlr.Drag.Icon) void { fn handleDestroy(listener: *wl.Listener(*wlr.Drag.Icon), _: *wlr.Drag.Icon) void {
const drag_icon = @fieldParentPtr(DragIcon, "destroy", listener); const drag_icon: *DragIcon = @fieldParentPtr("destroy", listener);
drag_icon.destroy.link.remove(); drag_icon.destroy.link.remove();

16
river/ForeignToplevelHandle.zig
View File

@ -36,7 +36,7 @@ foreign_close: wl.Listener(*wlr.ForeignToplevelHandleV1) =
wl.Listener(*wlr.ForeignToplevelHandleV1).init(handleForeignClose), wl.Listener(*wlr.ForeignToplevelHandleV1).init(handleForeignClose),
pub fn map(handle: *ForeignToplevelHandle) void { pub fn map(handle: *ForeignToplevelHandle) void {
const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle); const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
assert(handle.wlr_handle == null); assert(handle.wlr_handle == null);
@ -67,7 +67,7 @@ pub fn unmap(handle: *ForeignToplevelHandle) void {
/// Must be called just before the view's inflight state is made current. /// Must be called just before the view's inflight state is made current.
pub fn update(handle: *ForeignToplevelHandle) void { pub fn update(handle: *ForeignToplevelHandle) void {
const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle); const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
const wlr_handle = handle.wlr_handle orelse return; const wlr_handle = handle.wlr_handle orelse return;
@ -87,8 +87,8 @@ fn handleForeignActivate(
listener: *wl.Listener(*wlr.ForeignToplevelHandleV1.event.Activated), listener: *wl.Listener(*wlr.ForeignToplevelHandleV1.event.Activated),
event: *wlr.ForeignToplevelHandleV1.event.Activated, event: *wlr.ForeignToplevelHandleV1.event.Activated,
) void { ) void {
const handle = @fieldParentPtr(ForeignToplevelHandle, "foreign_activate", listener); const handle: *ForeignToplevelHandle = @fieldParentPtr("foreign_activate", listener);
const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle); const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
const seat: *Seat = @ptrFromInt(event.seat.data); const seat: *Seat = @ptrFromInt(event.seat.data);
seat.focus(view); seat.focus(view);
@ -99,8 +99,8 @@ fn handleForeignFullscreen(
listener: *wl.Listener(*wlr.ForeignToplevelHandleV1.event.Fullscreen), listener: *wl.Listener(*wlr.ForeignToplevelHandleV1.event.Fullscreen),
event: *wlr.ForeignToplevelHandleV1.event.Fullscreen, event: *wlr.ForeignToplevelHandleV1.event.Fullscreen,
) void { ) void {
const handle = @fieldParentPtr(ForeignToplevelHandle, "foreign_fullscreen", listener); const handle: *ForeignToplevelHandle = @fieldParentPtr("foreign_fullscreen", listener);
const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle); const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
view.pending.fullscreen = event.fullscreen; view.pending.fullscreen = event.fullscreen;
server.root.applyPending(); server.root.applyPending();
@ -110,8 +110,8 @@ fn handleForeignClose(
listener: *wl.Listener(*wlr.ForeignToplevelHandleV1), listener: *wl.Listener(*wlr.ForeignToplevelHandleV1),
_: *wlr.ForeignToplevelHandleV1, _: *wlr.ForeignToplevelHandleV1,
) void { ) void {
const handle = @fieldParentPtr(ForeignToplevelHandle, "foreign_close", listener); const handle: *ForeignToplevelHandle = @fieldParentPtr("foreign_close", listener);
const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle); const view: *View = @fieldParentPtr("foreign_toplevel_handle", handle);
view.close(); view.close();
} }

2
river/IdleInhibitManager.zig
View File

@ -78,7 +78,7 @@ pub fn checkActive(inhibit_manager: *IdleInhibitManager) void {
} }
fn handleNewIdleInhibitor(listener: *wl.Listener(*wlr.IdleInhibitorV1), inhibitor: *wlr.IdleInhibitorV1) void { fn handleNewIdleInhibitor(listener: *wl.Listener(*wlr.IdleInhibitorV1), inhibitor: *wlr.IdleInhibitorV1) void {
const inhibit_manager = @fieldParentPtr(IdleInhibitManager, "new_idle_inhibitor", listener); const inhibit_manager: *IdleInhibitManager = @fieldParentPtr("new_idle_inhibitor", listener);
const inhibitor_node = util.gpa.create(std.TailQueue(IdleInhibitor).Node) catch return; const inhibitor_node = util.gpa.create(std.TailQueue(IdleInhibitor).Node) catch return;
inhibitor_node.data.init(inhibitor, inhibit_manager) catch { inhibitor_node.data.init(inhibitor, inhibit_manager) catch {
util.gpa.destroy(inhibitor_node); util.gpa.destroy(inhibitor_node);

4
river/IdleInhibitor.zig
View File

@ -45,11 +45,11 @@ pub fn init(
} }
fn handleDestroy(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void { fn handleDestroy(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
const inhibitor = @fieldParentPtr(IdleInhibitor, "destroy", listener); const inhibitor: *IdleInhibitor = @fieldParentPtr("destroy", listener);
inhibitor.destroy.link.remove(); inhibitor.destroy.link.remove();
const node = @fieldParentPtr(std.TailQueue(IdleInhibitor).Node, "data", inhibitor); const node: *std.TailQueue(IdleInhibitor).Node = @fieldParentPtr("data", inhibitor);
server.idle_inhibit_manager.inhibitors.remove(node); server.idle_inhibit_manager.inhibitors.remove(node);
inhibitor.inhibit_manager.checkActive(); inhibitor.inhibit_manager.checkActive();

2
river/InputConfig.zig
View File

@ -241,7 +241,7 @@ pub const MapToOutput = struct {
device.seat.cursor.wlr_cursor.mapInputToOutput(device.wlr_device, wlr_output); device.seat.cursor.wlr_cursor.mapInputToOutput(device.wlr_device, wlr_output);
if (device.wlr_device.type == .tablet_tool) { if (device.wlr_device.type == .tablet_tool) {
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
tablet.output_mapping = wlr_output; tablet.output_mapping = wlr_output;
} }
}, },

8
river/InputDevice.zig
View File

@ -125,13 +125,13 @@ fn isKeyboardGroup(wlr_device: *wlr.InputDevice) bool {
} }
fn handleDestroy(listener: *wl.Listener(*wlr.InputDevice), _: *wlr.InputDevice) void { fn handleDestroy(listener: *wl.Listener(*wlr.InputDevice), _: *wlr.InputDevice) void {
const device = @fieldParentPtr(InputDevice, "destroy", listener); const device: *InputDevice = @fieldParentPtr("destroy", listener);
log.debug("removed input device: {s}", .{device.identifier}); log.debug("removed input device: {s}", .{device.identifier});
switch (device.wlr_device.type) { switch (device.wlr_device.type) {
.keyboard => { .keyboard => {
const keyboard = @fieldParentPtr(Keyboard, "device", device); const keyboard: *Keyboard = @fieldParentPtr("device", device);
keyboard.deinit(); keyboard.deinit();
util.gpa.destroy(keyboard); util.gpa.destroy(keyboard);
}, },
@ -140,11 +140,11 @@ fn handleDestroy(listener: *wl.Listener(*wlr.InputDevice), _: *wlr.InputDevice)
util.gpa.destroy(device); util.gpa.destroy(device);
}, },
.tablet_tool => { .tablet_tool => {
const tablet = @fieldParentPtr(Tablet, "device", device); const tablet: *Tablet = @fieldParentPtr("device", device);
tablet.destroy(); tablet.destroy();
}, },
.switch_device => { .switch_device => {
const switch_device = @fieldParentPtr(Switch, "device", device); const switch_device: *Switch = @fieldParentPtr("device", device);
switch_device.deinit(); switch_device.deinit();
util.gpa.destroy(switch_device); util.gpa.destroy(switch_device);
}, },

4
river/InputManager.zig
View File

@ -158,7 +158,7 @@ pub fn reconfigureDevices(input_manager: *InputManager) void {
} }
fn handleNewInput(listener: *wl.Listener(*wlr.InputDevice), wlr_device: *wlr.InputDevice) void { fn handleNewInput(listener: *wl.Listener(*wlr.InputDevice), wlr_device: *wlr.InputDevice) void {
const input_manager = @fieldParentPtr(InputManager, "new_input", listener); const input_manager: *InputManager = @fieldParentPtr("new_input", listener);
input_manager.defaultSeat().addDevice(wlr_device); input_manager.defaultSeat().addDevice(wlr_device);
} }
@ -167,7 +167,7 @@ fn handleNewVirtualPointer(
listener: *wl.Listener(*wlr.VirtualPointerManagerV1.event.NewPointer), listener: *wl.Listener(*wlr.VirtualPointerManagerV1.event.NewPointer),
event: *wlr.VirtualPointerManagerV1.event.NewPointer, event: *wlr.VirtualPointerManagerV1.event.NewPointer,
) void { ) void {
const input_manager = @fieldParentPtr(InputManager, "new_virtual_pointer", listener); const input_manager: *InputManager = @fieldParentPtr("new_virtual_pointer", listener);
// TODO Support multiple seats and don't ignore // TODO Support multiple seats and don't ignore
if (event.suggested_seat != null) { if (event.suggested_seat != null) {

8
river/InputPopup.zig
View File

@ -61,7 +61,7 @@ pub fn create(wlr_popup: *wlr.InputPopupSurfaceV2, input_relay: *InputRelay) !vo
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const input_popup = @fieldParentPtr(InputPopup, "destroy", listener); const input_popup: *InputPopup = @fieldParentPtr("destroy", listener);
input_popup.destroy.link.remove(); input_popup.destroy.link.remove();
input_popup.map.link.remove(); input_popup.map.link.remove();
@ -74,19 +74,19 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
} }
fn handleMap(listener: *wl.Listener(void)) void { fn handleMap(listener: *wl.Listener(void)) void {
const input_popup = @fieldParentPtr(InputPopup, "map", listener); const input_popup: *InputPopup = @fieldParentPtr("map", listener);
input_popup.update(); input_popup.update();
} }
fn handleUnmap(listener: *wl.Listener(void)) void { fn handleUnmap(listener: *wl.Listener(void)) void {
const input_popup = @fieldParentPtr(InputPopup, "unmap", listener); const input_popup: *InputPopup = @fieldParentPtr("unmap", listener);
input_popup.surface_tree.node.reparent(server.root.hidden.tree); input_popup.surface_tree.node.reparent(server.root.hidden.tree);
} }
fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void { fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
const input_popup = @fieldParentPtr(InputPopup, "commit", listener); const input_popup: *InputPopup = @fieldParentPtr("commit", listener);
input_popup.update(); input_popup.update();
} }

14
river/InputRelay.zig
View File

@ -66,7 +66,7 @@ pub fn init(relay: *InputRelay) void {
} }
pub fn newInputMethod(relay: *InputRelay, input_method: *wlr.InputMethodV2) void { pub fn newInputMethod(relay: *InputRelay, input_method: *wlr.InputMethodV2) void {
const seat = @fieldParentPtr(Seat, "relay", relay); const seat: *Seat = @fieldParentPtr("relay", relay);
log.debug("new input method on seat {s}", .{seat.wlr_seat.name}); log.debug("new input method on seat {s}", .{seat.wlr_seat.name});
@ -93,7 +93,7 @@ fn handleInputMethodCommit(
listener: *wl.Listener(*wlr.InputMethodV2), listener: *wl.Listener(*wlr.InputMethodV2),
input_method: *wlr.InputMethodV2, input_method: *wlr.InputMethodV2,
) void { ) void {
const relay = @fieldParentPtr(InputRelay, "input_method_commit", listener); const relay: *InputRelay = @fieldParentPtr("input_method_commit", listener);
assert(input_method == relay.input_method); assert(input_method == relay.input_method);
if (!input_method.client_active) return; if (!input_method.client_active) return;
@ -127,7 +127,7 @@ fn handleInputMethodDestroy(
listener: *wl.Listener(*wlr.InputMethodV2), listener: *wl.Listener(*wlr.InputMethodV2),
input_method: *wlr.InputMethodV2, input_method: *wlr.InputMethodV2,
) void { ) void {
const relay = @fieldParentPtr(InputRelay, "input_method_destroy", listener); const relay: *InputRelay = @fieldParentPtr("input_method_destroy", listener);
assert(input_method == relay.input_method); assert(input_method == relay.input_method);
relay.input_method_commit.link.remove(); relay.input_method_commit.link.remove();
@ -145,8 +145,8 @@ fn handleInputMethodGrabKeyboard(
listener: *wl.Listener(*wlr.InputMethodV2.KeyboardGrab), listener: *wl.Listener(*wlr.InputMethodV2.KeyboardGrab),
keyboard_grab: *wlr.InputMethodV2.KeyboardGrab, keyboard_grab: *wlr.InputMethodV2.KeyboardGrab,
) void { ) void {
const relay = @fieldParentPtr(InputRelay, "grab_keyboard", listener); const relay: *InputRelay = @fieldParentPtr("grab_keyboard", listener);
const seat = @fieldParentPtr(Seat, "relay", relay); const seat: *Seat = @fieldParentPtr("relay", relay);
const active_keyboard = seat.wlr_seat.getKeyboard(); const active_keyboard = seat.wlr_seat.getKeyboard();
keyboard_grab.setKeyboard(active_keyboard); keyboard_grab.setKeyboard(active_keyboard);
@ -158,7 +158,7 @@ fn handleInputMethodNewPopup(
listener: *wl.Listener(*wlr.InputPopupSurfaceV2), listener: *wl.Listener(*wlr.InputPopupSurfaceV2),
wlr_popup: *wlr.InputPopupSurfaceV2, wlr_popup: *wlr.InputPopupSurfaceV2,
) void { ) void {
const relay = @fieldParentPtr(InputRelay, "input_method_new_popup", listener); const relay: *InputRelay = @fieldParentPtr("input_method_new_popup", listener);
InputPopup.create(wlr_popup, relay) catch { InputPopup.create(wlr_popup, relay) catch {
log.err("out of memory", .{}); log.err("out of memory", .{});
@ -170,7 +170,7 @@ fn handleInputMethodGrabKeyboardDestroy(
listener: *wl.Listener(*wlr.InputMethodV2.KeyboardGrab), listener: *wl.Listener(*wlr.InputMethodV2.KeyboardGrab),
keyboard_grab: *wlr.InputMethodV2.KeyboardGrab, keyboard_grab: *wlr.InputMethodV2.KeyboardGrab,
) void { ) void {
const relay = @fieldParentPtr(InputRelay, "grab_keyboard_destroy", listener); const relay: *InputRelay = @fieldParentPtr("grab_keyboard_destroy", listener);
relay.grab_keyboard_destroy.link.remove(); relay.grab_keyboard_destroy.link.remove();
if (keyboard_grab.keyboard) |keyboard| { if (keyboard_grab.keyboard) |keyboard| {

4
river/Keyboard.zig
View File

@ -146,7 +146,7 @@ pub fn deinit(keyboard: *Keyboard) void {
fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboard.event.Key) void { fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboard.event.Key) void {
// This event is raised when a key is pressed or released. // This event is raised when a key is pressed or released.
const keyboard = @fieldParentPtr(Keyboard, "key", listener); const keyboard: *Keyboard = @fieldParentPtr("key", listener);
const wlr_keyboard = keyboard.device.wlr_device.toKeyboard(); const wlr_keyboard = keyboard.device.wlr_device.toKeyboard();
// If the keyboard is in a group, this event will be handled by the group's Keyboard instance. // If the keyboard is in a group, this event will be handled by the group's Keyboard instance.
@ -247,7 +247,7 @@ fn isModifier(keysym: xkb.Keysym) bool {
} }
fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void { fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void {
const keyboard = @fieldParentPtr(Keyboard, "modifiers", listener); const keyboard: *Keyboard = @fieldParentPtr("modifiers", listener);
const wlr_keyboard = keyboard.device.wlr_device.toKeyboard(); const wlr_keyboard = keyboard.device.wlr_device.toKeyboard();
// If the keyboard is in a group, this event will be handled by the group's Keyboard instance. // If the keyboard is in a group, this event will be handled by the group's Keyboard instance.

2
river/KeyboardGroup.zig
View File

@ -72,7 +72,7 @@ pub fn destroy(group: *KeyboardGroup) void {
group.wlr_group.destroy(); group.wlr_group.destroy();
const node = @fieldParentPtr(std.TailQueue(KeyboardGroup).Node, "data", group); const node: *std.TailQueue(KeyboardGroup).Node = @fieldParentPtr("data", group);
group.seat.keyboard_groups.remove(node); group.seat.keyboard_groups.remove(node);
util.gpa.destroy(node); util.gpa.destroy(node);
} }

10
river/LayerSurface.zig
View File

@ -80,7 +80,7 @@ pub fn destroyPopups(layer_surface: *LayerSurface) void {
} }
fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfaceV1) void { fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfaceV1) void {
const layer_surface = @fieldParentPtr(LayerSurface, "destroy", listener); const layer_surface: *LayerSurface = @fieldParentPtr("destroy", listener);
log.debug("layer surface '{s}' destroyed", .{layer_surface.wlr_layer_surface.namespace}); log.debug("layer surface '{s}' destroyed", .{layer_surface.wlr_layer_surface.namespace});
@ -97,7 +97,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfa
} }
fn handleMap(listener: *wl.Listener(void)) void { fn handleMap(listener: *wl.Listener(void)) void {
const layer_surface = @fieldParentPtr(LayerSurface, "map", listener); const layer_surface: *LayerSurface = @fieldParentPtr("map", listener);
log.debug("layer surface '{s}' mapped", .{layer_surface.wlr_layer_surface.namespace}); log.debug("layer surface '{s}' mapped", .{layer_surface.wlr_layer_surface.namespace});
@ -107,7 +107,7 @@ fn handleMap(listener: *wl.Listener(void)) void {
} }
fn handleUnmap(listener: *wl.Listener(void)) void { fn handleUnmap(listener: *wl.Listener(void)) void {
const layer_surface = @fieldParentPtr(LayerSurface, "unmap", listener); const layer_surface: *LayerSurface = @fieldParentPtr("unmap", listener);
log.debug("layer surface '{s}' unmapped", .{layer_surface.wlr_layer_surface.namespace}); log.debug("layer surface '{s}' unmapped", .{layer_surface.wlr_layer_surface.namespace});
@ -117,7 +117,7 @@ fn handleUnmap(listener: *wl.Listener(void)) void {
} }
fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void { fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
const layer_surface = @fieldParentPtr(LayerSurface, "commit", listener); const layer_surface: *LayerSurface = @fieldParentPtr("commit", listener);
const wlr_layer_surface = layer_surface.wlr_layer_surface; const wlr_layer_surface = layer_surface.wlr_layer_surface;
assert(wlr_layer_surface.output != null); assert(wlr_layer_surface.output != null);
@ -186,7 +186,7 @@ fn handleKeyboardInteractiveExclusive(output: *Output) void {
} }
fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void { fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void {
const layer_surface = @fieldParentPtr(LayerSurface, "new_popup", listener); const layer_surface: *LayerSurface = @fieldParentPtr("new_popup", listener);
XdgPopup.create( XdgPopup.create(
wlr_xdg_popup, wlr_xdg_popup,

2
river/Layout.zig
View File

@ -186,7 +186,7 @@ pub fn destroy(layout: *Layout) void {
); );
// Remove layout from the list // Remove layout from the list
const node = @fieldParentPtr(std.TailQueue(Layout).Node, "data", layout); const node: *std.TailQueue(Layout).Node = @fieldParentPtr("data", layout);
layout.output.layouts.remove(node); layout.output.layouts.remove(node);
// If we are the currently active layout of an output, clean up. // If we are the currently active layout of an output, clean up.

2
river/LayoutManager.zig
View File

@ -44,7 +44,7 @@ pub fn init(layout_manager: *LayoutManager) !void {
} }
fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void { fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void {
const layout_manager = @fieldParentPtr(LayoutManager, "server_destroy", listener); const layout_manager: *LayoutManager = @fieldParentPtr("server_destroy", listener);
layout_manager.global.destroy(); layout_manager.global.destroy();
} }

8
river/LockManager.zig
View File

@ -85,7 +85,7 @@ pub fn deinit(manager: *LockManager) void {
} }
fn handleLock(listener: *wl.Listener(*wlr.SessionLockV1), lock: *wlr.SessionLockV1) void { fn handleLock(listener: *wl.Listener(*wlr.SessionLockV1), lock: *wlr.SessionLockV1) void {
const manager = @fieldParentPtr(LockManager, "new_lock", listener); const manager: *LockManager = @fieldParentPtr("new_lock", listener);
if (manager.lock != null) { if (manager.lock != null) {
log.info("denying new session lock client, an active one already exists", .{}); log.info("denying new session lock client, an active one already exists", .{});
@ -191,7 +191,7 @@ pub fn maybeLock(manager: *LockManager) void {
} }
fn handleUnlock(listener: *wl.Listener(void)) void { fn handleUnlock(listener: *wl.Listener(void)) void {
const manager = @fieldParentPtr(LockManager, "unlock", listener); const manager: *LockManager = @fieldParentPtr("unlock", listener);
manager.state = .unlocked; manager.state = .unlocked;
@ -229,7 +229,7 @@ fn handleUnlock(listener: *wl.Listener(void)) void {
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const manager = @fieldParentPtr(LockManager, "destroy", listener); const manager: *LockManager = @fieldParentPtr("destroy", listener);
log.debug("ext_session_lock_v1 destroyed", .{}); log.debug("ext_session_lock_v1 destroyed", .{});
@ -248,7 +248,7 @@ fn handleSurface(
listener: *wl.Listener(*wlr.SessionLockSurfaceV1), listener: *wl.Listener(*wlr.SessionLockSurfaceV1),
wlr_lock_surface: *wlr.SessionLockSurfaceV1, wlr_lock_surface: *wlr.SessionLockSurfaceV1,
) void { ) void {
const manager = @fieldParentPtr(LockManager, "new_surface", listener); const manager: *LockManager = @fieldParentPtr("new_surface", listener);
log.debug("new ext_session_lock_surface_v1 created", .{}); log.debug("new ext_session_lock_surface_v1 created", .{});

4
river/LockSurface.zig
View File

@ -100,7 +100,7 @@ pub fn configure(lock_surface: *LockSurface) void {
} }
fn handleMap(listener: *wl.Listener(void)) void { fn handleMap(listener: *wl.Listener(void)) void {
const lock_surface = @fieldParentPtr(LockSurface, "map", listener); const lock_surface: *LockSurface = @fieldParentPtr("map", listener);
const output = lock_surface.getOutput(); const output = lock_surface.getOutput();
output.normal_content.node.setEnabled(false); output.normal_content.node.setEnabled(false);
@ -132,7 +132,7 @@ fn updateFocus(lock_surface: *LockSurface) void {
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const lock_surface = @fieldParentPtr(LockSurface, "surface_destroy", listener); const lock_surface: *LockSurface = @fieldParentPtr("surface_destroy", listener);
lock_surface.destroy(); lock_surface.destroy();
} }

15
river/Output.zig
View File

@ -20,6 +20,7 @@ const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const math = std.math; const math = std.math;
const mem = std.mem; const mem = std.mem;
const posix = std.posix;
const fmt = std.fmt; const fmt = std.fmt;
const wlr = @import("wlroots"); const wlr = @import("wlroots");
const wayland = @import("wayland"); const wayland = @import("wayland");
@ -401,7 +402,7 @@ fn sendLayerConfigures(
} }
fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void { fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
const output = @fieldParentPtr(Output, "destroy", listener); const output: *Output = @fieldParentPtr("destroy", listener);
log.debug("output '{s}' destroyed", .{output.wlr_output.name}); log.debug("output '{s}' destroyed", .{output.wlr_output.name});
@ -436,7 +437,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
} }
fn handleRequestState(listener: *wl.Listener(*wlr.Output.event.RequestState), event: *wlr.Output.event.RequestState) void { fn handleRequestState(listener: *wl.Listener(*wlr.Output.event.RequestState), event: *wlr.Output.event.RequestState) void {
const output = @fieldParentPtr(Output, "request_state", listener); const output: *Output = @fieldParentPtr("request_state", listener);
output.applyState(event.state) catch { output.applyState(event.state) catch {
log.err("failed to commit requested state", .{}); log.err("failed to commit requested state", .{});
@ -514,12 +515,12 @@ pub fn updateBackgroundRect(output: *Output) void {
output.layers.background_color_rect.setSize(width, height); output.layers.background_color_rect.setSize(width, height);
var it = output.layers.fullscreen.children.iterator(.forward); var it = output.layers.fullscreen.children.iterator(.forward);
const fullscreen_background = @fieldParentPtr(wlr.SceneRect, "node", it.next().?); const fullscreen_background: *wlr.SceneRect = @fieldParentPtr("node", it.next().?);
fullscreen_background.setSize(width, height); fullscreen_background.setSize(width, height);
} }
fn handleFrame(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void { fn handleFrame(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
const output = @fieldParentPtr(Output, "frame", listener); const output: *Output = @fieldParentPtr("frame", listener);
const scene_output = server.root.scene.getSceneOutput(output.wlr_output).?; const scene_output = server.root.scene.getSceneOutput(output.wlr_output).?;
// TODO this should probably be retried on failure // TODO this should probably be retried on failure
@ -528,8 +529,8 @@ fn handleFrame(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
error.CommitFailed => log.err("output commit failed for {s}", .{output.wlr_output.name}), error.CommitFailed => log.err("output commit failed for {s}", .{output.wlr_output.name}),
}; };
var now: std.os.timespec = undefined; var now: posix.timespec = undefined;
std.os.clock_gettime(std.os.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported"); posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
scene_output.sendFrameDone(&now); scene_output.sendFrameDone(&now);
} }
@ -591,7 +592,7 @@ fn handlePresent(
listener: *wl.Listener(*wlr.Output.event.Present), listener: *wl.Listener(*wlr.Output.event.Present),
event: *wlr.Output.event.Present, event: *wlr.Output.event.Present,
) void { ) void {
const output = @fieldParentPtr(Output, "present", listener); const output: *Output = @fieldParentPtr("present", listener);
if (!event.presented) { if (!event.presented) {
return; return;

6
river/PointerConstraint.zig
View File

@ -182,14 +182,14 @@ fn warpToHintIfSet(constraint: *PointerConstraint) void {
} }
fn handleNodeDestroy(listener: *wl.Listener(void)) void { fn handleNodeDestroy(listener: *wl.Listener(void)) void {
const constraint = @fieldParentPtr(PointerConstraint, "node_destroy", listener); const constraint: *PointerConstraint = @fieldParentPtr("node_destroy", listener);
log.info("deactivating pointer constraint, scene node destroyed", .{}); log.info("deactivating pointer constraint, scene node destroyed", .{});
constraint.deactivate(); constraint.deactivate();
} }
fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.PointerConstraintV1) void { fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.PointerConstraintV1) void {
const constraint = @fieldParentPtr(PointerConstraint, "destroy", listener); const constraint: *PointerConstraint = @fieldParentPtr("destroy", listener);
const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data); const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
if (constraint.state == .active) { if (constraint.state == .active) {
@ -211,7 +211,7 @@ fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.Point
} }
fn handleSetRegion(listener: *wl.Listener(void)) void { fn handleSetRegion(listener: *wl.Listener(void)) void {
const constraint = @fieldParentPtr(PointerConstraint, "set_region", listener); const constraint: *PointerConstraint = @fieldParentPtr("set_region", listener);
const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data); const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);
switch (constraint.state) { switch (constraint.state) {

6
river/Root.zig
View File

@ -740,7 +740,7 @@ fn commitTransaction(root: *Root) void {
// We need this listener to deal with outputs that have their position auto-configured // We need this listener to deal with outputs that have their position auto-configured
// by the wlr_output_layout. // by the wlr_output_layout.
fn handleLayoutChange(listener: *wl.Listener(*wlr.OutputLayout), _: *wlr.OutputLayout) void { fn handleLayoutChange(listener: *wl.Listener(*wlr.OutputLayout), _: *wlr.OutputLayout) void {
const root = @fieldParentPtr(Root, "layout_change", listener); const root: *Root = @fieldParentPtr("layout_change", listener);
root.handleOutputConfigChange() catch std.log.err("out of memory", .{}); root.handleOutputConfigChange() catch std.log.err("out of memory", .{});
} }
@ -775,7 +775,7 @@ fn handleManagerApply(
listener: *wl.Listener(*wlr.OutputConfigurationV1), listener: *wl.Listener(*wlr.OutputConfigurationV1),
config: *wlr.OutputConfigurationV1, config: *wlr.OutputConfigurationV1,
) void { ) void {
const root = @fieldParentPtr(Root, "manager_apply", listener); const root: *Root = @fieldParentPtr("manager_apply", listener);
defer config.destroy(); defer config.destroy();
std.log.scoped(.output_manager).info("applying output configuration", .{}); std.log.scoped(.output_manager).info("applying output configuration", .{});
@ -789,7 +789,7 @@ fn handleManagerTest(
listener: *wl.Listener(*wlr.OutputConfigurationV1), listener: *wl.Listener(*wlr.OutputConfigurationV1),
config: *wlr.OutputConfigurationV1, config: *wlr.OutputConfigurationV1,
) void { ) void {
const root = @fieldParentPtr(Root, "manager_test", listener); const root: *Root = @fieldParentPtr("manager_test", listener);
defer config.destroy(); defer config.destroy();
root.processOutputConfig(config, .test_only); root.processOutputConfig(config, .test_only);

2
river/SceneNodeData.zig
View File

@ -73,7 +73,7 @@ pub fn fromSurface(surface: *wlr.Surface) ?*SceneNodeData {
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const scene_node_data = @fieldParentPtr(SceneNodeData, "destroy", listener); const scene_node_data: *SceneNodeData = @fieldParentPtr("destroy", listener);
scene_node_data.destroy.link.remove(); scene_node_data.destroy.link.remove();
scene_node_data.node.data = 0; scene_node_data.node.data = 0;

10
river/Seat.zig
View File

@ -540,7 +540,7 @@ fn handleRequestSetSelection(
listener: *wl.Listener(*wlr.Seat.event.RequestSetSelection), listener: *wl.Listener(*wlr.Seat.event.RequestSetSelection),
event: *wlr.Seat.event.RequestSetSelection, event: *wlr.Seat.event.RequestSetSelection,
) void { ) void {
const seat = @fieldParentPtr(Seat, "request_set_selection", listener); const seat: *Seat = @fieldParentPtr("request_set_selection", listener);
seat.wlr_seat.setSelection(event.source, event.serial); seat.wlr_seat.setSelection(event.source, event.serial);
} }
@ -548,7 +548,7 @@ fn handleRequestStartDrag(
listener: *wl.Listener(*wlr.Seat.event.RequestStartDrag), listener: *wl.Listener(*wlr.Seat.event.RequestStartDrag),
event: *wlr.Seat.event.RequestStartDrag, event: *wlr.Seat.event.RequestStartDrag,
) void { ) void {
const seat = @fieldParentPtr(Seat, "request_start_drag", listener); const seat: *Seat = @fieldParentPtr("request_start_drag", listener);
// The start_drag request is ignored by wlroots if a drag is currently in progress. // The start_drag request is ignored by wlroots if a drag is currently in progress.
assert(seat.drag == .none); assert(seat.drag == .none);
@ -572,7 +572,7 @@ fn handleRequestStartDrag(
} }
fn handleStartDrag(listener: *wl.Listener(*wlr.Drag), wlr_drag: *wlr.Drag) void { fn handleStartDrag(listener: *wl.Listener(*wlr.Drag), wlr_drag: *wlr.Drag) void {
const seat = @fieldParentPtr(Seat, "start_drag", listener); const seat: *Seat = @fieldParentPtr("start_drag", listener);
assert(seat.drag == .none); assert(seat.drag == .none);
switch (wlr_drag.grab_type) { switch (wlr_drag.grab_type) {
@ -595,7 +595,7 @@ fn handleStartDrag(listener: *wl.Listener(*wlr.Drag), wlr_drag: *wlr.Drag) void
} }
fn handleDragDestroy(listener: *wl.Listener(*wlr.Drag), _: *wlr.Drag) void { fn handleDragDestroy(listener: *wl.Listener(*wlr.Drag), _: *wlr.Drag) void {
const seat = @fieldParentPtr(Seat, "drag_destroy", listener); const seat: *Seat = @fieldParentPtr("drag_destroy", listener);
seat.drag_destroy.link.remove(); seat.drag_destroy.link.remove();
switch (seat.drag) { switch (seat.drag) {
@ -613,6 +613,6 @@ fn handleRequestSetPrimarySelection(
listener: *wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection), listener: *wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection),
event: *wlr.Seat.event.RequestSetPrimarySelection, event: *wlr.Seat.event.RequestSetPrimarySelection,
) void { ) void {
const seat = @fieldParentPtr(Seat, "request_set_primary_selection", listener); const seat: *Seat = @fieldParentPtr("request_set_primary_selection", listener);
seat.wlr_seat.setPrimarySelection(event.source, event.serial); seat.wlr_seat.setPrimarySelection(event.source, event.serial);
} }

2
river/SeatStatus.zig
View File

@ -49,7 +49,7 @@ fn handleRequest(seat_status_v1: *zriver.SeatStatusV1, request: zriver.SeatStatu
} }
fn handleDestroy(_: *zriver.SeatStatusV1, seat_status: *SeatStatus) void { fn handleDestroy(_: *zriver.SeatStatusV1, seat_status: *SeatStatus) void {
const node = @fieldParentPtr(std.SinglyLinkedList(SeatStatus).Node, "data", seat_status); const node: *std.SinglyLinkedList(SeatStatus).Node = @fieldParentPtr("data", seat_status);
seat_status.seat.status_trackers.remove(node); seat_status.seat.status_trackers.remove(node);
util.gpa.destroy(node); util.gpa.destroy(node);
} }

9
river/Server.zig
View File

@ -19,6 +19,7 @@ const Server = @This();
const build_options = @import("build_options"); const build_options = @import("build_options");
const std = @import("std"); const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const posix = std.posix;
const wlr = @import("wlroots"); const wlr = @import("wlroots");
const wl = @import("wayland").server.wl; const wl = @import("wayland").server.wl;
@ -122,8 +123,8 @@ pub fn init(server: *Server, runtime_xwayland: bool) !void {
const loop = wl_server.getEventLoop(); const loop = wl_server.getEventLoop();
server.* = .{ server.* = .{
.wl_server = wl_server, .wl_server = wl_server,
.sigint_source = try loop.addSignal(*wl.Server, std.os.SIG.INT, terminate, wl_server), .sigint_source = try loop.addSignal(*wl.Server, posix.SIG.INT, terminate, wl_server),
.sigterm_source = try loop.addSignal(*wl.Server, std.os.SIG.TERM, terminate, wl_server), .sigterm_source = try loop.addSignal(*wl.Server, posix.SIG.TERM, terminate, wl_server),
.backend = backend, .backend = backend,
.session = session, .session = session,
@ -371,7 +372,7 @@ fn handleNewToplevelDecoration(
} }
fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void { fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void {
const server = @fieldParentPtr(Server, "new_layer_surface", listener); const server: *Server = @fieldParentPtr("new_layer_surface", listener);
log.debug( log.debug(
"new layer surface: namespace {s}, layer {s}, anchor {b:0>4}, size {},{}, margin {},{},{},{}, exclusive_zone {}", "new layer surface: namespace {s}, layer {s}, anchor {b:0>4}, size {},{}, margin {},{},{},{}, exclusive_zone {}",
@ -431,7 +432,7 @@ fn handleRequestActivate(
listener: *wl.Listener(*wlr.XdgActivationV1.event.RequestActivate), listener: *wl.Listener(*wlr.XdgActivationV1.event.RequestActivate),
event: *wlr.XdgActivationV1.event.RequestActivate, event: *wlr.XdgActivationV1.event.RequestActivate,
) void { ) void {
const server = @fieldParentPtr(Server, "request_activate", listener); const server: *Server = @fieldParentPtr("request_activate", listener);
const node_data = SceneNodeData.fromSurface(event.surface) orelse return; const node_data = SceneNodeData.fromSurface(event.surface) orelse return;
switch (node_data.data) { switch (node_data.data) {

2
river/StatusManager.zig
View File

@ -46,7 +46,7 @@ pub fn init(status_manager: *StatusManager) !void {
} }
fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void { fn handleServerDestroy(listener: *wl.Listener(*wl.Server), _: *wl.Server) void {
const status_manager = @fieldParentPtr(StatusManager, "server_destroy", listener); const status_manager: *StatusManager = @fieldParentPtr("server_destroy", listener);
status_manager.global.destroy(); status_manager.global.destroy();
} }

2
river/Switch.zig
View File

@ -71,7 +71,7 @@ pub fn deinit(switch_device: *Switch) void {
} }
fn handleToggle(listener: *wl.Listener(*wlr.Switch.event.Toggle), event: *wlr.Switch.event.Toggle) void { fn handleToggle(listener: *wl.Listener(*wlr.Switch.event.Toggle), event: *wlr.Switch.event.Toggle) void {
const switch_device = @fieldParentPtr(Switch, "toggle", listener); const switch_device: *Switch = @fieldParentPtr("toggle", listener);
switch_device.device.seat.handleActivity(); switch_device.device.seat.handleActivity();

4
river/TabletTool.zig
View File

@ -90,7 +90,7 @@ fn create(wlr_seat: *wlr.Seat, wlr_tool: *wlr.TabletTool) error{OutOfMemory}!*Ta
} }
fn handleDestroy(listener: *wl.Listener(*wlr.TabletTool), _: *wlr.TabletTool) void { fn handleDestroy(listener: *wl.Listener(*wlr.TabletTool), _: *wlr.TabletTool) void {
const tool = @fieldParentPtr(TabletTool, "destroy", listener); const tool: *TabletTool = @fieldParentPtr("destroy", listener);
tool.wp_tool.wlr_tool.data = 0; tool.wp_tool.wlr_tool.data = 0;
@ -106,7 +106,7 @@ fn handleSetCursor(
listener: *wl.Listener(*wlr.TabletV2TabletTool.event.SetCursor), listener: *wl.Listener(*wlr.TabletV2TabletTool.event.SetCursor),
event: *wlr.TabletV2TabletTool.event.SetCursor, event: *wlr.TabletV2TabletTool.event.SetCursor,
) void { ) void {
const tool = @fieldParentPtr(TabletTool, "set_cursor", listener); const tool: *TabletTool = @fieldParentPtr("set_cursor", listener);
if (tool.wp_tool.focused_surface == null or if (tool.wp_tool.focused_surface == null or
tool.wp_tool.focused_surface.?.resource.getClient() != event.seat_client.client) tool.wp_tool.focused_surface.?.resource.getClient() != event.seat_client.client)

8
river/TextInput.zig
View File

@ -63,7 +63,7 @@ pub fn create(wlr_text_input: *wlr.TextInputV3) !void {
} }
fn handleEnable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void { fn handleEnable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
const text_input = @fieldParentPtr(TextInput, "enable", listener); const text_input: *TextInput = @fieldParentPtr("enable", listener);
const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data); const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
if (text_input.wlr_text_input.focused_surface == null) { if (text_input.wlr_text_input.focused_surface == null) {
@ -90,7 +90,7 @@ fn handleEnable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) v
} }
fn handleCommit(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void { fn handleCommit(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
const text_input = @fieldParentPtr(TextInput, "commit", listener); const text_input: *TextInput = @fieldParentPtr("commit", listener);
const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data); const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
if (seat.relay.text_input != text_input) { if (seat.relay.text_input != text_input) {
@ -104,7 +104,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) v
} }
fn handleDisable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void { fn handleDisable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
const text_input = @fieldParentPtr(TextInput, "disable", listener); const text_input: *TextInput = @fieldParentPtr("disable", listener);
const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data); const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
if (seat.relay.text_input == text_input) { if (seat.relay.text_input == text_input) {
@ -113,7 +113,7 @@ fn handleDisable(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3)
} }
fn handleDestroy(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void { fn handleDestroy(listener: *wl.Listener(*wlr.TextInputV3), _: *wlr.TextInputV3) void {
const text_input = @fieldParentPtr(TextInput, "destroy", listener); const text_input: *TextInput = @fieldParentPtr("destroy", listener);
const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data); const seat: *Seat = @ptrFromInt(text_input.wlr_text_input.seat.data);
if (seat.relay.text_input == text_input) { if (seat.relay.text_input == text_input) {

2
river/Vector.zig
View File

@ -44,7 +44,7 @@ pub fn direction(v: Vector) ?wlr.OutputLayout.Direction {
// A zero length vector has no direction // A zero length vector has no direction
if (v.x == 0 and v.y == 0) return null; if (v.x == 0 and v.y == 0) return null;
if ((math.absInt(v.y) catch return null) > (math.absInt(v.x) catch return null)) { if (@abs(v.y) > @abs(v.x)) {
// Careful: We are operating in a Y-inverted coordinate system. // Careful: We are operating in a Y-inverted coordinate system.
return if (v.y > 0) .down else .up; return if (v.y > 0) .down else .up;
} else { } else {

7
river/View.zig
View File

@ -20,7 +20,7 @@ const build_options = @import("build_options");
const std = @import("std"); const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const math = std.math; const math = std.math;
const os = std.os; const posix = std.posix;
const wlr = @import("wlroots"); const wlr = @import("wlroots");
const wl = @import("wayland").server.wl; const wl = @import("wayland").server.wl;
@ -472,8 +472,9 @@ pub fn rootSurface(view: View) ?*wlr.Surface {
pub fn sendFrameDone(view: View) void { pub fn sendFrameDone(view: View) void {
assert(view.mapped and !view.destroying); assert(view.mapped and !view.destroying);
var now: os.timespec = undefined;
os.clock_gettime(os.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported"); var now: posix.timespec = undefined;
posix.clock_gettime(posix.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
view.rootSurface().?.sendFrameDone(&now); view.rootSurface().?.sendFrameDone(&now);
} }

4
river/XdgDecoration.zig
View File

@ -66,7 +66,7 @@ fn handleDestroy(
listener: *wl.Listener(*wlr.XdgToplevelDecorationV1), listener: *wl.Listener(*wlr.XdgToplevelDecorationV1),
_: *wlr.XdgToplevelDecorationV1, _: *wlr.XdgToplevelDecorationV1,
) void { ) void {
const decoration = @fieldParentPtr(XdgDecoration, "destroy", listener); const decoration: *XdgDecoration = @fieldParentPtr("destroy", listener);
decoration.deinit(); decoration.deinit();
} }
@ -75,7 +75,7 @@ fn handleRequestMode(
listener: *wl.Listener(*wlr.XdgToplevelDecorationV1), listener: *wl.Listener(*wlr.XdgToplevelDecorationV1),
_: *wlr.XdgToplevelDecorationV1, _: *wlr.XdgToplevelDecorationV1,
) void { ) void {
const decoration = @fieldParentPtr(XdgDecoration, "request_mode", listener); const decoration: *XdgDecoration = @fieldParentPtr("request_mode", listener);
const toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.toplevel.base.data); const toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.toplevel.base.data);
const view = toplevel.view; const view = toplevel.view;

6
river/XdgPopup.zig
View File

@ -61,7 +61,7 @@ pub fn create(
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const xdg_popup = @fieldParentPtr(XdgPopup, "destroy", listener); const xdg_popup: *XdgPopup = @fieldParentPtr("destroy", listener);
xdg_popup.destroy.link.remove(); xdg_popup.destroy.link.remove();
xdg_popup.new_popup.link.remove(); xdg_popup.new_popup.link.remove();
@ -71,7 +71,7 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
} }
fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void { fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void {
const xdg_popup = @fieldParentPtr(XdgPopup, "new_popup", listener); const xdg_popup: *XdgPopup = @fieldParentPtr("new_popup", listener);
XdgPopup.create( XdgPopup.create(
wlr_xdg_popup, wlr_xdg_popup,
@ -84,7 +84,7 @@ fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.Xdg
} }
fn handleReposition(listener: *wl.Listener(void)) void { fn handleReposition(listener: *wl.Listener(void)) void {
const xdg_popup = @fieldParentPtr(XdgPopup, "reposition", listener); const xdg_popup: *XdgPopup = @fieldParentPtr("reposition", listener);
const output = switch (SceneNodeData.fromNode(&xdg_popup.root.node).?.data) { const output = switch (SceneNodeData.fromNode(&xdg_popup.root.node).?.data) {
.view => |view| view.current.output orelse return, .view => |view| view.current.output orelse return,

22
river/XdgToplevel.zig
View File

@ -200,7 +200,7 @@ pub fn destroyPopups(toplevel: XdgToplevel) void {
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "destroy", listener); const toplevel: *XdgToplevel = @fieldParentPtr("destroy", listener);
// This can be be non-null here if the client commits a protocol error or // This can be be non-null here if the client commits a protocol error or
// if it exits without destroying its wayland objects. // if it exits without destroying its wayland objects.
@ -223,7 +223,7 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
} }
fn handleMap(listener: *wl.Listener(void)) void { fn handleMap(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "map", listener); const toplevel: *XdgToplevel = @fieldParentPtr("map", listener);
const view = toplevel.view; const view = toplevel.view;
// Add listeners that are only active while mapped // Add listeners that are only active while mapped
@ -266,7 +266,7 @@ fn handleMap(listener: *wl.Listener(void)) void {
/// Called when the surface is unmapped and will no longer be displayed. /// Called when the surface is unmapped and will no longer be displayed.
fn handleUnmap(listener: *wl.Listener(void)) void { fn handleUnmap(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "unmap", listener); const toplevel: *XdgToplevel = @fieldParentPtr("unmap", listener);
// Remove listeners that are only active while mapped // Remove listeners that are only active while mapped
toplevel.ack_configure.link.remove(); toplevel.ack_configure.link.remove();
@ -281,7 +281,7 @@ fn handleUnmap(listener: *wl.Listener(void)) void {
} }
fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void { fn handleNewPopup(listener: *wl.Listener(*wlr.XdgPopup), wlr_xdg_popup: *wlr.XdgPopup) void {
const toplevel = @fieldParentPtr(XdgToplevel, "new_popup", listener); const toplevel: *XdgToplevel = @fieldParentPtr("new_popup", listener);
XdgPopup.create(wlr_xdg_popup, toplevel.view.popup_tree, toplevel.view.popup_tree) catch { XdgPopup.create(wlr_xdg_popup, toplevel.view.popup_tree, toplevel.view.popup_tree) catch {
wlr_xdg_popup.resource.postNoMemory(); wlr_xdg_popup.resource.postNoMemory();
@ -293,7 +293,7 @@ fn handleAckConfigure(
listener: *wl.Listener(*wlr.XdgSurface.Configure), listener: *wl.Listener(*wlr.XdgSurface.Configure),
acked_configure: *wlr.XdgSurface.Configure, acked_configure: *wlr.XdgSurface.Configure,
) void { ) void {
const toplevel = @fieldParentPtr(XdgToplevel, "ack_configure", listener); const toplevel: *XdgToplevel = @fieldParentPtr("ack_configure", listener);
switch (toplevel.configure_state) { switch (toplevel.configure_state) {
.inflight => |serial| if (acked_configure.serial == serial) { .inflight => |serial| if (acked_configure.serial == serial) {
toplevel.configure_state = .acked; toplevel.configure_state = .acked;
@ -306,7 +306,7 @@ fn handleAckConfigure(
} }
fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void { fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
const toplevel = @fieldParentPtr(XdgToplevel, "commit", listener); const toplevel: *XdgToplevel = @fieldParentPtr("commit", listener);
const view = toplevel.view; const view = toplevel.view;
{ {
@ -395,7 +395,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
/// Called when the client asks to be fullscreened. We always honor the request /// Called when the client asks to be fullscreened. We always honor the request
/// for now, perhaps it should be denied in some cases in the future. /// for now, perhaps it should be denied in some cases in the future.
fn handleRequestFullscreen(listener: *wl.Listener(void)) void { fn handleRequestFullscreen(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "request_fullscreen", listener); const toplevel: *XdgToplevel = @fieldParentPtr("request_fullscreen", listener);
if (toplevel.view.pending.fullscreen != toplevel.wlr_toplevel.requested.fullscreen) { if (toplevel.view.pending.fullscreen != toplevel.wlr_toplevel.requested.fullscreen) {
toplevel.view.pending.fullscreen = toplevel.wlr_toplevel.requested.fullscreen; toplevel.view.pending.fullscreen = toplevel.wlr_toplevel.requested.fullscreen;
server.root.applyPending(); server.root.applyPending();
@ -406,7 +406,7 @@ fn handleRequestMove(
listener: *wl.Listener(*wlr.XdgToplevel.event.Move), listener: *wl.Listener(*wlr.XdgToplevel.event.Move),
event: *wlr.XdgToplevel.event.Move, event: *wlr.XdgToplevel.event.Move,
) void { ) void {
const toplevel = @fieldParentPtr(XdgToplevel, "request_move", listener); const toplevel: *XdgToplevel = @fieldParentPtr("request_move", listener);
const seat: *Seat = @ptrFromInt(event.seat.seat.data); const seat: *Seat = @ptrFromInt(event.seat.seat.data);
const view = toplevel.view; const view = toplevel.view;
@ -429,7 +429,7 @@ fn handleRequestMove(
} }
fn handleRequestResize(listener: *wl.Listener(*wlr.XdgToplevel.event.Resize), event: *wlr.XdgToplevel.event.Resize) void { fn handleRequestResize(listener: *wl.Listener(*wlr.XdgToplevel.event.Resize), event: *wlr.XdgToplevel.event.Resize) void {
const toplevel = @fieldParentPtr(XdgToplevel, "request_resize", listener); const toplevel: *XdgToplevel = @fieldParentPtr("request_resize", listener);
const seat: *Seat = @ptrFromInt(event.seat.seat.data); const seat: *Seat = @ptrFromInt(event.seat.seat.data);
const view = toplevel.view; const view = toplevel.view;
@ -453,12 +453,12 @@ fn handleRequestResize(listener: *wl.Listener(*wlr.XdgToplevel.event.Resize), ev
/// Called when the client sets / updates its title /// Called when the client sets / updates its title
fn handleSetTitle(listener: *wl.Listener(void)) void { fn handleSetTitle(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "set_title", listener); const toplevel: *XdgToplevel = @fieldParentPtr("set_title", listener);
toplevel.view.notifyTitle(); toplevel.view.notifyTitle();
} }
/// Called when the client sets / updates its app_id /// Called when the client sets / updates its app_id
fn handleSetAppId(listener: *wl.Listener(void)) void { fn handleSetAppId(listener: *wl.Listener(void)) void {
const toplevel = @fieldParentPtr(XdgToplevel, "set_app_id", listener); const toplevel: *XdgToplevel = @fieldParentPtr("set_app_id", listener);
toplevel.view.notifyAppId(); toplevel.view.notifyAppId();
} }

14
river/XwaylandOverrideRedirect.zig
View File

@ -78,7 +78,7 @@ fn handleRequestConfigure(
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "destroy", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("destroy", listener);
override_redirect.request_configure.link.remove(); override_redirect.request_configure.link.remove();
override_redirect.destroy.link.remove(); override_redirect.destroy.link.remove();
@ -90,21 +90,21 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
} }
fn handleAssociate(listener: *wl.Listener(void)) void { fn handleAssociate(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "associate", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("associate", listener);
override_redirect.xwayland_surface.surface.?.events.map.add(&override_redirect.map); override_redirect.xwayland_surface.surface.?.events.map.add(&override_redirect.map);
override_redirect.xwayland_surface.surface.?.events.unmap.add(&override_redirect.unmap); override_redirect.xwayland_surface.surface.?.events.unmap.add(&override_redirect.unmap);
} }
fn handleDissociate(listener: *wl.Listener(void)) void { fn handleDissociate(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "dissociate", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("dissociate", listener);
override_redirect.map.link.remove(); override_redirect.map.link.remove();
override_redirect.unmap.link.remove(); override_redirect.unmap.link.remove();
} }
pub fn handleMap(listener: *wl.Listener(void)) void { pub fn handleMap(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "map", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("map", listener);
override_redirect.mapImpl() catch { override_redirect.mapImpl() catch {
log.err("out of memory", .{}); log.err("out of memory", .{});
@ -155,7 +155,7 @@ pub fn focusIfDesired(override_redirect: *XwaylandOverrideRedirect) void {
} }
fn handleUnmap(listener: *wl.Listener(void)) void { fn handleUnmap(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "unmap", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("unmap", listener);
override_redirect.set_geometry.link.remove(); override_redirect.set_geometry.link.remove();
@ -180,7 +180,7 @@ fn handleUnmap(listener: *wl.Listener(void)) void {
} }
fn handleSetGeometry(listener: *wl.Listener(void)) void { fn handleSetGeometry(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "set_geometry", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("set_geometry", listener);
override_redirect.surface_tree.?.node.setPosition( override_redirect.surface_tree.?.node.setPosition(
override_redirect.xwayland_surface.x, override_redirect.xwayland_surface.x,
@ -189,7 +189,7 @@ fn handleSetGeometry(listener: *wl.Listener(void)) void {
} }
fn handleSetOverrideRedirect(listener: *wl.Listener(void)) void { fn handleSetOverrideRedirect(listener: *wl.Listener(void)) void {
const override_redirect = @fieldParentPtr(XwaylandOverrideRedirect, "set_override_redirect", listener); const override_redirect: *XwaylandOverrideRedirect = @fieldParentPtr("set_override_redirect", listener);
const xwayland_surface = override_redirect.xwayland_surface; const xwayland_surface = override_redirect.xwayland_surface;
log.debug("xwayland surface unset override redirect", .{}); log.debug("xwayland surface unset override redirect", .{});

24
river/XwaylandView.zig
View File

@ -131,7 +131,7 @@ fn setActivated(xwayland_view: XwaylandView, activated: bool) void {
} }
fn handleDestroy(listener: *wl.Listener(void)) void { fn handleDestroy(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "destroy", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("destroy", listener);
// Remove listeners that are active for the entire lifetime of the view // Remove listeners that are active for the entire lifetime of the view
xwayland_view.destroy.link.remove(); xwayland_view.destroy.link.remove();
@ -146,20 +146,20 @@ fn handleDestroy(listener: *wl.Listener(void)) void {
} }
fn handleAssociate(listener: *wl.Listener(void)) void { fn handleAssociate(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "associate", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("associate", listener);
xwayland_view.xwayland_surface.surface.?.events.map.add(&xwayland_view.map); xwayland_view.xwayland_surface.surface.?.events.map.add(&xwayland_view.map);
xwayland_view.xwayland_surface.surface.?.events.unmap.add(&xwayland_view.unmap); xwayland_view.xwayland_surface.surface.?.events.unmap.add(&xwayland_view.unmap);
} }
fn handleDissociate(listener: *wl.Listener(void)) void { fn handleDissociate(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "dissociate", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("dissociate", listener);
xwayland_view.map.link.remove(); xwayland_view.map.link.remove();
xwayland_view.unmap.link.remove(); xwayland_view.unmap.link.remove();
} }
pub fn handleMap(listener: *wl.Listener(void)) void { pub fn handleMap(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "map", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("map", listener);
const view = xwayland_view.view; const view = xwayland_view.view;
const xwayland_surface = xwayland_view.xwayland_surface; const xwayland_surface = xwayland_view.xwayland_surface;
@ -213,7 +213,7 @@ pub fn handleMap(listener: *wl.Listener(void)) void {
} }
fn handleUnmap(listener: *wl.Listener(void)) void { fn handleUnmap(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "unmap", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("unmap", listener);
xwayland_view.xwayland_surface.surface.?.data = 0; xwayland_view.xwayland_surface.surface.?.data = 0;
@ -235,7 +235,7 @@ fn handleRequestConfigure(
listener: *wl.Listener(*wlr.XwaylandSurface.event.Configure), listener: *wl.Listener(*wlr.XwaylandSurface.event.Configure),
event: *wlr.XwaylandSurface.event.Configure, event: *wlr.XwaylandSurface.event.Configure,
) void { ) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "request_configure", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("request_configure", listener);
// If unmapped, let the client do whatever it wants // If unmapped, let the client do whatever it wants
if (xwayland_view.xwayland_surface.surface == null or if (xwayland_view.xwayland_surface.surface == null or
@ -254,7 +254,7 @@ fn handleRequestConfigure(
} }
fn handleSetOverrideRedirect(listener: *wl.Listener(void)) void { fn handleSetOverrideRedirect(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "set_override_redirect", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("set_override_redirect", listener);
const xwayland_surface = xwayland_view.xwayland_surface; const xwayland_surface = xwayland_view.xwayland_surface;
log.debug("xwayland surface set override redirect", .{}); log.debug("xwayland surface set override redirect", .{});
@ -276,17 +276,17 @@ fn handleSetOverrideRedirect(listener: *wl.Listener(void)) void {
} }
fn handleSetTitle(listener: *wl.Listener(void)) void { fn handleSetTitle(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "set_title", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("set_title", listener);
xwayland_view.view.notifyTitle(); xwayland_view.view.notifyTitle();
} }
fn handleSetClass(listener: *wl.Listener(void)) void { fn handleSetClass(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "set_class", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("set_class", listener);
xwayland_view.view.notifyAppId(); xwayland_view.view.notifyAppId();
} }
fn handleSetDecorations(listener: *wl.Listener(void)) void { fn handleSetDecorations(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "set_decorations", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("set_decorations", listener);
const view = xwayland_view.view; const view = xwayland_view.view;
const ssd = server.config.rules.ssd.match(view) orelse const ssd = server.config.rules.ssd.match(view) orelse
@ -299,7 +299,7 @@ fn handleSetDecorations(listener: *wl.Listener(void)) void {
} }
fn handleRequestFullscreen(listener: *wl.Listener(void)) void { fn handleRequestFullscreen(listener: *wl.Listener(void)) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "request_fullscreen", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("request_fullscreen", listener);
if (xwayland_view.view.pending.fullscreen != xwayland_view.xwayland_surface.fullscreen) { if (xwayland_view.view.pending.fullscreen != xwayland_view.xwayland_surface.fullscreen) {
xwayland_view.view.pending.fullscreen = xwayland_view.xwayland_surface.fullscreen; xwayland_view.view.pending.fullscreen = xwayland_view.xwayland_surface.fullscreen;
server.root.applyPending(); server.root.applyPending();
@ -314,6 +314,6 @@ fn handleRequestMinimize(
listener: *wl.Listener(*wlr.XwaylandSurface.event.Minimize), listener: *wl.Listener(*wlr.XwaylandSurface.event.Minimize),
event: *wlr.XwaylandSurface.event.Minimize, event: *wlr.XwaylandSurface.event.Minimize,
) void { ) void {
const xwayland_view = @fieldParentPtr(XwaylandView, "request_minimize", listener); const xwayland_view: *XwaylandView = @fieldParentPtr("request_minimize", listener);
xwayland_view.xwayland_surface.setMinimized(event.minimize); xwayland_view.xwayland_surface.setMinimized(event.minimize);
} }

2
river/command/output.zig
View File

@ -109,7 +109,7 @@ fn getOutput(seat: *Seat, str: []const u8) !?*Output {
.previous => link.prev.?, .previous => link.prev.?,
}; };
} }
return @fieldParentPtr(Output, "active_link", link); return @as(*Output, @fieldParentPtr("active_link", link));
} else if (std.meta.stringToEnum(wlr.OutputLayout.Direction, str)) |direction| { // Spacial direction } else if (std.meta.stringToEnum(wlr.OutputLayout.Direction, str)) |direction| { // Spacial direction
var focus_box: wlr.Box = undefined; var focus_box: wlr.Box = undefined;
server.root.output_layout.getBox(seat.focused_output.?.wlr_output, &focus_box); server.root.output_layout.getBox(seat.focused_output.?.wlr_output, &focus_box);

17
river/command/spawn.zig
View File

@ -15,7 +15,7 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
const std = @import("std"); const std = @import("std");
const os = std.os; const posix = std.posix;
const c = @import("../c.zig"); const c = @import("../c.zig");
const util = @import("../util.zig"); const util = @import("../util.zig");
@ -35,23 +35,26 @@ pub fn spawn(
const child_args = [_:null]?[*:0]const u8{ "/bin/sh", "-c", args[1], null }; const child_args = [_:null]?[*:0]const u8{ "/bin/sh", "-c", args[1], null };
const pid = os.fork() catch { const pid = posix.fork() catch {
out.* = try std.fmt.allocPrint(util.gpa, "fork/execve failed", .{}); out.* = try std.fmt.allocPrint(util.gpa, "fork/execve failed", .{});
return Error.Other; return Error.Other;
}; };
if (pid == 0) { if (pid == 0) {
process.cleanupChild(); process.cleanupChild();
const pid2 = os.fork() catch c._exit(1);
if (pid2 == 0) os.execveZ("/bin/sh", &child_args, std.c.environ) catch c._exit(1); const pid2 = posix.fork() catch c._exit(1);
if (pid2 == 0) {
posix.execveZ("/bin/sh", &child_args, std.c.environ) catch c._exit(1);
}
c._exit(0); c._exit(0);
} }
// Wait the intermediate child. // Wait the intermediate child.
const ret = os.waitpid(pid, 0); const ret = posix.waitpid(pid, 0);
if (!os.W.IFEXITED(ret.status) or if (!posix.W.IFEXITED(ret.status) or
(os.W.IFEXITED(ret.status) and os.W.EXITSTATUS(ret.status) != 0)) (posix.W.IFEXITED(ret.status) and posix.W.EXITSTATUS(ret.status) != 0))
{ {
out.* = try std.fmt.allocPrint(util.gpa, "fork/execve failed", .{}); out.* = try std.fmt.allocPrint(util.gpa, "fork/execve failed", .{});
return Error.Other; return Error.Other;

45
river/main.zig
View File

@ -20,7 +20,7 @@ const mem = std.mem;
const fs = std.fs; const fs = std.fs;
const io = std.io; const io = std.io;
const log = std.log; const log = std.log;
const os = std.os; const posix = std.posix;
const builtin = @import("builtin"); const builtin = @import("builtin");
const wlr = @import("wlroots"); const wlr = @import("wlroots");
const flags = @import("flags"); const flags = @import("flags");
@ -57,23 +57,23 @@ pub fn main() anyerror!void {
.{ .name = "c", .kind = .arg }, .{ .name = "c", .kind = .arg },
.{ .name = "log-level", .kind = .arg }, .{ .name = "log-level", .kind = .arg },
.{ .name = "no-xwayland", .kind = .boolean }, .{ .name = "no-xwayland", .kind = .boolean },
}).parse(os.argv[1..]) catch { }).parse(std.os.argv[1..]) catch {
try io.getStdErr().writeAll(usage); try io.getStdErr().writeAll(usage);
os.exit(1); posix.exit(1);
}; };
if (result.flags.h) { if (result.flags.h) {
try io.getStdOut().writeAll(usage); try io.getStdOut().writeAll(usage);
os.exit(0); posix.exit(0);
} }
if (result.args.len != 0) { if (result.args.len != 0) {
log.err("unknown option '{s}'", .{result.args[0]}); log.err("unknown option '{s}'", .{result.args[0]});
try io.getStdErr().writeAll(usage); try io.getStdErr().writeAll(usage);
os.exit(1); posix.exit(1);
} }
if (result.flags.version) { if (result.flags.version) {
try io.getStdOut().writeAll(build_options.version ++ "\n"); try io.getStdOut().writeAll(build_options.version ++ "\n");
os.exit(0); posix.exit(0);
} }
if (result.flags.@"log-level") |level| { if (result.flags.@"log-level") |level| {
if (mem.eql(u8, level, "error")) { if (mem.eql(u8, level, "error")) {
@ -87,7 +87,7 @@ pub fn main() anyerror!void {
} else { } else {
log.err("invalid log level '{s}'", .{level}); log.err("invalid log level '{s}'", .{level});
try io.getStdErr().writeAll(usage); try io.getStdErr().writeAll(usage);
os.exit(1); posix.exit(1);
} }
} }
const enable_xwayland = !result.flags.@"no-xwayland"; const enable_xwayland = !result.flags.@"no-xwayland";
@ -119,16 +119,16 @@ pub fn main() anyerror!void {
const child_pgid = if (startup_command) |cmd| blk: { const child_pgid = if (startup_command) |cmd| blk: {
log.info("running init executable '{s}'", .{cmd}); log.info("running init executable '{s}'", .{cmd});
const child_args = [_:null]?[*:0]const u8{ "/bin/sh", "-c", cmd, null }; const child_args = [_:null]?[*:0]const u8{ "/bin/sh", "-c", cmd, null };
const pid = try os.fork(); const pid = try posix.fork();
if (pid == 0) { if (pid == 0) {
process.cleanupChild(); process.cleanupChild();
os.execveZ("/bin/sh", &child_args, std.c.environ) catch c._exit(1); posix.execveZ("/bin/sh", &child_args, std.c.environ) catch c._exit(1);
} }
util.gpa.free(cmd); util.gpa.free(cmd);
// Since the child has called setsid, the pid is the pgid // Since the child has called setsid, the pid is the pgid
break :blk pid; break :blk pid;
} else null; } else null;
defer if (child_pgid) |pgid| os.kill(-pgid, os.SIG.TERM) catch |err| { defer if (child_pgid) |pgid| posix.kill(-pgid, posix.SIG.TERM) catch |err| {
log.err("failed to kill init process group: {s}", .{@errorName(err)}); log.err("failed to kill init process group: {s}", .{@errorName(err)});
}; };
@ -141,20 +141,20 @@ pub fn main() anyerror!void {
fn defaultInitPath() !?[:0]const u8 { fn defaultInitPath() !?[:0]const u8 {
const path = blk: { const path = blk: {
if (os.getenv("XDG_CONFIG_HOME")) |xdg_config_home| { if (posix.getenv("XDG_CONFIG_HOME")) |xdg_config_home| {
break :blk try fs.path.joinZ(util.gpa, &[_][]const u8{ xdg_config_home, "river/init" }); break :blk try fs.path.joinZ(util.gpa, &[_][]const u8{ xdg_config_home, "river/init" });
} else if (os.getenv("HOME")) |home| { } else if (posix.getenv("HOME")) |home| {
break :blk try fs.path.joinZ(util.gpa, &[_][]const u8{ home, ".config/river/init" }); break :blk try fs.path.joinZ(util.gpa, &[_][]const u8{ home, ".config/river/init" });
} else { } else {
return null; return null;
} }
}; };
os.accessZ(path, os.X_OK) catch |err| { posix.accessZ(path, posix.X_OK) catch |err| {
if (err == error.PermissionDenied) { if (err == error.PermissionDenied) {
if (os.accessZ(path, os.R_OK)) { if (posix.accessZ(path, posix.R_OK)) {
log.err("failed to run init executable {s}: the file is not executable", .{path}); log.err("failed to run init executable {s}: the file is not executable", .{path});
os.exit(1); posix.exit(1);
} else |_| {} } else |_| {}
} }
log.err("failed to run init executable {s}: {s}", .{ path, @errorName(err) }); log.err("failed to run init executable {s}: {s}", .{ path, @errorName(err) });
@ -171,24 +171,25 @@ var runtime_log_level: log.Level = switch (builtin.mode) {
.ReleaseSafe, .ReleaseFast, .ReleaseSmall => .info, .ReleaseSafe, .ReleaseFast, .ReleaseSmall => .info,
}; };
pub const std_options = struct { pub const std_options: std.Options = .{
/// Tell std.log to leave all log level filtering to us. // Tell std.log to leave all log level filtering to us.
pub const log_level: log.Level = .debug; .log_level = .debug,
.logFn = logFn,
};
pub fn logFn( pub fn logFn(
comptime level: log.Level, comptime level: log.Level,
comptime scope: @TypeOf(.EnumLiteral), comptime scope: @TypeOf(.EnumLiteral),
comptime format: []const u8, comptime format: []const u8,
args: anytype, args: anytype,
) void { ) void {
if (@intFromEnum(level) > @intFromEnum(runtime_log_level)) return; if (@intFromEnum(level) > @intFromEnum(runtime_log_level)) return;
const scope_prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): "; const scope_prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
const stderr = io.getStdErr().writer(); const stderr = io.getStdErr().writer();
stderr.print(level.asText() ++ scope_prefix ++ format ++ "\n", args) catch {}; stderr.print(level.asText() ++ scope_prefix ++ format ++ "\n", args) catch {};
} }
};
/// See wlroots_log_wrapper.c /// See wlroots_log_wrapper.c
extern fn river_init_wlroots_log(importance: wlr.log.Importance) void; extern fn river_init_wlroots_log(importance: wlr.log.Importance) void;

30
river/process.zig
View File

@ -15,21 +15,21 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
const std = @import("std"); const std = @import("std");
const os = std.os; const posix = std.posix;
const c = @import("c.zig"); const c = @import("c.zig");
var original_rlimit: ?os.rlimit = null; var original_rlimit: ?posix.rlimit = null;
pub fn setup() void { pub fn setup() void {
// Ignore SIGPIPE so we don't get killed when writing to a socket that // Ignore SIGPIPE so we don't get killed when writing to a socket that
// has had its read end closed by another process. // has had its read end closed by another process.
const sig_ign = os.Sigaction{ const sig_ign = posix.Sigaction{
.handler = .{ .handler = os.SIG.IGN }, .handler = .{ .handler = posix.SIG.IGN },
.mask = os.empty_sigset, .mask = posix.empty_sigset,
.flags = 0, .flags = 0,
}; };
os.sigaction(os.SIG.PIPE, &sig_ign, null) catch unreachable; posix.sigaction(posix.SIG.PIPE, &sig_ign, null) catch unreachable;
// Most unix systems have a default limit of 1024 file descriptors and it // 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 // seems unlikely for this default to be universally raised due to the
@ -41,13 +41,13 @@ pub fn setup() void {
// to catch any fd leaks. Therefore, don't use some crazy high limit that // to catch any fd leaks. Therefore, don't use some crazy high limit that
// can never be reached before the system runs out of memory. This can be // can never be reached before the system runs out of memory. This can be
// raised further if anyone reaches it in practice. // raised further if anyone reaches it in practice.
if (os.getrlimit(.NOFILE)) |original| { if (posix.getrlimit(.NOFILE)) |original| {
original_rlimit = original; original_rlimit = original;
const new: os.rlimit = .{ const new: posix.rlimit = .{
.cur = @min(4096, original.max), .cur = @min(4096, original.max),
.max = original.max, .max = original.max,
}; };
if (os.setrlimit(.NOFILE, new)) { if (posix.setrlimit(.NOFILE, new)) {
std.log.info("raised file descriptor limit of the river process to {d}", .{new.cur}); std.log.info("raised file descriptor limit of the river process to {d}", .{new.cur});
} else |_| { } else |_| {
std.log.err("setrlimit failed, using system default file descriptor limit of {d}", .{ std.log.err("setrlimit failed, using system default file descriptor limit of {d}", .{
@ -61,17 +61,17 @@ pub fn setup() void {
pub fn cleanupChild() void { pub fn cleanupChild() void {
if (c.setsid() < 0) unreachable; if (c.setsid() < 0) unreachable;
if (os.system.sigprocmask(os.SIG.SETMASK, &os.empty_sigset, null) < 0) unreachable; if (posix.system.sigprocmask(posix.SIG.SETMASK, &posix.empty_sigset, null) < 0) unreachable;
const sig_dfl = os.Sigaction{ const sig_dfl = posix.Sigaction{
.handler = .{ .handler = os.SIG.DFL }, .handler = .{ .handler = posix.SIG.DFL },
.mask = os.empty_sigset, .mask = posix.empty_sigset,
.flags = 0, .flags = 0,
}; };
os.sigaction(os.SIG.PIPE, &sig_dfl, null) catch unreachable; posix.sigaction(posix.SIG.PIPE, &sig_dfl, null) catch unreachable;
if (original_rlimit) |original| { if (original_rlimit) |original| {
os.setrlimit(.NOFILE, original) catch { posix.setrlimit(.NOFILE, original) catch {
std.log.err("failed to restore original file descriptor limit for " ++ std.log.err("failed to restore original file descriptor limit for " ++
"child process, setrlimit failed", .{}); "child process, setrlimit failed", .{});
}; };

18
riverctl/main.zig
View File

@ -17,7 +17,7 @@
const std = @import("std"); const std = @import("std");
const mem = std.mem; const mem = std.mem;
const io = std.io; const io = std.io;
const os = std.os; const posix = std.posix;
const assert = std.debug.assert; const assert = std.debug.assert;
const builtin = @import("builtin"); const builtin = @import("builtin");
@ -57,7 +57,7 @@ pub fn main() !void {
, .{}), , .{}),
error.ConnectFailed => { error.ConnectFailed => {
std.log.err("Unable to connect to the Wayland server.", .{}); std.log.err("Unable to connect to the Wayland server.", .{});
if (os.getenvZ("WAYLAND_DISPLAY") == null) { if (posix.getenvZ("WAYLAND_DISPLAY") == null) {
fatal("WAYLAND_DISPLAY is not set.", .{}); fatal("WAYLAND_DISPLAY is not set.", .{});
} else { } else {
fatal("Does WAYLAND_DISPLAY contain the socket name of a running server?", .{}); fatal("Does WAYLAND_DISPLAY contain the socket name of a running server?", .{});
@ -72,17 +72,17 @@ fn _main() !void {
const result = flags.parser([*:0]const u8, &.{ const result = flags.parser([*:0]const u8, &.{
.{ .name = "h", .kind = .boolean }, .{ .name = "h", .kind = .boolean },
.{ .name = "version", .kind = .boolean }, .{ .name = "version", .kind = .boolean },
}).parse(os.argv[1..]) catch { }).parse(std.os.argv[1..]) catch {
try io.getStdErr().writeAll(usage); try io.getStdErr().writeAll(usage);
os.exit(1); posix.exit(1);
}; };
if (result.flags.h) { if (result.flags.h) {
try io.getStdOut().writeAll(usage); try io.getStdOut().writeAll(usage);
os.exit(0); posix.exit(0);
} }
if (result.flags.version) { if (result.flags.version) {
try io.getStdOut().writeAll(@import("build_options").version ++ "\n"); try io.getStdOut().writeAll(@import("build_options").version ++ "\n");
os.exit(0); posix.exit(0);
} }
const display = try wl.Display.connect(null); const display = try wl.Display.connect(null);
@ -128,14 +128,14 @@ fn callbackListener(_: *zriver.CommandCallbackV1, event: zriver.CommandCallbackV
const stdout = io.getStdOut().writer(); const stdout = io.getStdOut().writer();
stdout.print("{s}\n", .{success.output}) catch @panic("failed to write to stdout"); stdout.print("{s}\n", .{success.output}) catch @panic("failed to write to stdout");
} }
os.exit(0); posix.exit(0);
}, },
.failure => |failure| { .failure => |failure| {
// A small hack to provide usage text when river reports an unknown command. // A small hack to provide usage text when river reports an unknown command.
if (mem.orderZ(u8, failure.failure_message, "unknown command") == .eq) { if (mem.orderZ(u8, failure.failure_message, "unknown command") == .eq) {
std.log.err("unknown command", .{}); std.log.err("unknown command", .{});
io.getStdErr().writeAll(usage) catch {}; io.getStdErr().writeAll(usage) catch {};
os.exit(1); posix.exit(1);
} }
fatal("{s}", .{failure.failure_message}); fatal("{s}", .{failure.failure_message});
}, },
@ -144,5 +144,5 @@ fn callbackListener(_: *zriver.CommandCallbackV1, event: zriver.CommandCallbackV
fn fatal(comptime format: []const u8, args: anytype) noreturn { fn fatal(comptime format: []const u8, args: anytype) noreturn {
std.log.err(format, args); std.log.err(format, args);
os.exit(1); posix.exit(1);
} }

16
rivertile/main.zig
View File

@ -39,7 +39,7 @@ const std = @import("std");
const fmt = std.fmt; const fmt = std.fmt;
const mem = std.mem; const mem = std.mem;
const math = std.math; const math = std.math;
const os = std.os; const posix = std.posix;
const assert = std.debug.assert; const assert = std.debug.assert;
const wayland = @import("wayland"); const wayland = @import("wayland");
@ -311,19 +311,19 @@ pub fn main() !void {
.{ .name = "main-location", .kind = .arg }, .{ .name = "main-location", .kind = .arg },
.{ .name = "main-count", .kind = .arg }, .{ .name = "main-count", .kind = .arg },
.{ .name = "main-ratio", .kind = .arg }, .{ .name = "main-ratio", .kind = .arg },
}).parse(os.argv[1..]) catch { }).parse(std.os.argv[1..]) catch {
try std.io.getStdErr().writeAll(usage); try std.io.getStdErr().writeAll(usage);
os.exit(1); posix.exit(1);
}; };
if (result.flags.h) { if (result.flags.h) {
try std.io.getStdOut().writeAll(usage); try std.io.getStdOut().writeAll(usage);
os.exit(0); posix.exit(0);
} }
if (result.args.len != 0) fatalPrintUsage("unknown option '{s}'", .{result.args[0]}); if (result.args.len != 0) fatalPrintUsage("unknown option '{s}'", .{result.args[0]});
if (result.flags.version) { if (result.flags.version) {
try std.io.getStdOut().writeAll(@import("build_options").version ++ "\n"); try std.io.getStdOut().writeAll(@import("build_options").version ++ "\n");
os.exit(0); posix.exit(0);
} }
if (result.flags.@"view-padding") |raw| { if (result.flags.@"view-padding") |raw| {
view_padding = fmt.parseUnsigned(u31, raw, 10) catch view_padding = fmt.parseUnsigned(u31, raw, 10) catch
@ -352,7 +352,7 @@ pub fn main() !void {
const display = wl.Display.connect(null) catch { const display = wl.Display.connect(null) catch {
std.debug.print("Unable to connect to Wayland server.\n", .{}); std.debug.print("Unable to connect to Wayland server.\n", .{});
os.exit(1); posix.exit(1);
}; };
defer display.disconnect(); defer display.disconnect();
@ -405,13 +405,13 @@ fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, context: *
fn fatal(comptime format: []const u8, args: anytype) noreturn { fn fatal(comptime format: []const u8, args: anytype) noreturn {
std.log.err(format, args); std.log.err(format, args);
os.exit(1); posix.exit(1);
} }
fn fatalPrintUsage(comptime format: []const u8, args: anytype) noreturn { fn fatalPrintUsage(comptime format: []const u8, args: anytype) noreturn {
std.log.err(format, args); std.log.err(format, args);
std.io.getStdErr().writeAll(usage) catch {}; std.io.getStdErr().writeAll(usage) catch {};
os.exit(1); posix.exit(1);
} }
fn saturatingCast(comptime T: type, x: anytype) T { fn saturatingCast(comptime T: type, x: anytype) T {