Bikeshed variable names

1 files changed, 37 insertions, 37 deletions

diff --git a/src/layer_surface.zig b/src/layer_surface.zig
index 650fdb2..5d5778b 100644
--- a/src/layer_surface.zig
+++ b/src/layer_surface.zig
@@ -57,61 +57,61 @@ pub const LayerSurface = struct {
     }
 
     fn handleDestroy(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void {
-        const layer_surface = @fieldParentPtr(LayerSurface, "listen_destroy", listener.?);
-        const output = layer_surface.output;
+        const self = @fieldParentPtr(Self, "listen_destroy", listener.?);
+        const output = self.output;
 
-        Log.Debug.log("Layer surface '{}' destroyed", .{layer_surface.wlr_layer_surface.namespace});
+        Log.Debug.log("Layer surface '{}' destroyed", .{self.wlr_layer_surface.namespace});
 
         // Remove listeners active the entire lifetime of the layer surface
-        c.wl_list_remove(&layer_surface.listen_destroy.link);
-        c.wl_list_remove(&layer_surface.listen_map.link);
-        c.wl_list_remove(&layer_surface.listen_unmap.link);
+        c.wl_list_remove(&self.listen_destroy.link);
+        c.wl_list_remove(&self.listen_map.link);
+        c.wl_list_remove(&self.listen_unmap.link);
 
-        const node = @fieldParentPtr(std.TailQueue(LayerSurface).Node, "data", layer_surface);
-        output.layers[@intCast(usize, @enumToInt(layer_surface.layer))].remove(node);
+        const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
+        output.layers[@intCast(usize, @enumToInt(self.layer))].remove(node);
         output.root.server.allocator.destroy(node);
     }
 
     fn handleMap(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void {
-        const layer_surface = @fieldParentPtr(LayerSurface, "listen_map", listener.?);
-        const wlr_layer_surface = layer_surface.wlr_layer_surface;
+        const self = @fieldParentPtr(Self, "listen_map", listener.?);
+        const wlr_layer_surface = self.wlr_layer_surface;
 
         Log.Debug.log("Layer surface '{}' mapped.", .{wlr_layer_surface.namespace});
 
-        layer_surface.mapped = true;
+        self.mapped = true;
 
         // Add listeners that are only active while mapped
-        layer_surface.listen_commit.notify = handleCommit;
-        c.wl_signal_add(&wlr_layer_surface.surface.*.events.commit, &layer_surface.listen_commit);
+        self.listen_commit.notify = handleCommit;
+        c.wl_signal_add(&wlr_layer_surface.surface.*.events.commit, &self.listen_commit);
 
-        layer_surface.listen_new_popup.notify = handleNewPopup;
-        c.wl_signal_add(&wlr_layer_surface.events.new_popup, &layer_surface.listen_new_popup);
+        self.listen_new_popup.notify = handleNewPopup;
+        c.wl_signal_add(&wlr_layer_surface.events.new_popup, &self.listen_new_popup);
 
         c.wlr_surface_send_enter(
             wlr_layer_surface.surface,
             wlr_layer_surface.output,
         );
 
-        layer_surface.output.arrangeLayers();
+        self.output.arrangeLayers();
     }
 
     fn handleUnmap(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void {
-        const layer_surface = @fieldParentPtr(LayerSurface, "listen_unmap", listener.?);
+        const self = @fieldParentPtr(Self, "listen_unmap", listener.?);
 
-        Log.Debug.log("Layer surface '{}' unmapped.", .{layer_surface.wlr_layer_surface.namespace});
+        Log.Debug.log("Layer surface '{}' unmapped.", .{self.wlr_layer_surface.namespace});
 
-        layer_surface.mapped = false;
+        self.mapped = false;
 
         // remove listeners only active while the layer surface is mapped
-        c.wl_list_remove(&layer_surface.listen_commit.link);
-        c.wl_list_remove(&layer_surface.listen_new_popup.link);
+        c.wl_list_remove(&self.listen_commit.link);
+        c.wl_list_remove(&self.listen_new_popup.link);
 
         // If the unmapped surface is focused, clear focus
-        var it = layer_surface.output.root.server.input_manager.seats.first;
+        var it = self.output.root.server.input_manager.seats.first;
         while (it) |node| : (it = node.next) {
             const seat = &node.data;
             if (seat.focused_layer) |current_focus| {
-                if (current_focus == layer_surface) {
+                if (current_focus == self) {
                     seat.setFocusRaw(.{ .none = {} });
                 }
             }
@@ -119,11 +119,11 @@ pub const LayerSurface = struct {
 
         // This gives exclusive focus to a keyboard interactive top or overlay layer
         // surface if there is one.
-        layer_surface.output.arrangeLayers();
+        self.output.arrangeLayers();
 
         // Ensure that focus is given to the appropriate view if there is no
         // other top/overlay layer surface to grab focus.
-        it = layer_surface.output.root.server.input_manager.seats.first;
+        it = self.output.root.server.input_manager.seats.first;
         while (it) |node| : (it = node.next) {
             const seat = &node.data;
             seat.focus(null);
@@ -131,34 +131,34 @@ pub const LayerSurface = struct {
     }
 
     fn handleCommit(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void {
-        const layer_surface = @fieldParentPtr(LayerSurface, "listen_commit", listener.?);
-        const wlr_layer_surface = layer_surface.wlr_layer_surface;
+        const self = @fieldParentPtr(Self, "listen_commit", listener.?);
+        const wlr_layer_surface = self.wlr_layer_surface;
 
-        if (layer_surface.wlr_layer_surface.output == null) {
+        if (self.wlr_layer_surface.output == null) {
             Log.Error.log("Layer surface committed with null output", .{});
             return;
         }
 
         // If the layer changed, move the LayerSurface to the proper list
-        if (layer_surface.layer != layer_surface.wlr_layer_surface.current.layer) {
-            const node = @fieldParentPtr(std.TailQueue(LayerSurface).Node, "data", layer_surface);
+        if (self.layer != self.wlr_layer_surface.current.layer) {
+            const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
 
-            const old_layer_idx = @intCast(usize, @enumToInt(layer_surface.layer));
-            layer_surface.output.layers[old_layer_idx].remove(node);
+            const old_layer_idx = @intCast(usize, @enumToInt(self.layer));
+            self.output.layers[old_layer_idx].remove(node);
 
-            layer_surface.layer = layer_surface.wlr_layer_surface.current.layer;
+            self.layer = self.wlr_layer_surface.current.layer;
 
-            const new_layer_idx = @intCast(usize, @enumToInt(layer_surface.layer));
-            layer_surface.output.layers[new_layer_idx].append(node);
+            const new_layer_idx = @intCast(usize, @enumToInt(self.layer));
+            self.output.layers[new_layer_idx].append(node);
         }
 
         // TODO: only reconfigure if things haven't changed
         // https://github.com/swaywm/wlroots/issues/1079
-        layer_surface.output.arrangeLayers();
+        self.output.arrangeLayers();
     }
 
     fn handleNewPopup(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void {
-        const layer_surface = @fieldParentPtr(LayerSurface, "listen_new_popup", listener.?);
+        const self = @fieldParentPtr(Self, "listen_new_popup", listener.?);
         Log.Debug.log("new layer surface popup.", .{});
         // TODO: handle popups
         unreachable;