From 267aa9a9b5ff77dca82b650f705a897a2d76721d Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Thu, 14 Mar 2024 12:05:36 +0100 Subject: [PATCH] Seat: eliminate "self" naming convention --- river/Seat.zig | 254 ++++++++++++++++++++++++------------------------- 1 file changed, 127 insertions(+), 127 deletions(-) diff --git a/river/Seat.zig b/river/Seat.zig index 4da4861..4ebcec5 100644 --- a/river/Seat.zig +++ b/river/Seat.zig @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -const Self = @This(); +const Seat = @This(); const build_options = @import("build_options"); const std = @import("std"); @@ -110,64 +110,64 @@ drag_destroy: wl.Listener(*wlr.Drag) = wl.Listener(*wlr.Drag).init(handleDragDes request_set_primary_selection: wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection) = wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection).init(handleRequestSetPrimarySelection), -pub fn init(self: *Self, name: [*:0]const u8) !void { +pub fn init(seat: *Seat, name: [*:0]const u8) !void { const event_loop = server.wl_server.getEventLoop(); - const mapping_repeat_timer = try event_loop.addTimer(*Self, handleMappingRepeatTimeout, self); + const mapping_repeat_timer = try event_loop.addTimer(*Seat, handleMappingRepeatTimeout, seat); errdefer mapping_repeat_timer.remove(); - self.* = .{ + seat.* = .{ // This will be automatically destroyed when the display is destroyed .wlr_seat = try wlr.Seat.create(server.wl_server, name), .cursor = undefined, .relay = undefined, .mapping_repeat_timer = mapping_repeat_timer, }; - self.wlr_seat.data = @intFromPtr(self); + seat.wlr_seat.data = @intFromPtr(seat); - try self.cursor.init(self); - self.relay.init(); + try seat.cursor.init(seat); + seat.relay.init(); - self.wlr_seat.events.request_set_selection.add(&self.request_set_selection); - self.wlr_seat.events.request_start_drag.add(&self.request_start_drag); - self.wlr_seat.events.start_drag.add(&self.start_drag); - self.wlr_seat.events.request_set_primary_selection.add(&self.request_set_primary_selection); + seat.wlr_seat.events.request_set_selection.add(&seat.request_set_selection); + seat.wlr_seat.events.request_start_drag.add(&seat.request_start_drag); + seat.wlr_seat.events.start_drag.add(&seat.start_drag); + seat.wlr_seat.events.request_set_primary_selection.add(&seat.request_set_primary_selection); } -pub fn deinit(self: *Self) void { +pub fn deinit(seat: *Seat) void { { var it = server.input_manager.devices.iterator(.forward); - while (it.next()) |device| assert(device.seat != self); + while (it.next()) |device| assert(device.seat != seat); } - self.cursor.deinit(); - self.mapping_repeat_timer.remove(); + seat.cursor.deinit(); + seat.mapping_repeat_timer.remove(); - while (self.keyboard_groups.first) |node| { + while (seat.keyboard_groups.first) |node| { node.data.destroy(); } - self.request_set_selection.link.remove(); - self.request_start_drag.link.remove(); - self.start_drag.link.remove(); - if (self.drag != .none) self.drag_destroy.link.remove(); - self.request_set_primary_selection.link.remove(); + seat.request_set_selection.link.remove(); + seat.request_start_drag.link.remove(); + seat.start_drag.link.remove(); + if (seat.drag != .none) seat.drag_destroy.link.remove(); + seat.request_set_primary_selection.link.remove(); } /// Set the current focus. If a visible view is passed it will be focused. /// If null is passed, the top view in the stack of the focused output will be focused. /// Requires a call to Root.applyPending() -pub fn focus(self: *Self, _target: ?*View) void { +pub fn focus(seat: *Seat, _target: ?*View) void { var target = _target; // Don't change focus if there are no outputs. - if (self.focused_output == null) return; + if (seat.focused_output == null) return; // Views may not receive focus while locked. if (server.lock_manager.state != .unlocked) return; // While a layer surface is exclusively focused, views may not receive focus - if (self.focused == .layer) { - const wlr_layer_surface = self.focused.layer.wlr_layer_surface; + if (seat.focused == .layer) { + const wlr_layer_surface = seat.focused.layer.wlr_layer_surface; assert(wlr_layer_surface.surface.mapped); if (wlr_layer_surface.current.keyboard_interactive == .exclusive and (wlr_layer_surface.current.layer == .top or wlr_layer_surface.current.layer == .overlay)) @@ -182,17 +182,17 @@ pub fn focus(self: *Self, _target: ?*View) void { { // If the view is not currently visible, behave as if null was passed target = null; - } else if (view.pending.output.? != self.focused_output.?) { + } else if (view.pending.output.? != seat.focused_output.?) { // If the view is not on the currently focused output, focus it - self.focusOutput(view.pending.output.?); + seat.focusOutput(view.pending.output.?); } } { - var it = self.focused_output.?.pending.focus_stack.iterator(.forward); + var it = seat.focused_output.?.pending.focus_stack.iterator(.forward); while (it.next()) |view| { if (view.pending.fullscreen and - view.pending.tags & self.focused_output.?.pending.tags != 0) + view.pending.tags & seat.focused_output.?.pending.tags != 0) { target = view; break; @@ -202,9 +202,9 @@ pub fn focus(self: *Self, _target: ?*View) void { // If null, set the target to the first currently visible view in the focus stack if any if (target == null) { - var it = self.focused_output.?.pending.focus_stack.iterator(.forward); + var it = seat.focused_output.?.pending.focus_stack.iterator(.forward); target = while (it.next()) |view| { - if (view.pending.tags & self.focused_output.?.pending.tags != 0) { + if (view.pending.tags & seat.focused_output.?.pending.tags != 0) { break view; } } else null; @@ -213,24 +213,24 @@ pub fn focus(self: *Self, _target: ?*View) void { // Focus the target view or clear the focus if target is null if (target) |view| { view.pending_focus_stack_link.remove(); - self.focused_output.?.pending.focus_stack.prepend(view); - self.setFocusRaw(.{ .view = view }); + seat.focused_output.?.pending.focus_stack.prepend(view); + seat.setFocusRaw(.{ .view = view }); } else { - self.setFocusRaw(.{ .none = {} }); + seat.setFocusRaw(.{ .none = {} }); } } /// Switch focus to the target, handling unfocus and input inhibition /// properly. This should only be called directly if dealing with layers or /// override redirect xwayland views. -pub fn setFocusRaw(self: *Self, new_focus: FocusTarget) void { +pub fn setFocusRaw(seat: *Seat, new_focus: FocusTarget) void { // If the target is already focused, do nothing - if (std.meta.eql(new_focus, self.focused)) return; + if (std.meta.eql(new_focus, seat.focused)) return; const target_surface = new_focus.surface(); // First clear the current focus - switch (self.focused) { + switch (seat.focused) { .view => |view| { view.pending.focus -= 1; view.destroyPopups(); @@ -245,66 +245,66 @@ pub fn setFocusRaw(self: *Self, new_focus: FocusTarget) void { switch (new_focus) { .view => |target_view| { assert(server.lock_manager.state != .locked); - assert(self.focused_output == target_view.pending.output); + assert(seat.focused_output == target_view.pending.output); target_view.pending.focus += 1; target_view.pending.urgent = false; }, .layer => |target_layer| { assert(server.lock_manager.state != .locked); - assert(self.focused_output == target_layer.output); + assert(seat.focused_output == target_layer.output); }, .lock_surface => assert(server.lock_manager.state != .unlocked), .xwayland_override_redirect, .none => {}, } - self.focused = new_focus; + seat.focused = new_focus; - if (self.cursor.constraint) |constraint| { + if (seat.cursor.constraint) |constraint| { if (constraint.wlr_constraint.surface != target_surface) { if (constraint.state == .active) { log.info("deactivating pointer constraint for surface, keyboard focus lost", .{}); constraint.deactivate(); } - self.cursor.constraint = null; + seat.cursor.constraint = null; } } - self.keyboardEnterOrLeave(target_surface); - self.relay.focus(target_surface); + seat.keyboardEnterOrLeave(target_surface); + seat.relay.focus(target_surface); if (target_surface) |surface| { const pointer_constraints = server.input_manager.pointer_constraints; - if (pointer_constraints.constraintForSurface(surface, self.wlr_seat)) |wlr_constraint| { - if (self.cursor.constraint) |constraint| { + if (pointer_constraints.constraintForSurface(surface, seat.wlr_seat)) |wlr_constraint| { + if (seat.cursor.constraint) |constraint| { assert(constraint.wlr_constraint == wlr_constraint); } else { - self.cursor.constraint = @ptrFromInt(wlr_constraint.data); - assert(self.cursor.constraint != null); + seat.cursor.constraint = @ptrFromInt(wlr_constraint.data); + assert(seat.cursor.constraint != null); } } } // Depending on configuration and cursor position, changing keyboard focus // may cause the cursor to be warped. - self.cursor.may_need_warp = true; + seat.cursor.may_need_warp = true; // Inform any clients tracking status of the change - var it = self.status_trackers.first; + var it = seat.status_trackers.first; while (it) |node| : (it = node.next) node.data.sendFocusedView(); } /// Send keyboard enter/leave events and handle pointer constraints /// This should never normally be called from outside of setFocusRaw(), but we make an exception for /// XwaylandOverrideRedirect surfaces as they don't conform to the Wayland focus model. -pub fn keyboardEnterOrLeave(self: *Self, target_surface: ?*wlr.Surface) void { +pub fn keyboardEnterOrLeave(seat: *Seat, target_surface: ?*wlr.Surface) void { if (target_surface) |wlr_surface| { - self.keyboardNotifyEnter(wlr_surface); + seat.keyboardNotifyEnter(wlr_surface); } else { - self.wlr_seat.keyboardNotifyClearFocus(); + seat.wlr_seat.keyboardNotifyClearFocus(); } } -fn keyboardNotifyEnter(self: *Self, wlr_surface: *wlr.Surface) void { - if (self.wlr_seat.getKeyboard()) |wlr_keyboard| { +fn keyboardNotifyEnter(seat: *Seat, wlr_surface: *wlr.Surface) void { + if (seat.wlr_seat.getKeyboard()) |wlr_keyboard| { const keyboard: *Keyboard = @ptrFromInt(wlr_keyboard.data); var keycodes: std.BoundedArray(u32, Keyboard.Pressed.capacity) = .{}; @@ -312,45 +312,45 @@ fn keyboardNotifyEnter(self: *Self, wlr_surface: *wlr.Surface) void { if (item.consumer == .focus) keycodes.appendAssumeCapacity(item.code); } - self.wlr_seat.keyboardNotifyEnter( + seat.wlr_seat.keyboardNotifyEnter( wlr_surface, keycodes.constSlice(), &wlr_keyboard.modifiers, ); } else { - self.wlr_seat.keyboardNotifyEnter(wlr_surface, &.{}, null); + seat.wlr_seat.keyboardNotifyEnter(wlr_surface, &.{}, null); } } /// Focus the given output, notifying any listening clients of the change. -pub fn focusOutput(self: *Self, output: ?*Output) void { - if (self.focused_output == output) return; +pub fn focusOutput(seat: *Seat, output: ?*Output) void { + if (seat.focused_output == output) return; - if (self.focused_output) |old| { - var it = self.status_trackers.first; + if (seat.focused_output) |old| { + var it = seat.status_trackers.first; while (it) |node| : (it = node.next) node.data.sendOutput(old, .unfocused); } - self.focused_output = output; + seat.focused_output = output; - if (self.focused_output) |new| { - var it = self.status_trackers.first; + if (seat.focused_output) |new| { + var it = seat.status_trackers.first; while (it) |node| : (it = node.next) node.data.sendOutput(new, .focused); } // Depending on configuration and cursor position, changing output focus // may cause the cursor to be warped. - self.cursor.may_need_warp = true; + seat.cursor.may_need_warp = true; } -pub fn handleActivity(self: Self) void { - server.input_manager.idle_notifier.notifyActivity(self.wlr_seat); +pub fn handleActivity(seat: Seat) void { + server.input_manager.idle_notifier.notifyActivity(seat.wlr_seat); } -pub fn enterMode(self: *Self, mode_id: u32) void { - self.mode_id = mode_id; +pub fn enterMode(seat: *Seat, mode_id: u32) void { + seat.mode_id = mode_id; - var it = self.status_trackers.first; + var it = seat.status_trackers.first; while (it) |node| : (it = node.next) { node.data.sendMode(server.config.modes.items[mode_id].name); } @@ -359,7 +359,7 @@ pub fn enterMode(self: *Self, mode_id: u32) void { /// Handle any user-defined mapping for passed keycode, modifiers and keyboard state /// Returns true if a mapping was run pub fn handleMapping( - self: *Self, + seat: *Seat, keycode: xkb.Keycode, modifiers: wlr.Keyboard.ModifierMask, released: bool, @@ -380,7 +380,7 @@ pub fn handleMapping( // That is, if the physical keys Mod+Shift+1 are pressed on a US layout don't // translate the keysym 1 to an exclamation mark. This behavior is generally // what is desired. - for (modes.items[self.mode_id].mappings.items) |*mapping| { + for (modes.items[seat.mode_id].mappings.items) |*mapping| { if (mapping.match(keycode, modifiers, released, xkb_state, .no_translate)) { if (found == null) { found = mapping; @@ -394,7 +394,7 @@ pub fn handleMapping( // with xkbcommon for intuitive behavior. For example, layouts may require // translation with the numlock modifier to obtain keypad number keysyms // (e.g. KP_1). - for (modes.items[self.mode_id].mappings.items) |*mapping| { + for (modes.items[seat.mode_id].mappings.items) |*mapping| { if (mapping.match(keycode, modifiers, released, xkb_state, .translate)) { if (found == null) { found = mapping; @@ -408,12 +408,12 @@ pub fn handleMapping( // the list of mappings we are iterating through, possibly causing it to be re-allocated. if (found) |mapping| { if (mapping.options.repeat) { - self.repeating_mapping = mapping; - self.mapping_repeat_timer.timerUpdate(server.config.repeat_delay) catch { + seat.repeating_mapping = mapping; + seat.mapping_repeat_timer.timerUpdate(server.config.repeat_delay) catch { log.err("failed to update mapping repeat timer", .{}); }; } - self.runCommand(mapping.command_args); + seat.runCommand(mapping.command_args); return true; } @@ -422,22 +422,22 @@ pub fn handleMapping( /// Handle any user-defined mapping for switches pub fn handleSwitchMapping( - self: *Self, + seat: *Seat, switch_type: Switch.Type, switch_state: Switch.State, ) void { const modes = &server.config.modes; - for (modes.items[self.mode_id].switch_mappings.items) |mapping| { + for (modes.items[seat.mode_id].switch_mappings.items) |mapping| { if (std.meta.eql(mapping.switch_type, switch_type) and std.meta.eql(mapping.switch_state, switch_state)) { - self.runCommand(mapping.command_args); + seat.runCommand(mapping.command_args); } } } -pub fn runCommand(self: *Self, args: []const [:0]const u8) void { +pub fn runCommand(seat: *Seat, args: []const [:0]const u8) void { var out: ?[]const u8 = null; defer if (out) |s| util.gpa.free(s); - command.run(self, args, &out) catch |err| { + command.run(seat, args, &out) catch |err| { const failure_message = switch (err) { command.Error.Other => out.?, else => command.errToMsg(err), @@ -453,63 +453,63 @@ pub fn runCommand(self: *Self, args: []const [:0]const u8) void { } } -pub fn clearRepeatingMapping(self: *Self) void { - self.mapping_repeat_timer.timerUpdate(0) catch { +pub fn clearRepeatingMapping(seat: *Seat) void { + seat.mapping_repeat_timer.timerUpdate(0) catch { log.err("failed to clear mapping repeat timer", .{}); }; - self.repeating_mapping = null; + seat.repeating_mapping = null; } /// Repeat key mapping -fn handleMappingRepeatTimeout(self: *Self) c_int { - if (self.repeating_mapping) |mapping| { +fn handleMappingRepeatTimeout(seat: *Seat) c_int { + if (seat.repeating_mapping) |mapping| { const rate = server.config.repeat_rate; const ms_delay = if (rate > 0) 1000 / rate else 0; - self.mapping_repeat_timer.timerUpdate(ms_delay) catch { + seat.mapping_repeat_timer.timerUpdate(ms_delay) catch { log.err("failed to update mapping repeat timer", .{}); }; - self.runCommand(mapping.command_args); + seat.runCommand(mapping.command_args); } return 0; } -pub fn addDevice(self: *Self, wlr_device: *wlr.InputDevice) void { - self.tryAddDevice(wlr_device) catch |err| switch (err) { +pub fn addDevice(seat: *Seat, wlr_device: *wlr.InputDevice) void { + seat.tryAddDevice(wlr_device) catch |err| switch (err) { error.OutOfMemory => log.err("out of memory", .{}), }; } -fn tryAddDevice(self: *Self, wlr_device: *wlr.InputDevice) !void { +fn tryAddDevice(seat: *Seat, wlr_device: *wlr.InputDevice) !void { switch (wlr_device.type) { .keyboard => { const keyboard = try util.gpa.create(Keyboard); errdefer util.gpa.destroy(keyboard); - try keyboard.init(self, wlr_device); + try keyboard.init(seat, wlr_device); - self.wlr_seat.setKeyboard(keyboard.device.wlr_device.toKeyboard()); - if (self.wlr_seat.keyboard_state.focused_surface) |wlr_surface| { - self.wlr_seat.keyboardNotifyClearFocus(); - self.keyboardNotifyEnter(wlr_surface); + seat.wlr_seat.setKeyboard(keyboard.device.wlr_device.toKeyboard()); + if (seat.wlr_seat.keyboard_state.focused_surface) |wlr_surface| { + seat.wlr_seat.keyboardNotifyClearFocus(); + seat.keyboardNotifyEnter(wlr_surface); } }, .pointer, .touch => { const device = try util.gpa.create(InputDevice); errdefer util.gpa.destroy(device); - try device.init(self, wlr_device); + try device.init(seat, wlr_device); - self.cursor.wlr_cursor.attachInputDevice(wlr_device); + seat.cursor.wlr_cursor.attachInputDevice(wlr_device); }, .tablet_tool => { - try Tablet.create(self, wlr_device); - self.cursor.wlr_cursor.attachInputDevice(wlr_device); + try Tablet.create(seat, wlr_device); + seat.cursor.wlr_cursor.attachInputDevice(wlr_device); }, .switch_device => { const switch_device = try util.gpa.create(Switch); errdefer util.gpa.destroy(switch_device); - try switch_device.init(self, wlr_device); + try switch_device.init(seat, wlr_device); }, // TODO Support these types of input devices. @@ -517,14 +517,14 @@ fn tryAddDevice(self: *Self, wlr_device: *wlr.InputDevice) !void { } } -pub fn updateCapabilities(self: *Self) void { +pub fn updateCapabilities(seat: *Seat) void { // Currently a cursor is always drawn even if there are no pointer input devices. // TODO Don't draw a cursor if there are no input devices. var capabilities: wl.Seat.Capability = .{ .pointer = true }; var it = server.input_manager.devices.iterator(.forward); while (it.next()) |device| { - if (device.seat == self) { + if (device.seat == seat) { switch (device.wlr_device.type) { .keyboard => capabilities.keyboard = true, .touch => capabilities.touch = true, @@ -534,36 +534,36 @@ pub fn updateCapabilities(self: *Self) void { } } - self.wlr_seat.setCapabilities(capabilities); + seat.wlr_seat.setCapabilities(capabilities); } fn handleRequestSetSelection( listener: *wl.Listener(*wlr.Seat.event.RequestSetSelection), event: *wlr.Seat.event.RequestSetSelection, ) void { - const self = @fieldParentPtr(Self, "request_set_selection", listener); - self.wlr_seat.setSelection(event.source, event.serial); + const seat = @fieldParentPtr(Seat, "request_set_selection", listener); + seat.wlr_seat.setSelection(event.source, event.serial); } fn handleRequestStartDrag( listener: *wl.Listener(*wlr.Seat.event.RequestStartDrag), event: *wlr.Seat.event.RequestStartDrag, ) void { - const self = @fieldParentPtr(Self, "request_start_drag", listener); + const seat = @fieldParentPtr(Seat, "request_start_drag", listener); // The start_drag request is ignored by wlroots if a drag is currently in progress. - assert(self.drag == .none); + assert(seat.drag == .none); - if (self.wlr_seat.validatePointerGrabSerial(event.origin, event.serial)) { + if (seat.wlr_seat.validatePointerGrabSerial(event.origin, event.serial)) { log.debug("starting pointer drag", .{}); - self.wlr_seat.startPointerDrag(event.drag, event.serial); + seat.wlr_seat.startPointerDrag(event.drag, event.serial); return; } var point: *wlr.TouchPoint = undefined; - if (self.wlr_seat.validateTouchGrabSerial(event.origin, event.serial, &point)) { + if (seat.wlr_seat.validateTouchGrabSerial(event.origin, event.serial, &point)) { log.debug("starting touch drag", .{}); - self.wlr_seat.startTouchDrag(event.drag, event.serial, point); + seat.wlr_seat.startTouchDrag(event.drag, event.serial, point); return; } @@ -573,21 +573,21 @@ fn handleRequestStartDrag( } fn handleStartDrag(listener: *wl.Listener(*wlr.Drag), wlr_drag: *wlr.Drag) void { - const self = @fieldParentPtr(Self, "start_drag", listener); + const seat = @fieldParentPtr(Seat, "start_drag", listener); - assert(self.drag == .none); + assert(seat.drag == .none); switch (wlr_drag.grab_type) { .keyboard_pointer => { - self.drag = .pointer; - self.cursor.mode = .passthrough; + seat.drag = .pointer; + seat.cursor.mode = .passthrough; }, - .keyboard_touch => self.drag = .touch, + .keyboard_touch => seat.drag = .touch, .keyboard => unreachable, } - wlr_drag.events.destroy.add(&self.drag_destroy); + wlr_drag.events.destroy.add(&seat.drag_destroy); if (wlr_drag.icon) |wlr_drag_icon| { - DragIcon.create(wlr_drag_icon, &self.cursor) catch { + DragIcon.create(wlr_drag_icon, &seat.cursor) catch { log.err("out of memory", .{}); wlr_drag.seat_client.client.postNoMemory(); return; @@ -596,24 +596,24 @@ fn handleStartDrag(listener: *wl.Listener(*wlr.Drag), wlr_drag: *wlr.Drag) void } fn handleDragDestroy(listener: *wl.Listener(*wlr.Drag), _: *wlr.Drag) void { - const self = @fieldParentPtr(Self, "drag_destroy", listener); - self.drag_destroy.link.remove(); + const seat = @fieldParentPtr(Seat, "drag_destroy", listener); + seat.drag_destroy.link.remove(); - switch (self.drag) { + switch (seat.drag) { .none => unreachable, .pointer => { - self.cursor.checkFocusFollowsCursor(); - self.cursor.updateState(); + seat.cursor.checkFocusFollowsCursor(); + seat.cursor.updateState(); }, .touch => {}, } - self.drag = .none; + seat.drag = .none; } fn handleRequestSetPrimarySelection( listener: *wl.Listener(*wlr.Seat.event.RequestSetPrimarySelection), event: *wlr.Seat.event.RequestSetPrimarySelection, ) void { - const self = @fieldParentPtr(Self, "request_set_primary_selection", listener); - self.wlr_seat.setPrimarySelection(event.source, event.serial); + const seat = @fieldParentPtr(Seat, "request_set_primary_selection", listener); + seat.wlr_seat.setPrimarySelection(event.source, event.serial); }