Nulo/river
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Implement keyboard interactivity for layer shell

Browse source
This commit is contained in:
Isaac Freund 2020-04-18 20:47:51 +02:00
parent 837513d329
commit 5244618b01
No known key found for this signature in database
GPG key ID: 86DED400DDFD7A11
2 changed files with 103 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
src/output.zig
View file

@ -228,27 +228,58 @@ pub const Output = struct {
// This box is modified as exclusive zones are applied
var usable_box = full_box;
const layers = [_]usize{
const layer_idxs = [_]usize{
c.ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
c.ZWLR_LAYER_SHELL_V1_LAYER_TOP,
c.ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM,
c.ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND,
};
for (layers) |layer| {
// Arrange all layer surfaces with exclusive zones, applying them to the
// usable box along the way.
for (layer_idxs) |layer| {
self.arrangeLayer(self.layers[layer], full_box, &usable_box, true);
}
if (self.usable_box.width != usable_box.width or self.usable_box.height != usable_box.height) {
// If the the usable_box has changed, we need to rearrange the output
if (!std.meta.eql(self.usable_box, usable_box)) {
self.usable_box = usable_box;
self.root.arrange();
}
for (layers) |layer| {
// Arrange the layers without exclusive zones
for (layer_idxs) |layer| {
self.arrangeLayer(self.layers[layer], full_box, &usable_box, false);
}
// TODO: handle seat focus
// If there is any layer surface in the top or overlay layers which requests
// keyboard interactivity, give it focus.
const topmost_surface = outer: for (layer_idxs[0..2]) |layer| {
// Iterate in reverse order since the last layer is rendered on top
var it = self.layers[layer].last;
while (it) |node| : (it = node.prev) {
const layer_surface = &node.data;
if (layer_surface.wlr_layer_surface.current.keyboard_interactive) {
break :outer layer_surface;
}
}
} else null;
var it = self.root.server.input_manager.seats.first;
while (it) |node| : (it = node.next) {
const seat = &node.data;
if (topmost_surface) |to_focus| {
// If we found a surface that requires focus, grab the focus of all
// seats.
seat.focusLayer(to_focus);
} else if (seat.focused_layer) |current_focus| {
// If the seat is currently focusing a layer without keyboard
// interactivity, clear the focused layer.
if (!current_focus.wlr_layer_surface.current.keyboard_interactive) {
seat.focusLayer(null);
}
}
}
}
/// Arrange the layer surfaces of a given layer

84
src/seat.zig
View file

@ -1,9 +1,10 @@
const std = @import("std");
const c = @import("c.zig");
const std = @import("std");
const Cursor = @import("cursor.zig").Cursor;
const InputManager = @import("input_manager.zig").InputManager;
const Keyboard = @import("keyboard.zig").Keyboard;
const LayerSurface = @import("layer_surface.zig").LayerSurface;
const Output = @import("output.zig").Output;
const View = @import("view.zig").View;
const ViewStack = @import("view_stack.zig").ViewStack;
@ -30,6 +31,10 @@ pub const Seat = struct {
/// If there is a currently focused view, it is on top.
focus_stack: ViewStack(*View),
/// Currently focused layer, if any. While this is non-null, no views may
/// recieve focus.
focused_layer: ?*LayerSurface,
pub fn init(self: *Self, input_manager: *InputManager, name: []const u8) !void {
self.input_manager = input_manager;
@ -47,6 +52,8 @@ pub const Seat = struct {
self.focused_view = null;
self.focus_stack.init();
self.focused_layer = null;
}
pub fn deinit(self: *Self) void {
@ -67,6 +74,12 @@ pub const Seat = struct {
pub fn focus(self: *Self, _view: ?*View) void {
var view = _view;
// While a layer surface is focused, views may not recieve focus
if (self.focused_layer != null) {
std.debug.assert(self.focused_view == null);
return;
}
// If view is null or not currently visible
if (if (view) |v|
v.output != self.focused_output or
@ -94,12 +107,12 @@ pub const Seat = struct {
current_focus.setActivated(false);
}
if (view) |to_focus| {
if (view) |view_to_focus| {
// Find or allocate a new node in the focus stack for the target view
var it = self.focus_stack.first;
while (it) |node| : (it = node.next) {
// If the view is found, move it to the top of the stack
if (node.view == to_focus) {
if (node.view == view_to_focus) {
const new_focus_node = self.focus_stack.remove(node);
self.focus_stack.push(node);
break;
@ -109,29 +122,66 @@ pub const Seat = struct {
const new_focus_node = self.input_manager.server.allocator.create(
ViewStack(*View).Node,
) catch unreachable;
new_focus_node.view = to_focus;
new_focus_node.view = view_to_focus;
self.focus_stack.push(new_focus_node);
}
// The target view is now at the top of the focus stack, so activate it
to_focus.setActivated(true);
// Tell the seat to have the keyboard enter this surface. wlroots will keep
// track of this and automatically send key events to the appropriate
// clients without additional work on your part.
const keyboard: *c.wlr_keyboard = c.wlr_seat_get_keyboard(self.wlr_seat);
c.wlr_seat_keyboard_notify_enter(
self.wlr_seat,
to_focus.wlr_xdg_surface.surface,
&keyboard.keycodes,
keyboard.num_keycodes,
&keyboard.modifiers,
);
view_to_focus.setActivated(true);
self.sendKeyboardEnter(view_to_focus.wlr_xdg_surface.surface);
}
self.focused_view = view;
}
/// Set the focus to the passed layer surface, or clear the focused layer
/// if the argument is null.
pub fn focusLayer(self: *Self, layer_surface: ?*LayerSurface) void {
if (layer_surface) |layer_to_focus| {
// If the layer is already focused, don't re-focus it.
if (self.focused_layer) |current_focus| {
if (current_focus == layer_to_focus) {
std.debug.assert(self.focused_view == null);
return;
}
}
// If a view is currently focused, unfocus it
if (self.focused_view) |current_focus| {
current_focus.setActivated(false);
self.focused_view = null;
}
// Focus the layer surface
self.sendKeyboardEnter(layer_to_focus.wlr_layer_surface.surface);
self.focused_layer = layer_to_focus;
self.focused_output = layer_to_focus.output;
} else {
// If there is a layer currently focused, unfocus it
if (self.focused_layer != null) {
std.debug.assert(self.focused_view == null);
self.focused_layer = null;
}
// Then focus the view on the top of the focus stack if any
self.focus(null);
}
}
/// Tell the seat to have the keyboard enter this surface. wlroots will keep
/// track of this and automatically send key events to the appropriate
/// clients.
fn sendKeyboardEnter(self: Self, wlr_surface: *c.wlr_surface) void {
const keyboard: *c.wlr_keyboard = c.wlr_seat_get_keyboard(self.wlr_seat);
c.wlr_seat_keyboard_notify_enter(
self.wlr_seat,
wlr_surface,
&keyboard.keycodes,
keyboard.num_keycodes,
&keyboard.modifiers,
);
}
/// Handle the unmapping of a view, removing it from the focus stack and
/// setting the focus if needed.
pub fn handleViewUnmap(self: *Self, view: *View) void {