From c959a426b723fb89f1dda34893d426b90f8fa9f4 Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Sun, 19 Apr 2020 00:59:07 +0200 Subject: [PATCH] Implement wlr-input-inhibitor --- src/c.zig | 1 + src/input_manager.zig | 68 ++++++++++++++++++++++++- src/output.zig | 5 +- src/render.zig | 2 +- src/seat.zig | 115 +++++++++++++++++++++++------------------- 5 files changed, 135 insertions(+), 56 deletions(-) diff --git a/src/c.zig b/src/c.zig index 7cc0fce..d2080d2 100644 --- a/src/c.zig +++ b/src/c.zig @@ -10,6 +10,7 @@ pub usingnamespace @cImport({ @cInclude("wlr/types/wlr_cursor.h"); @cInclude("wlr/types/wlr_data_device.h"); @cInclude("wlr/types/wlr_input_device.h"); + @cInclude("wlr/types/wlr_input_inhibitor.h"); @cInclude("wlr/types/wlr_keyboard.h"); @cInclude("wlr/types/wlr_layer_shell_v1.h"); @cInclude("wlr/types/wlr_matrix.h"); diff --git a/src/input_manager.zig b/src/input_manager.zig index d2c11db..8cb0aa6 100644 --- a/src/input_manager.zig +++ b/src/input_manager.zig @@ -11,14 +11,25 @@ pub const InputManager = struct { server: *Server, + wlr_input_inhibit_manager: *c.wlr_input_inhibit_manager, + seats: std.TailQueue(Seat), default_seat: *Seat, + exclusive_client: ?*c.wl_client, + + listen_inhibit_activate: c.wl_listener, + listen_inhibit_deactivate: c.wl_listener, listen_new_input: c.wl_listener, pub fn init(self: *Self, server: *Server) !void { self.server = server; + // This is automatically freed when the display is destroyed + self.wlr_input_inhibit_manager = + c.wlr_input_inhibit_manager_create(server.wl_display) orelse + return error.CantCreateInputInhibitManager; + self.seats = std.TailQueue(Seat).init(); const seat_node = try server.allocator.create(std.TailQueue(Seat).Node); @@ -26,8 +37,21 @@ pub const InputManager = struct { self.default_seat = &seat_node.data; self.seats.prepend(seat_node); - // Set up handler for all new input devices made available. This - // includes keyboards, pointers, touch, etc. + self.exclusive_client = null; + + // Set up all listeners + self.listen_inhibit_activate.notify = handleInhibitActivate; + c.wl_signal_add( + &self.wlr_input_inhibit_manager.events.activate, + &self.listen_inhibit_activate, + ); + + self.listen_inhibit_deactivate.notify = handleInhibitDeactivate; + c.wl_signal_add( + &self.wlr_input_inhibit_manager.events.deactivate, + &self.listen_inhibit_deactivate, + ); + self.listen_new_input.notify = handleNewInput; c.wl_signal_add(&self.server.wlr_backend.events.new_input, &self.listen_new_input); } @@ -48,6 +72,46 @@ pub const InputManager = struct { } } + /// Returns true if input is currently allowed on the passed surface. + pub fn inputAllowed(self: Self, wlr_surface: *c.wlr_surface) bool { + return if (self.exclusive_client) |exclusive_client| + exclusive_client == c.wl_resource_get_client(wlr_surface.resource) + else + true; + } + + fn handleInhibitActivate(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { + const self = @fieldParentPtr(Self, "listen_inhibit_activate", listener.?); + + // Clear focus of all seats + var seat_it = self.seats.first; + while (seat_it) |seat_node| : (seat_it = seat_node.next) { + seat_node.data.setFocusRaw(.{ .none = {} }); + } + + self.exclusive_client = self.wlr_input_inhibit_manager.active_client; + } + + fn handleInhibitDeactivate(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { + const self = @fieldParentPtr(Self, "listen_inhibit_deactivate", listener.?); + + self.exclusive_client = null; + + // Calling arrangeLayers() like this ensures that any top or overlay, + // keyboard-interactive surfaces will re-grab focus. + var output_it = self.server.root.outputs.first; + while (output_it) |output_node| : (output_it = output_node.next) { + output_node.data.arrangeLayers(); + } + + // After ensuring that any possible layer surface focus grab has occured, + // have each Seat handle focus. + var seat_it = self.seats.first; + while (seat_it) |seat_node| : (seat_it = seat_node.next) { + seat_node.data.focus(null); + } + } + /// This event is raised by the backend when a new input device becomes available. fn handleNewInput(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { const input_manager = @fieldParentPtr(InputManager, "listen_new_input", listener.?); diff --git a/src/output.zig b/src/output.zig index 3475f8c..fa09b07 100644 --- a/src/output.zig +++ b/src/output.zig @@ -277,12 +277,13 @@ pub const Output = struct { if (topmost_surface) |to_focus| { // If we found a surface that requires focus, grab the focus of all // seats. - seat.focusLayer(to_focus); + seat.setFocusRaw(.{ .layer = 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); + seat.setFocusRaw(.{ .none = {} }); + seat.focus(null); } } } diff --git a/src/render.zig b/src/render.zig index e9c6089..e938bfb 100644 --- a/src/render.zig +++ b/src/render.zig @@ -242,7 +242,7 @@ fn renderSurface(_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void fn renderBorders(output: Output, view: *View, now: *c.struct_timespec) void { var border: c.wlr_box = undefined; - const color = if (view.wlr_xdg_surface.unnamed_163.toplevel.*.current.activated) + const color = if (view.wlr_xdg_surface.unnamed_164.toplevel.*.current.activated) [_]f32{ 0.57647059, 0.63137255, 0.63137255, 1.0 } // Solarized base1 else [_]f32{ 0.34509804, 0.43137255, 0.45882353, 1.0 }; // Solarized base01 diff --git a/src/seat.zig b/src/seat.zig index cb107fc..6b7539e 100644 --- a/src/seat.zig +++ b/src/seat.zig @@ -9,6 +9,12 @@ const Output = @import("output.zig").Output; const View = @import("view.zig").View; const ViewStack = @import("view_stack.zig").ViewStack; +const FocusTarget = union(enum) { + view: *View, + layer: *LayerSurface, + none: void, +}; + pub const Seat = struct { const Self = @This(); @@ -98,15 +104,6 @@ pub const Seat = struct { } else null; } - if (self.focused_view) |current_focus| { - // Don't refocus the currently focused view - if (if (view) |v| current_focus == v else false) { - return; - } - // Deactivate the currently focused view - current_focus.setActivated(false); - } - 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; @@ -126,62 +123,78 @@ pub const Seat = struct { self.focus_stack.push(new_focus_node); } - // The target view is now at the top of the focus stack, so activate it - view_to_focus.setActivated(true); - self.sendKeyboardEnter(view_to_focus.wlr_xdg_surface.surface); + // Focus the target view + self.setFocusRaw(.{ .view = view_to_focus }); + } else { + // Otherwise clear the focus + self.setFocusRaw(.{ .none = {} }); } - - 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; - } - } + /// Switch focus to the target, handling unfocus and input inhibition + /// properly. This should only be called directly if dealing with layers. + pub fn setFocusRaw(self: *Self, focus_target: FocusTarget) void { + // If the target is already focused, do nothing + if (switch (focus_target) { + .view => |target_view| target_view == self.focused_view, + .layer => |target_layer| target_layer == self.focused_layer, + .none => false, + }) { + return; + } + // Obtain the target wlr_surface + const target_wlr_surface = switch (focus_target) { + .view => |target_view| target_view.wlr_xdg_surface.surface, + .layer => |target_layer| target_layer.wlr_layer_surface.surface, + .none => null, + }; - // If a view is currently focused, unfocus it + // If input is not allowed on the target surface (e.g. due to an active + // input inhibitor) do not set focus. If there is no target surface we + // still clear the focus. + if (if (target_wlr_surface) |wlr_surface| + self.input_manager.inputAllowed(wlr_surface) + else + true) { + // First clear the current focus if (self.focused_view) |current_focus| { + std.debug.assert(self.focused_layer == null); 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; - std.debug.assert(self.focused_output == layer_to_focus.output); - } else { - // If there is a layer currently focused, unfocus it - if (self.focused_layer != null) { + } else if (self.focused_layer) |current_focus| { std.debug.assert(self.focused_view == null); self.focused_layer = null; } + c.wlr_seat_keyboard_clear_focus(self.wlr_seat); - // Then focus the view on the top of the focus stack if any - self.focus(null); + // Set the new focus + switch (focus_target) { + .view => |target_view| { + std.debug.assert(self.focused_output == target_view.output); + target_view.setActivated(true); + self.focused_view = target_view; + }, + .layer => |target_layer| blk: { + std.debug.assert(self.focused_output == target_layer.output); + self.focused_layer = target_layer; + }, + .none => {}, + } + + // Tell wlroots to send the new keyboard focus if we have a target + if (target_wlr_surface) |wlr_surface| { + 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, + ); + } } } - /// 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 {