LayerSurface: render using the scene graph

This also brings a lot of code cleanup and proper support for
version 4 of the protocol.

river/Cursor.zig

@@ -357,7 +357,7 @@ fn updateKeyboardFocus(self: Self, result: Root.AtResult) void {
             self.seat.focusOutput(layer_surface.output);
             // If a keyboard inteactive layer surface has been clicked on,
             // give it keyboard focus.
-            if (layer_surface.wlr_layer_surface.current.keyboard_interactive == .exclusive) {
+            if (layer_surface.scene_layer_surface.layer_surface.current.keyboard_interactive != .none) {
                 self.seat.setFocusRaw(.{ .layer = layer_surface });
             } else {
                 self.seat.focus(null);

river/LayerSurface.zig

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-const Self = @This();
+const LayerSurface = @This();
 
 const std = @import("std");
 const assert = std.debug.assert;
@@ -26,125 +26,140 @@ const server = &@import("main.zig").server;
 const util = @import("util.zig");
 
 const Output = @import("Output.zig");
+const SceneNodeData = @import("SceneNodeData.zig");
 
 const log = std.log.scoped(.layer_shell);
 
 output: *Output,
-wlr_layer_surface: *wlr.LayerSurfaceV1,
+scene_layer_surface: *wlr.SceneLayerSurfaceV1,
-
-box: wlr.Box = undefined,
-layer: zwlr.LayerShellV1.Layer,
 
 destroy: wl.Listener(*wlr.LayerSurfaceV1) = wl.Listener(*wlr.LayerSurfaceV1).init(handleDestroy),
 map: wl.Listener(*wlr.LayerSurfaceV1) = wl.Listener(*wlr.LayerSurfaceV1).init(handleMap),
 unmap: wl.Listener(*wlr.LayerSurfaceV1) = wl.Listener(*wlr.LayerSurfaceV1).init(handleUnmap),
 commit: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleCommit),
 
-pub fn init(self: *Self, output: *Output, wlr_layer_surface: *wlr.LayerSurfaceV1) void {
+pub fn create(wlr_layer_surface: *wlr.LayerSurfaceV1) error{OutOfMemory}!void {
-    self.* = .{
+    const output = @intToPtr(*Output, wlr_layer_surface.output.?.data);
-        .output = output,
+    const layer_surface = try util.gpa.create(LayerSurface);
-        .wlr_layer_surface = wlr_layer_surface,
+    errdefer util.gpa.destroy(layer_surface);
-        .layer = wlr_layer_surface.current.layer,
-    };
-    wlr_layer_surface.data = @ptrToInt(self);
 
-    // Set up listeners that are active for the entire lifetime of the layer surface
+    const tree = output.layerSurfaceTree(wlr_layer_surface.current.layer);
-    wlr_layer_surface.events.destroy.add(&self.destroy);
+    const scene_layer_surface = try tree.createSceneLayerSurfaceV1(wlr_layer_surface);
-    wlr_layer_surface.events.map.add(&self.map);
+
-    wlr_layer_surface.events.unmap.add(&self.unmap);
+    try SceneNodeData.attach(&scene_layer_surface.tree.node, .{ .layer_surface = layer_surface });
-    wlr_layer_surface.surface.events.commit.add(&self.commit);
+
+    layer_surface.* = .{
+        .output = output,
+        .scene_layer_surface = scene_layer_surface,
+    };
+    wlr_layer_surface.data = @ptrToInt(layer_surface);
+
+    wlr_layer_surface.events.destroy.add(&layer_surface.destroy);
+    wlr_layer_surface.events.map.add(&layer_surface.map);
+    wlr_layer_surface.events.unmap.add(&layer_surface.unmap);
+    wlr_layer_surface.surface.events.commit.add(&layer_surface.commit);
 
     // wlroots only informs us of the new surface after the first commit,
     // so our listener does not get called for this first commit. However,
     // we do want our listener called in order to send the initial configure.
-    handleCommit(&self.commit, wlr_layer_surface.surface);
+    handleCommit(&layer_surface.commit, wlr_layer_surface.surface);
 }
 
-fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfaceV1) void {
+fn handleDestroy(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void {
-    const self = @fieldParentPtr(Self, "destroy", listener);
+    const layer_surface = @fieldParentPtr(LayerSurface, "destroy", listener);
 
-    log.debug("layer surface '{s}' destroyed", .{self.wlr_layer_surface.namespace});
+    log.debug("layer surface '{s}' destroyed", .{wlr_layer_surface.namespace});
 
-    // Remove listeners active the entire lifetime of the layer surface
+    layer_surface.destroy.link.remove();
-    self.destroy.link.remove();
+    layer_surface.map.link.remove();
-    self.map.link.remove();
+    layer_surface.unmap.link.remove();
-    self.unmap.link.remove();
+    layer_surface.commit.link.remove();
-    self.commit.link.remove();
 
-    const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
+    util.gpa.destroy(layer_surface);
-    util.gpa.destroy(node);
 }
 
 fn handleMap(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void {
-    const self = @fieldParentPtr(Self, "map", listener);
+    const layer_surface = @fieldParentPtr(LayerSurface, "map", listener);
 
     log.debug("layer surface '{s}' mapped", .{wlr_layer_surface.namespace});
 
-    wlr_layer_surface.surface.sendEnter(wlr_layer_surface.output.?);
+    layer_surface.output.arrangeLayers();
-
+    handleKeyboardInteractiveExclusive(layer_surface.output);
-    const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
-    self.output.getLayer(self.layer).append(node);
-    self.output.arrangeLayers(.mapped);
     server.root.startTransaction();
 }
 
-fn handleUnmap(listener: *wl.Listener(*wlr.LayerSurfaceV1), _: *wlr.LayerSurfaceV1) void {
+fn handleUnmap(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void {
-    const self = @fieldParentPtr(Self, "unmap", listener);
+    const layer_surface = @fieldParentPtr(LayerSurface, "unmap", listener);
 
-    log.debug("layer surface '{s}' unmapped", .{self.wlr_layer_surface.namespace});
+    log.debug("layer surface '{s}' unmapped", .{wlr_layer_surface.namespace});
-
-    // Remove from the output's list of layer surfaces
-    const self_node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
-    self.output.layer_surfaces[@intCast(usize, @enumToInt(self.layer))].remove(self_node);
-
-    // If the unmapped surface is focused, clear focus
-    var it = server.input_manager.seats.first;
-    while (it) |node| : (it = node.next) {
-        const seat = &node.data;
-        if (seat.focused == .layer and seat.focused.layer == self)
-            seat.setFocusRaw(.{ .none = {} });
-    }
-
-    // This gives exclusive focus to a keyboard interactive top or overlay layer
-    // surface if there is one.
-    self.output.arrangeLayers(.mapped);
-
-    // Ensure that focus is given to the appropriate view if there is no
-    // other top/overlay layer surface to grab focus.
-    it = server.input_manager.seats.first;
-    while (it) |node| : (it = node.next) {
-        const seat = &node.data;
-        seat.focus(null);
-    }
 
+    layer_surface.output.arrangeLayers();
+    handleKeyboardInteractiveExclusive(layer_surface.output);
     server.root.startTransaction();
 }
 
 fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
-    const self = @fieldParentPtr(Self, "commit", listener);
+    const layer_surface = @fieldParentPtr(LayerSurface, "commit", listener);
+    const wlr_layer_surface = layer_surface.scene_layer_surface.layer_surface;
 
-    assert(self.wlr_layer_surface.output != null);
+    assert(wlr_layer_surface.output != null);
 
-    // If a surface is committed while it is not mapped, we may need to send a configure.
+    // If the layer was changed, move the LayerSurface to the proper tree.
-    if (!self.wlr_layer_surface.mapped) {
+    if (wlr_layer_surface.current.committed.layer) {
-        const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
+        const tree = layer_surface.output.layerSurfaceTree(wlr_layer_surface.current.layer);
-        self.layer = self.wlr_layer_surface.current.layer;
+        layer_surface.scene_layer_surface.tree.node.reparent(tree);
-        self.output.getLayer(self.layer).append(node);
-        self.output.arrangeLayers(.unmapped);
-        self.output.getLayer(self.layer).remove(node);
-        return;
     }
 
-    if (@bitCast(u32, self.wlr_layer_surface.current.committed) != 0) {
+    // If a surface is committed while it is not mapped, we must send a configure.
-        // If the layer changed, move the LayerSurface to the proper list
+    if (!wlr_layer_surface.mapped or @bitCast(u32, wlr_layer_surface.current.committed) != 0) {
-        if (self.wlr_layer_surface.current.layer != self.layer) {
+        layer_surface.output.arrangeLayers();
-            const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
+        handleKeyboardInteractiveExclusive(layer_surface.output);
-            self.output.getLayer(self.layer).remove(node);
-            self.layer = self.wlr_layer_surface.current.layer;
-            self.output.getLayer(self.layer).append(node);
-        }
-
-        self.output.arrangeLayers(.mapped);
         server.root.startTransaction();
     }
 }
+
+fn handleKeyboardInteractiveExclusive(output: *Output) void {
+    if (server.lock_manager.state != .unlocked) return;
+
+    // Find the topmost layer surface in the top or overlay layers which
+    // requests keyboard interactivity if any.
+    const topmost_surface = outer: for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top }) |layer| {
+        const tree = output.layerSurfaceTree(layer);
+        // Iterate in reverse to match rendering order.
+        var it = tree.children.iterator(.reverse);
+        while (it.next()) |node| {
+            assert(node.type == .tree);
+            if (@intToPtr(?*SceneNodeData, node.data)) |node_data| {
+                const layer_surface = node_data.data.layer_surface;
+                const wlr_layer_surface = layer_surface.scene_layer_surface.layer_surface;
+                if (wlr_layer_surface.mapped and
+                    wlr_layer_surface.current.keyboard_interactive == .exclusive)
+                {
+                    break :outer layer_surface;
+                }
+            }
+        }
+    } else null;
+
+    var it = server.input_manager.seats.first;
+    while (it) |node| : (it = node.next) {
+        const seat = &node.data;
+
+        // Only grab focus of seats which have the output focused
+        if (seat.focused_output != output) continue;
+
+        if (topmost_surface) |to_focus| {
+            // If we found a surface that requires focus, grab the focus of all
+            // seats.
+            seat.setFocusRaw(.{ .layer = to_focus });
+        } else if (seat.focused == .layer) {
+            const current_focus = seat.focused.layer.scene_layer_surface.layer_surface;
+            // If the seat is currently focusing an unmapped layer surface or one
+            // without keyboard interactivity, stop focusing that layer surface.
+            if (!current_focus.mapped or current_focus.current.keyboard_interactive == .none) {
+                seat.setFocusRaw(.{ .none = {} });
+                seat.focus(null);
+            }
+        }
+    }
+}

river/Output.zig

@@ -34,9 +34,10 @@ const LayerSurface = @import("LayerSurface.zig");
 const Layout = @import("Layout.zig");
 const LayoutDemand = @import("LayoutDemand.zig");
 const LockSurface = @import("LockSurface.zig");
+const OutputStatus = @import("OutputStatus.zig");
+const SceneNodeData = @import("SceneNodeData.zig");
 const View = @import("View.zig");
 const ViewStack = @import("view_stack.zig").ViewStack;
-const OutputStatus = @import("OutputStatus.zig");
 
 const State = struct {
     /// A bit field of focused tags
@@ -56,9 +57,6 @@ const State = struct {
 
 wlr_output: *wlr.Output,
 
-/// All layer surfaces on the output, indexed by the layer enum.
-layer_surfaces: [4]std.TailQueue(LayerSurface) = [1]std.TailQueue(LayerSurface){.{}} ** 4,
-
 /// The area left for views and other layer surfaces after applying the
 /// exclusive zones of exclusive layer surfaces.
 /// TODO: this should be part of the output's State
@@ -226,8 +224,14 @@ pub fn create(wlr_output: *wlr.Output) !void {
     handleEnable(&self.enable, self.wlr_output);
 }
 
-pub fn getLayer(self: *Self, layer: zwlr.LayerShellV1.Layer) *std.TailQueue(LayerSurface) {
+pub fn layerSurfaceTree(self: Self, layer: zwlr.LayerShellV1.Layer) *wlr.SceneTree {
-    return &self.layer_surfaces[@intCast(usize, @enumToInt(layer))];
+    const trees = [_]*wlr.SceneTree{
+        self.layers.background,
+        self.layers.bottom,
+        self.layers.top,
+        self.layers.overlay,
+    };
+    return trees[@intCast(usize, @enumToInt(layer))];
 }
 
 pub fn sendViewTags(self: Self) void {
@@ -305,13 +309,9 @@ pub fn arrangeViews(self: *Self) void {
     }
 }
 
-const ArrangeLayersTarget = enum { mapped, unmapped };
-
 /// Arrange all layer surfaces of this output and adjust the usable area.
 /// Will arrange views as well if the usable area changes.
-/// If target is unmapped, this function is pure aside from the
+pub fn arrangeLayers(self: *Self) void {
-/// wlr.LayerSurfaceV1.configure() calls made on umapped layer surfaces.
-pub fn arrangeLayers(self: *Self, target: ArrangeLayersTarget) void {
     var full_box: wlr.Box = .{
         .x = 0,
         .y = 0,
@@ -323,186 +323,22 @@ pub fn arrangeLayers(self: *Self, target: ArrangeLayersTarget) void {
     // This box is modified as exclusive zones are applied
     var usable_box = full_box;
 
-    const layers = [_]zwlr.LayerShellV1.Layer{ .overlay, .top, .bottom, .background };
+    for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top, .bottom, .background }) |layer| {
-
+        const tree = self.layerSurfaceTree(layer);
-    // Arrange all layer surfaces with exclusive zones, applying them to the
+        var it = tree.children.iterator(.forward);
-    // usable box along the way.
+        while (it.next()) |node| {
-    for (layers) |layer| arrangeLayer(self.getLayer(layer).*, full_box, &usable_box, true, target);
+            assert(node.type == .tree);
+            if (@intToPtr(?*SceneNodeData, node.data)) |node_data| {
+                node_data.data.layer_surface.scene_layer_surface.configure(&full_box, &usable_box);
+            }
+        }
+    }
 
     // If the the usable_box has changed, we need to rearrange the output
-    if (target == .mapped and !std.meta.eql(self.usable_box, usable_box)) {
+    if (!std.meta.eql(self.usable_box, usable_box)) {
         self.usable_box = usable_box;
         self.arrangeViews();
     }
-
-    // Arrange the layers without exclusive zones
-    for (layers) |layer| arrangeLayer(self.getLayer(layer).*, full_box, &usable_box, false, target);
-
-    if (target == .unmapped) return;
-
-    if (server.lock_manager.state != .unlocked) return;
-
-    // Find the topmost layer surface in the top or overlay layers which
-    // requests keyboard interactivity if any.
-    const topmost_surface = outer: for (layers[0..2]) |layer| {
-        // Iterate in reverse order since the last layer is rendered on top
-        var it = self.getLayer(layer).last;
-        while (it) |node| : (it = node.prev) {
-            const layer_surface = &node.data;
-            if (layer_surface.wlr_layer_surface.current.keyboard_interactive == .exclusive) {
-                break :outer layer_surface;
-            }
-        }
-    } else null;
-
-    var it = server.input_manager.seats.first;
-    while (it) |node| : (it = node.next) {
-        const seat = &node.data;
-
-        // Only grab focus of seats which have the output focused
-        if (seat.focused_output != self) continue;
-
-        if (topmost_surface) |to_focus| {
-            // If we found a surface that requires focus, grab the focus of all
-            // seats.
-            seat.setFocusRaw(.{ .layer = to_focus });
-        } else if (seat.focused == .layer) {
-            // If the seat is currently focusing a layer without keyboard
-            // interactivity, stop focusing that layer.
-            if (seat.focused.layer.wlr_layer_surface.current.keyboard_interactive != .exclusive) {
-                seat.setFocusRaw(.{ .none = {} });
-                seat.focus(null);
-            }
-        }
-    }
-}
-
-/// Arrange the layer surfaces of a given layer
-fn arrangeLayer(
-    layer: std.TailQueue(LayerSurface),
-    full_box: wlr.Box,
-    usable_box: *wlr.Box,
-    exclusive: bool,
-    target: ArrangeLayersTarget,
-) void {
-    var it = layer.first;
-    while (it) |node| : (it = node.next) {
-        const layer_surface = &node.data;
-        const current_state = layer_surface.wlr_layer_surface.current;
-
-        const desired_width = @intCast(u31, math.min(math.maxInt(u31), current_state.desired_width));
-        const desired_height = @intCast(u31, math.min(math.maxInt(u31), current_state.desired_height));
-
-        // If the value of exclusive_zone is greater than zero, then it exclusivly
-        // occupies some area of the screen.
-        if (exclusive != (current_state.exclusive_zone > 0)) continue;
-
-        // If the exclusive zone is set to -1, this means the the client would like
-        // to ignore any exclusive zones and use the full area of the output.
-        const bounds = if (current_state.exclusive_zone == -1) &full_box else usable_box;
-
-        var new_box: wlr.Box = undefined;
-
-        // Horizontal alignment
-        if (desired_width == 0) {
-            assert(current_state.anchor.right and current_state.anchor.left);
-            new_box.x = bounds.x + current_state.margin.left;
-            new_box.width = bounds.width - (current_state.margin.left + current_state.margin.right);
-        } else if (current_state.anchor.left == current_state.anchor.right) {
-            new_box.x = bounds.x + @divTrunc(bounds.width, 2) - desired_width / 2;
-            new_box.width = desired_width;
-        } else if (current_state.anchor.left) {
-            new_box.x = bounds.x + current_state.margin.left;
-            new_box.width = desired_width;
-        } else {
-            assert(current_state.anchor.right);
-            new_box.x = bounds.x + bounds.width - desired_width - current_state.margin.right;
-            new_box.width = desired_width;
-        }
-
-        // Vertical alignment
-        if (desired_height == 0) {
-            assert(current_state.anchor.top and current_state.anchor.bottom);
-            new_box.y = bounds.y + current_state.margin.top;
-            new_box.height = bounds.height - (current_state.margin.top + current_state.margin.bottom);
-        } else if (current_state.anchor.top == current_state.anchor.bottom) {
-            new_box.y = bounds.y + @divTrunc(bounds.height, 2) - desired_height / 2;
-            new_box.height = desired_height;
-        } else if (current_state.anchor.top) {
-            new_box.y = bounds.y + current_state.margin.top;
-            new_box.height = desired_height;
-        } else {
-            assert(current_state.anchor.bottom);
-            new_box.y = bounds.y + bounds.height - desired_height - current_state.margin.bottom;
-            new_box.height = desired_height;
-        }
-
-        // Apply the exclusive zone to the current bounds
-        const edges = [4]struct {
-            single: zwlr.LayerSurfaceV1.Anchor,
-            triple: zwlr.LayerSurfaceV1.Anchor,
-            to_increase: ?*i32,
-            to_decrease: *i32,
-            margin: i32,
-        }{
-            .{
-                .single = .{ .top = true },
-                .triple = .{ .top = true, .left = true, .right = true },
-                .to_increase = &usable_box.y,
-                .to_decrease = &usable_box.height,
-                .margin = current_state.margin.top,
-            },
-            .{
-                .single = .{ .bottom = true },
-                .triple = .{ .bottom = true, .left = true, .right = true },
-                .to_increase = null,
-                .to_decrease = &usable_box.height,
-                .margin = current_state.margin.bottom,
-            },
-            .{
-                .single = .{ .left = true },
-                .triple = .{ .left = true, .top = true, .bottom = true },
-                .to_increase = &usable_box.x,
-                .to_decrease = &usable_box.width,
-                .margin = current_state.margin.left,
-            },
-            .{
-                .single = .{ .right = true },
-                .triple = .{ .right = true, .top = true, .bottom = true },
-                .to_increase = null,
-                .to_decrease = &usable_box.width,
-                .margin = current_state.margin.right,
-            },
-        };
-
-        for (edges) |edge| {
-            if ((std.meta.eql(current_state.anchor, edge.single) or std.meta.eql(current_state.anchor, edge.triple)) and
-                current_state.exclusive_zone + edge.margin > 0)
-            {
-                const delta = current_state.exclusive_zone + edge.margin;
-                if (edge.to_increase) |value| value.* += delta;
-                edge.to_decrease.* -= delta;
-                break;
-            }
-        }
-
-        switch (target) {
-            .mapped => {
-                assert(layer_surface.wlr_layer_surface.mapped);
-                layer_surface.box = new_box;
-                _ = layer_surface.wlr_layer_surface.configure(
-                    @intCast(u32, new_box.width),
-                    @intCast(u32, new_box.height),
-                );
-            },
-            .unmapped => if (!layer_surface.wlr_layer_surface.mapped) {
-                _ = layer_surface.wlr_layer_surface.configure(
-                    @intCast(u32, new_box.width),
-                    @intCast(u32, new_box.height),
-                );
-            },
-        }
-    }
 }
 
 fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
@@ -513,7 +349,6 @@ fn handleDestroy(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
     // Remove the destroyed output from root if it wasn't already removed
     server.root.removeOutput(self);
     assert(self.views.first == null and self.views.last == null);
-    for (self.layer_surfaces) |layer| assert(layer.len == 0);
     assert(self.layouts.len == 0);
 
     var it = server.root.all_outputs.first;
@@ -588,8 +423,7 @@ fn handleMode(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
         background_color_rect.setSize(width, height);
     }
 
-    self.arrangeLayers(.mapped);
+    self.arrangeLayers();
-    self.arrangeViews();
     server.root.startTransaction();
 }
 

river/Root.zig

@@ -22,6 +22,7 @@ const assert = std.debug.assert;
 const mem = std.mem;
 const wlr = @import("wlroots");
 const wl = @import("wayland").server.wl;
+const zwlr = @import("wayland").server.zwlr;
 
 const server = &@import("main.zig").server;
 const util = @import("util.zig");
@@ -178,6 +179,7 @@ pub fn at(self: Self, lx: f64, ly: f64) ?AtResult {
                     .sy = sy,
                     .node = switch (scene_node_data.data) {
                         .view => |view| .{ .view = view },
+                        .layer_surface => |layer_surface| .{ .layer_surface = layer_surface },
                         .lock_surface => |lock_surface| .{ .lock_surface = lock_surface },
                     },
                 };
@@ -235,9 +237,15 @@ pub fn removeOutput(self: *Self, output: *Output) void {
     }
 
     // Close all layer surfaces on the removed output
-    for (output.layer_surfaces) |*layer| {
+    for ([_]zwlr.LayerShellV1.Layer{ .overlay, .top, .bottom, .background }) |layer| {
-        // Destroying the layer surface will cause it to be removed from this list.
+        const tree = output.layerSurfaceTree(layer);
-        while (layer.first) |layer_node| layer_node.data.wlr_layer_surface.destroy();
+        var it = tree.children.safeIterator(.forward);
+        while (it.next()) |scene_node| {
+            assert(scene_node.type == .tree);
+            if (@intToPtr(?*SceneNodeData, scene_node.data)) |node_data| {
+                node_data.data.layer_surface.scene_layer_surface.layer_surface.destroy();
+            }
+        }
     }
 
     // If any seat has the removed output focused, focus the fallback one
@@ -534,7 +542,7 @@ fn processOutputConfig(
                         self.output_layout.add(output.wlr_output, head.state.x, head.state.y);
                         output.tree.node.setEnabled(true);
                         output.tree.node.setPosition(head.state.x, head.state.y);
-                        output.arrangeLayers(.mapped);
+                        output.arrangeLayers();
                     } else {
                         self.removeOutput(output);
                         self.output_layout.remove(output.wlr_output);

river/SceneNodeData.zig

@@ -22,12 +22,14 @@ const wl = @import("wayland").server.wl;
 
 const util = @import("util.zig");
 
+const LayerSurface = @import("LayerSurface.zig");
 const LockSurface = @import("LockSurface.zig");
 const View = @import("View.zig");
 
 const Data = union(enum) {
     view: *View,
     lock_surface: *LockSurface,
+    layer_surface: *LayerSurface,
 };
 
 node: *wlr.SceneNode,

river/Seat.zig

@@ -157,8 +157,15 @@ pub fn focus(self: *Self, _target: ?*View) void {
     // Views may not recieve focus while locked.
     if (server.lock_manager.state != .unlocked) return;
 
-    // While a layer surface is focused, views may not recieve focus
+    // While a layer surface is exclusively focused, views may not recieve focus
-    if (self.focused == .layer) return;
+    if (self.focused == .layer) {
+        const wlr_layer_surface = self.focused.layer.scene_layer_surface.layer_surface;
+        if (wlr_layer_surface.current.keyboard_interactive == .exclusive and
+            (wlr_layer_surface.current.layer == .top or wlr_layer_surface.current.layer == .overlay))
+        {
+            return;
+        }
+    }
 
     if (target) |view| {
         // If the view is not currently visible, behave as if null was passed
@@ -224,7 +231,7 @@ pub fn setFocusRaw(self: *Self, new_focus: FocusTarget) void {
     const target_surface = switch (new_focus) {
         .view => |target_view| target_view.rootSurface(),
         .xwayland_override_redirect => |target_or| target_or.xwayland_surface.surface,
-        .layer => |target_layer| target_layer.wlr_layer_surface.surface,
+        .layer => |target_layer| target_layer.scene_layer_surface.layer_surface.surface,
         .lock_surface => |lock_surface| lock_surface.wlr_lock_surface.surface,
         .none => null,
     };

river/Server.zig

@@ -198,7 +198,6 @@ fn handleNewXdgSurface(listener: *wl.Listener(*wlr.XdgSurface), xdg_surface: *wl
     };
 }
 
-/// This event is raised when the layer_shell recieves a new surface from a client.
 fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_surface: *wlr.LayerSurfaceV1) void {
     const self = @fieldParentPtr(Self, "new_layer_surface", listener);
 
@@ -206,15 +205,15 @@ fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_
         "new layer surface: namespace {s}, layer {s}, anchor {b:0>4}, size {},{}, margin {},{},{},{}, exclusive_zone {}",
         .{
             wlr_layer_surface.namespace,
-            @tagName(wlr_layer_surface.pending.layer),
+            @tagName(wlr_layer_surface.current.layer),
-            @bitCast(u32, wlr_layer_surface.pending.anchor),
+            @bitCast(u32, wlr_layer_surface.current.anchor),
-            wlr_layer_surface.pending.desired_width,
+            wlr_layer_surface.current.desired_width,
-            wlr_layer_surface.pending.desired_height,
+            wlr_layer_surface.current.desired_height,
-            wlr_layer_surface.pending.margin.top,
+            wlr_layer_surface.current.margin.top,
-            wlr_layer_surface.pending.margin.right,
+            wlr_layer_surface.current.margin.right,
-            wlr_layer_surface.pending.margin.bottom,
+            wlr_layer_surface.current.margin.bottom,
-            wlr_layer_surface.pending.margin.left,
+            wlr_layer_surface.current.margin.left,
-            wlr_layer_surface.pending.exclusive_zone,
+            wlr_layer_surface.current.exclusive_zone,
         },
     );
 
@@ -232,13 +231,10 @@ fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_
         wlr_layer_surface.output = output.wlr_output;
     }
 
-    // The layer surface will add itself to the proper list of the output on map
+    LayerSurface.create(wlr_layer_surface) catch {
-    const output = @intToPtr(*Output, wlr_layer_surface.output.?.data);
-    const node = util.gpa.create(std.TailQueue(LayerSurface).Node) catch {
         wlr_layer_surface.resource.postNoMemory();
         return;
     };
-    node.data.init(output, wlr_layer_surface);
 }
 
 fn handleNewXwaylandSurface(listener: *wl.Listener(*wlr.XwaylandSurface), xwayland_surface: *wlr.XwaylandSurface) void {