From 6c3f851464596dcdea525d3af9b8c54a5db678e9 Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Thu, 14 Mar 2024 12:35:21 +0100 Subject: [PATCH] Keyboard: eliminate "self" naming convention --- river/Keyboard.zig | 78 +++++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/river/Keyboard.zig b/river/Keyboard.zig index a4c164c..bcb0404 100644 --- a/river/Keyboard.zig +++ b/river/Keyboard.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 Keyboard = @This(); const std = @import("std"); const assert = std.debug.assert; @@ -82,15 +82,15 @@ pressed: Pressed = .{}, key: wl.Listener(*wlr.Keyboard.event.Key) = wl.Listener(*wlr.Keyboard.event.Key).init(handleKey), modifiers: wl.Listener(*wlr.Keyboard) = wl.Listener(*wlr.Keyboard).init(handleModifiers), -pub fn init(self: *Self, seat: *Seat, wlr_device: *wlr.InputDevice) !void { - self.* = .{ +pub fn init(keyboard: *Keyboard, seat: *Seat, wlr_device: *wlr.InputDevice) !void { + keyboard.* = .{ .device = undefined, }; - try self.device.init(seat, wlr_device); - errdefer self.device.deinit(); + try keyboard.device.init(seat, wlr_device); + errdefer keyboard.device.deinit(); - const wlr_keyboard = self.device.wlr_device.toKeyboard(); - wlr_keyboard.data = @intFromPtr(self); + const wlr_keyboard = keyboard.device.wlr_device.toKeyboard(); + wlr_keyboard.data = @intFromPtr(keyboard); // wlroots will log a more detailed error if this fails. if (!wlr_keyboard.setKeymap(server.config.keymap)) return error.OutOfMemory; @@ -99,7 +99,7 @@ pub fn init(self: *Self, seat: *Seat, wlr_device: *wlr.InputDevice) !void { var group_it = seat.keyboard_groups.first; outer: while (group_it) |group_node| : (group_it = group_node.next) { for (group_node.data.globs.items) |glob| { - if (globber.match(glob, self.device.identifier)) { + if (globber.match(glob, keyboard.device.identifier)) { // wlroots will log an error if this fails explaining the reason. _ = group_node.data.wlr_group.addKeyboard(wlr_keyboard); break :outer; @@ -109,18 +109,18 @@ pub fn init(self: *Self, seat: *Seat, wlr_device: *wlr.InputDevice) !void { wlr_keyboard.setRepeatInfo(server.config.repeat_rate, server.config.repeat_delay); - wlr_keyboard.events.key.add(&self.key); - wlr_keyboard.events.modifiers.add(&self.modifiers); + wlr_keyboard.events.key.add(&keyboard.key); + wlr_keyboard.events.modifiers.add(&keyboard.modifiers); } -pub fn deinit(self: *Self) void { - self.key.link.remove(); - self.modifiers.link.remove(); +pub fn deinit(keyboard: *Keyboard) void { + keyboard.key.link.remove(); + keyboard.modifiers.link.remove(); - const seat = self.device.seat; - const wlr_keyboard = self.device.wlr_device.toKeyboard(); + const seat = keyboard.device.seat; + const wlr_keyboard = keyboard.device.wlr_device.toKeyboard(); - self.device.deinit(); + keyboard.device.deinit(); // If the currently active keyboard of a seat is destroyed we need to set // a new active keyboard. Otherwise wlroots may send an enter event without @@ -135,20 +135,20 @@ pub fn deinit(self: *Self) void { } } - self.* = undefined; + keyboard.* = undefined; } 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. - const self = @fieldParentPtr(Self, "key", listener); - const wlr_keyboard = self.device.wlr_device.toKeyboard(); + const keyboard = @fieldParentPtr(Keyboard, "key", listener); + 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 (wlr_keyboard.group != null) return; - self.device.seat.handleActivity(); + keyboard.device.seat.handleActivity(); - self.device.seat.clearRepeatingMapping(); + keyboard.device.seat.clearRepeatingMapping(); // Translate libinput keycode -> xkbcommon const keycode = event.keycode + 8; @@ -168,7 +168,7 @@ fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboa !released and !isModifier(sym)) { - self.device.seat.cursor.hide(); + keyboard.device.seat.cursor.hide(); break; } } @@ -186,17 +186,17 @@ fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboa if (released) { // The released key might not be in the pressed set when switching from a different tty // or if the press was ignored due to >32 keys being pressed simultaneously. - break :blk self.pressed.remove(event.keycode) orelse return; + break :blk keyboard.pressed.remove(event.keycode) orelse return; } // Ignore key presses beyond 32 simultaneously pressed keys (see comments in Pressed). // We must ensure capacity before calling handleMapping() to ensure that we either run // both the press and release mapping for certain key or neither mapping. - self.pressed.keys.ensureUnusedCapacity(1) catch return; + keyboard.pressed.keys.ensureUnusedCapacity(1) catch return; - if (self.device.seat.handleMapping(keycode, modifiers, released, xkb_state)) { + if (keyboard.device.seat.handleMapping(keycode, modifiers, released, xkb_state)) { break :blk .mapping; - } else if (self.getInputMethodGrab() != null) { + } else if (keyboard.getInputMethodGrab() != null) { break :blk .im_grab; } @@ -204,26 +204,26 @@ fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboa }; if (!released) { - self.pressed.addAssumeCapacity(.{ .code = event.keycode, .consumer = consumer }); + keyboard.pressed.addAssumeCapacity(.{ .code = event.keycode, .consumer = consumer }); } switch (consumer) { // Press mappings are handled above when determining the consumer of the press // Release mappings are handled separately as they are executed independent of the consumer. .mapping => {}, - .im_grab => if (self.getInputMethodGrab()) |keyboard_grab| { + .im_grab => if (keyboard.getInputMethodGrab()) |keyboard_grab| { keyboard_grab.setKeyboard(keyboard_grab.keyboard); keyboard_grab.sendKey(event.time_msec, event.keycode, event.state); }, .focus => { - const wlr_seat = self.device.seat.wlr_seat; - wlr_seat.setKeyboard(self.device.wlr_device.toKeyboard()); + const wlr_seat = keyboard.device.seat.wlr_seat; + wlr_seat.setKeyboard(keyboard.device.wlr_device.toKeyboard()); wlr_seat.keyboardNotifyKey(event.time_msec, event.keycode, event.state); }, } // Release mappings don't interact with anything - if (released) _ = self.device.seat.handleMapping(keycode, modifiers, released, xkb_state); + if (released) _ = keyboard.device.seat.handleMapping(keycode, modifiers, released, xkb_state); } fn isModifier(keysym: xkb.Keysym) bool { @@ -231,18 +231,18 @@ fn isModifier(keysym: xkb.Keysym) bool { } fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void { - const self = @fieldParentPtr(Self, "modifiers", listener); - const wlr_keyboard = self.device.wlr_device.toKeyboard(); + const keyboard = @fieldParentPtr(Keyboard, "modifiers", listener); + 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 (wlr_keyboard.group != null) return; - if (self.getInputMethodGrab()) |keyboard_grab| { + if (keyboard.getInputMethodGrab()) |keyboard_grab| { keyboard_grab.setKeyboard(keyboard_grab.keyboard); keyboard_grab.sendModifiers(&wlr_keyboard.modifiers); } else { - self.device.seat.wlr_seat.setKeyboard(self.device.wlr_device.toKeyboard()); - self.device.seat.wlr_seat.keyboardNotifyModifiers(&wlr_keyboard.modifiers); + keyboard.device.seat.wlr_seat.setKeyboard(keyboard.device.wlr_device.toKeyboard()); + keyboard.device.seat.wlr_seat.keyboardNotifyModifiers(&wlr_keyboard.modifiers); } } @@ -267,10 +267,10 @@ fn handleBuiltinMapping(keysym: xkb.Keysym) bool { /// Returns null if the keyboard is not grabbed by an input method, /// or if event is from a virtual keyboard of the same client as the grab. /// TODO: see https://gitlab.freedesktop.org/wlroots/wlroots/-/issues/2322 -fn getInputMethodGrab(self: Self) ?*wlr.InputMethodV2.KeyboardGrab { - if (self.device.seat.relay.input_method) |input_method| { +fn getInputMethodGrab(keyboard: Keyboard) ?*wlr.InputMethodV2.KeyboardGrab { + if (keyboard.device.seat.relay.input_method) |input_method| { if (input_method.keyboard_grab) |keyboard_grab| { - if (self.device.wlr_device.getVirtualKeyboard()) |virtual_keyboard| { + if (keyboard.device.wlr_device.getVirtualKeyboard()) |virtual_keyboard| { if (virtual_keyboard.resource.getClient() == keyboard_grab.resource.getClient()) { return null; }