From 94760394b4b57fec09f4fed214dd2bf70993c857 Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Tue, 21 Apr 2020 16:29:17 +0200 Subject: [PATCH] Bikeshed variable names --- src/cursor.zig | 38 ++++++++++---------- src/decoration.zig | 4 +-- src/decoration_manager.zig | 12 +++---- src/input_manager.zig | 4 +-- src/keyboard.zig | 24 ++++++------- src/layer_surface.zig | 74 +++++++++++++++++++------------------- src/output.zig | 34 +++++++++--------- src/root.zig | 4 +-- src/server.zig | 12 +++---- src/view.zig | 48 ++++++++++++------------- 10 files changed, 125 insertions(+), 129 deletions(-) diff --git a/src/cursor.zig b/src/cursor.zig index 4ca999d..7582547 100644 --- a/src/cursor.zig +++ b/src/cursor.zig @@ -94,7 +94,7 @@ pub const Cursor = struct { fn handleAxis(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is forwarded by the cursor when a pointer emits an axis event, // for example when you move the scroll wheel. - const cursor = @fieldParentPtr(Cursor, "listen_axis", listener.?); + const cursor = @fieldParentPtr(Self, "listen_axis", listener.?); const event = @ptrCast( *c.wlr_event_pointer_axis, @alignCast(@alignOf(*c.wlr_event_pointer_axis), data), @@ -114,14 +114,14 @@ pub const Cursor = struct { fn handleButton(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is forwarded by the cursor when a pointer emits a button // event. - const cursor = @fieldParentPtr(Cursor, "listen_button", listener.?); + const self = @fieldParentPtr(Self, "listen_button", listener.?); const event = @ptrCast( *c.wlr_event_pointer_button, @alignCast(@alignOf(*c.wlr_event_pointer_button), data), ); // Notify the client with pointer focus that a button press has occurred _ = c.wlr_seat_pointer_notify_button( - cursor.seat.wlr_seat, + self.seat.wlr_seat, event.time_msec, event.button, event.state, @@ -131,9 +131,9 @@ pub const Cursor = struct { var sy: f64 = undefined; var surface: ?*c.wlr_surface = null; - const view = cursor.seat.input_manager.server.root.viewAt( - cursor.wlr_cursor.x, - cursor.wlr_cursor.y, + const view = self.seat.input_manager.server.root.viewAt( + self.wlr_cursor.x, + self.wlr_cursor.y, &surface, &sx, &sy, @@ -141,11 +141,11 @@ pub const Cursor = struct { if (event.state == c.enum_wlr_button_state.WLR_BUTTON_RELEASED) { // If you released any buttons, we exit interactive move/resize mode. - cursor.mode = CursorMode.Passthrough; + self.mode = CursorMode.Passthrough; } else { // Focus that client if the button was _pressed_ if (view) |v| { - cursor.seat.focus(v); + self.seat.focus(v); } } } @@ -155,9 +155,9 @@ pub const Cursor = struct { // event. Frame events are sent after regular pointer events to group // multiple events together. For instance, two axis events may happen at the // same time, in which case a frame event won't be sent in between. - const cursor = @fieldParentPtr(Cursor, "listen_frame", listener.?); + const self = @fieldParentPtr(Self, "listen_frame", listener.?); // Notify the client with pointer focus of the frame event. - c.wlr_seat_pointer_notify_frame(cursor.seat.wlr_seat); + c.wlr_seat_pointer_notify_frame(self.seat.wlr_seat); } fn processMove(self: Self, time: u32) void { @@ -176,19 +176,19 @@ pub const Cursor = struct { // move the mouse over the window. You could enter the window from any edge, // so we have to warp the mouse there. There is also some hardware which // emits these events. - const cursor = @fieldParentPtr(Cursor, "listen_motion_absolute", listener.?); + const self = @fieldParentPtr(Self, "listen_motion_absolute", listener.?); const event = @ptrCast( *c.wlr_event_pointer_motion_absolute, @alignCast(@alignOf(*c.wlr_event_pointer_motion_absolute), data), ); - c.wlr_cursor_warp_absolute(cursor.wlr_cursor, event.device, event.x, event.y); - cursor.processMotion(event.time_msec); + c.wlr_cursor_warp_absolute(self.wlr_cursor, event.device, event.x, event.y); + self.processMotion(event.time_msec); } fn handleMotion(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is forwarded by the cursor when a pointer emits a _relative_ // pointer motion event (i.e. a delta) - const cursor = @fieldParentPtr(Cursor, "listen_motion", listener.?); + const self = @fieldParentPtr(Self, "listen_motion", listener.?); const event = @ptrCast( *c.wlr_event_pointer_motion, @alignCast(@alignOf(*c.wlr_event_pointer_motion), data), @@ -198,18 +198,18 @@ pub const Cursor = struct { // special configuration applied for the specific input device which // generated the event. You can pass NULL for the device if you want to move // the cursor around without any input. - c.wlr_cursor_move(cursor.wlr_cursor, event.device, event.delta_x, event.delta_y); - cursor.processMotion(event.time_msec); + c.wlr_cursor_move(self.wlr_cursor, event.device, event.delta_x, event.delta_y); + self.processMotion(event.time_msec); } fn handleRequestSetCursor(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is rasied by the seat when a client provides a cursor image - const cursor = @fieldParentPtr(Cursor, "listen_request_set_cursor", listener.?); + const self = @fieldParentPtr(Self, "listen_request_set_cursor", listener.?); const event = @ptrCast( *c.wlr_seat_pointer_request_set_cursor_event, @alignCast(@alignOf(*c.wlr_seat_pointer_request_set_cursor_event), data), ); - const focused_client = cursor.seat.wlr_seat.pointer_state.focused_client; + const focused_client = self.seat.wlr_seat.pointer_state.focused_client; // This can be sent by any client, so we check to make sure this one is // actually has pointer focus first. @@ -219,7 +219,7 @@ pub const Cursor = struct { // on the output that it's currently on and continue to do so as the // cursor moves between outputs. c.wlr_cursor_set_surface( - cursor.wlr_cursor, + self.wlr_cursor, event.surface, event.hotspot_x, event.hotspot_y, diff --git a/src/decoration.zig b/src/decoration.zig index dbf0342..5e8df06 100644 --- a/src/decoration.zig +++ b/src/decoration.zig @@ -27,10 +27,10 @@ pub const Decoration = struct { } fn handleRequestMode(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const decoration = @fieldParentPtr(Decoration, "listen_request_mode", listener.?); + const self = @fieldParentPtr(Self, "listen_request_mode", listener.?); // TODO: we might need to take this configure serial and do a transaction _ = c.wlr_xdg_toplevel_decoration_v1_set_mode( - decoration.wlr_xdg_toplevel_decoration, + self.wlr_xdg_toplevel_decoration, c.wlr_xdg_toplevel_decoration_v1_mode.WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE, ); } diff --git a/src/decoration_manager.zig b/src/decoration_manager.zig index 256f2a0..cb23e2c 100644 --- a/src/decoration_manager.zig +++ b/src/decoration_manager.zig @@ -28,18 +28,14 @@ pub const DecorationManager = struct { } fn handleNewToplevelDecoration(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const decoration_manager = @fieldParentPtr( - DecorationManager, - "listen_new_toplevel_decoration", - listener.?, - ); + const self = @fieldParentPtr(Self, "listen_new_toplevel_decoration", listener.?); const wlr_xdg_toplevel_decoration = @ptrCast( *c.wlr_xdg_toplevel_decoration_v1, @alignCast(@alignOf(*c.wlr_xdg_toplevel_decoration_v1), data), ); - const node = decoration_manager.decorations.allocateNode(decoration_manager.server.allocator) catch unreachable; - node.data.init(decoration_manager, wlr_xdg_toplevel_decoration); - decoration_manager.decorations.prepend(node); + const node = self.decorations.allocateNode(self.server.allocator) catch unreachable; + node.data.init(self, wlr_xdg_toplevel_decoration); + self.decorations.prepend(node); } }; diff --git a/src/input_manager.zig b/src/input_manager.zig index 12f4171..e5d12dd 100644 --- a/src/input_manager.zig +++ b/src/input_manager.zig @@ -119,11 +119,11 @@ pub const InputManager = struct { /// 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.?); + const self = @fieldParentPtr(Self, "listen_new_input", listener.?); const device = @ptrCast(*c.wlr_input_device, @alignCast(@alignOf(*c.wlr_input_device), data)); // TODO: suport multiple seats - if (input_manager.seats.first) |seat_node| { + if (self.seats.first) |seat_node| { seat_node.data.addDevice(device) catch unreachable; } } diff --git a/src/keyboard.zig b/src/keyboard.zig index f270a22..4be0ccb 100644 --- a/src/keyboard.zig +++ b/src/keyboard.zig @@ -54,13 +54,13 @@ pub const Keyboard = struct { fn handleKey(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is raised when a key is pressed or released. - const keyboard = @fieldParentPtr(Keyboard, "listen_key", listener.?); + const self = @fieldParentPtr(Self, "listen_key", listener.?); const event = @ptrCast( *c.wlr_event_keyboard_key, @alignCast(@alignOf(*c.wlr_event_keyboard_key), data), ); - const wlr_keyboard: *c.wlr_keyboard = keyboard.device.unnamed_133.keyboard; + const wlr_keyboard: *c.wlr_keyboard = self.device.unnamed_133.keyboard; // Translate libinput keycode -> xkbcommon const keycode = event.keycode + 8; @@ -91,10 +91,10 @@ pub const Keyboard = struct { if (event.state == c.enum_wlr_key_state.WLR_KEY_PRESSED) { var i: usize = 0; while (i < translated_keysyms_len) : (i += 1) { - if (keyboard.handleBuiltinKeybind(translated_keysyms.?[i])) { + if (self.handleBuiltinKeybind(translated_keysyms.?[i])) { handled = true; break; - } else if (keyboard.seat.handleKeybinding(translated_keysyms.?[i], modifiers)) { + } else if (self.seat.handleKeybinding(translated_keysyms.?[i], modifiers)) { handled = true; break; } @@ -102,10 +102,10 @@ pub const Keyboard = struct { if (!handled) { i = 0; while (i < raw_keysyms_len) : (i += 1) { - if (keyboard.handleBuiltinKeybind(raw_keysyms.?[i])) { + if (self.handleBuiltinKeybind(raw_keysyms.?[i])) { handled = true; break; - } else if (keyboard.seat.handleKeybinding(raw_keysyms.?[i], modifiers)) { + } else if (self.seat.handleKeybinding(raw_keysyms.?[i], modifiers)) { handled = true; break; } @@ -115,8 +115,8 @@ pub const Keyboard = struct { if (!handled) { // Otherwise, we pass it along to the client. - const wlr_seat = keyboard.seat.wlr_seat; - c.wlr_seat_set_keyboard(wlr_seat, keyboard.device); + const wlr_seat = self.seat.wlr_seat; + c.wlr_seat_set_keyboard(wlr_seat, self.device); c.wlr_seat_keyboard_notify_key( wlr_seat, event.time_msec, @@ -129,18 +129,18 @@ pub const Keyboard = struct { fn handleModifiers(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is raised when a modifier key, such as shift or alt, is // pressed. We simply communicate this to the client. */ - const keyboard = @fieldParentPtr(Keyboard, "listen_modifiers", listener.?); + const self = @fieldParentPtr(Self, "listen_modifiers", listener.?); // A seat can only have one keyboard, but this is a limitation of the // Wayland protocol - not wlroots. We assign all connected keyboards to the // same seat. You can swap out the underlying wlr_keyboard like this and // wlr_seat handles this transparently. - c.wlr_seat_set_keyboard(keyboard.seat.wlr_seat, keyboard.device); + c.wlr_seat_set_keyboard(self.seat.wlr_seat, self.device); // Send modifiers to the client. c.wlr_seat_keyboard_notify_modifiers( - keyboard.seat.wlr_seat, - &keyboard.wlr_keyboard.modifiers, + self.seat.wlr_seat, + &self.wlr_keyboard.modifiers, ); } 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; diff --git a/src/output.zig b/src/output.zig index 34769f1..9979870 100644 --- a/src/output.zig +++ b/src/output.zig @@ -431,28 +431,28 @@ pub const Output = struct { /// Called when the output is destroyed. Evacuate all views from the output /// and then remove it from the list of outputs. fn handleDestroy(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const destroyed_output = @fieldParentPtr(Output, "listen_destroy", listener.?); - const root = destroyed_output.root; + const self = @fieldParentPtr(Self, "listen_destroy", listener.?); + const root = self.root; - Log.Debug.log("Output {} destroyed", .{destroyed_output.wlr_output.name}); + Log.Debug.log("Output {} destroyed", .{self.wlr_output.name}); // Use the first output in the list that is not the one being destroyed. // If there is no other real output, use the noop output. var output_it = root.outputs.first; const fallback_output = while (output_it) |output_node| : (output_it = output_node.next) { - if (&output_node.data != destroyed_output) { + if (&output_node.data != self) { break &output_node.data; } } else &root.noop_output; // Move all views from the destroyed output to the fallback one - while (destroyed_output.views.last) |node| { + while (self.views.last) |node| { const view = &node.view; view.sendToOutput(fallback_output); } // Close all layer surfaces on the destroyed output - for (destroyed_output.layers) |*layer, layer_idx| { + for (self.layers) |*layer, layer_idx| { while (layer.pop()) |node| { const layer_surface = &node.data; c.wlr_layer_surface_v1_close(layer_surface.wlr_layer_surface); @@ -470,22 +470,22 @@ pub const Output = struct { var seat_it = root.server.input_manager.seats.first; while (seat_it) |seat_node| : (seat_it = seat_node.next) { const seat = &seat_node.data; - if (seat.focused_output == destroyed_output) { + if (seat.focused_output == self) { seat.focused_output = fallback_output; seat.focus(null); } } // Remove all listeners - c.wl_list_remove(&destroyed_output.listen_destroy.link); - c.wl_list_remove(&destroyed_output.listen_frame.link); - c.wl_list_remove(&destroyed_output.listen_mode.link); + c.wl_list_remove(&self.listen_destroy.link); + c.wl_list_remove(&self.listen_frame.link); + c.wl_list_remove(&self.listen_mode.link); // Clean up the wlr_output - destroyed_output.wlr_output.data = null; + self.wlr_output.data = null; // Remove the destroyed output from the list - const node = @fieldParentPtr(std.TailQueue(Output).Node, "data", destroyed_output); + const node = @fieldParentPtr(std.TailQueue(Output).Node, "data", self); root.outputs.remove(node); root.server.allocator.destroy(node); @@ -496,13 +496,13 @@ pub const Output = struct { fn handleFrame(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This function is called every time an output is ready to display a frame, // generally at the output's refresh rate (e.g. 60Hz). - const output = @fieldParentPtr(Output, "listen_frame", listener.?); - render.renderOutput(output); + const self = @fieldParentPtr(Self, "listen_frame", listener.?); + render.renderOutput(self); } fn handleMode(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const output = @fieldParentPtr(Output, "listen_mode", listener.?); - output.arrangeLayers(); - output.root.arrange(); + const self = @fieldParentPtr(Self, "listen_mode", listener.?); + self.arrangeLayers(); + self.root.arrange(); } }; diff --git a/src/root.zig b/src/root.zig index 7246577..9623230 100644 --- a/src/root.zig +++ b/src/root.zig @@ -154,7 +154,7 @@ pub const Root = struct { // TODO: log failure to create timer and commit immediately self.transaction_timer = c.wl_event_loop_add_timer( self.server.wl_event_loop, - handle_timeout, + handleTimeout, self, ); @@ -167,7 +167,7 @@ pub const Root = struct { } } - fn handle_timeout(data: ?*c_void) callconv(.C) c_int { + fn handleTimeout(data: ?*c_void) callconv(.C) c_int { const root = @ptrCast(*Root, @alignCast(@alignOf(*Root), data)); Log.Error.log("Transaction timed out. Some imperfect frames may be shown.", .{}); diff --git a/src/server.zig b/src/server.zig index 8371860..db00173 100644 --- a/src/server.zig +++ b/src/server.zig @@ -131,16 +131,16 @@ pub const Server = struct { } fn handleNewOutput(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const server = @fieldParentPtr(Server, "listen_new_output", listener.?); + const self = @fieldParentPtr(Self, "listen_new_output", listener.?); const wlr_output = @ptrCast(*c.wlr_output, @alignCast(@alignOf(*c.wlr_output), data)); Log.Debug.log("New output {}", .{wlr_output.name}); - server.root.addOutput(wlr_output); + self.root.addOutput(wlr_output); } fn handleNewXdgSurface(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is raised when wlr_xdg_shell receives a new xdg surface from a // client, either a toplevel (application window) or popup. - const server = @fieldParentPtr(Server, "listen_new_xdg_surface", listener.?); + const self = @fieldParentPtr(Self, "listen_new_xdg_surface", listener.?); const wlr_xdg_surface = @ptrCast(*c.wlr_xdg_surface, @alignCast(@alignOf(*c.wlr_xdg_surface), data)); if (wlr_xdg_surface.role != c.enum_wlr_xdg_surface_role.WLR_XDG_SURFACE_ROLE_TOPLEVEL) { @@ -148,12 +148,12 @@ pub const Server = struct { return; } - server.input_manager.default_seat.focused_output.addView(wlr_xdg_surface); + self.input_manager.default_seat.focused_output.addView(wlr_xdg_surface); } /// This event is raised when the layer_shell recieves a new surface from a client. fn handleNewLayerSurface(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const server = @fieldParentPtr(Server, "listen_new_layer_surface", listener.?); + const self = @fieldParentPtr(Self, "listen_new_layer_surface", listener.?); const wlr_layer_surface = @ptrCast( *c.wlr_layer_surface_v1, @alignCast(@alignOf(*c.wlr_layer_surface_v1), data), @@ -178,7 +178,7 @@ pub const Server = struct { // If the new layer surface does not have an output assigned to it, use the // first output or close the surface if none are available. if (wlr_layer_surface.output == null) { - if (server.root.outputs.first) |node| { + if (self.root.outputs.first) |node| { const output = &node.data; Log.Debug.log( "New layer surface had null output, assigning it to output {}", diff --git a/src/view.zig b/src/view.zig index 4a1886e..9bde87d 100644 --- a/src/view.zig +++ b/src/view.zig @@ -137,68 +137,68 @@ pub const View = struct { } fn handleDestroy(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const view = @fieldParentPtr(View, "listen_destroy", listener.?); - const output = view.output; + const self = @fieldParentPtr(Self, "listen_destroy", listener.?); + const output = self.output; // Remove listeners that are active for the entire lifetime of the view - c.wl_list_remove(&view.listen_destroy.link); - c.wl_list_remove(&view.listen_map.link); - c.wl_list_remove(&view.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); // Remove the view from the stack - const node = @fieldParentPtr(ViewStack(View).Node, "view", view); + const node = @fieldParentPtr(ViewStack(View).Node, "view", self); output.views.remove(node); output.root.server.allocator.destroy(node); } /// Called when the surface is mapped, or ready to display on-screen. fn handleMap(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const view = @fieldParentPtr(View, "listen_map", listener.?); - const root = view.output.root; + const self = @fieldParentPtr(Self, "listen_map", listener.?); + const root = self.output.root; // Add listeners that are only active while mapped - view.listen_commit.notify = handleCommit; - c.wl_signal_add(&view.wlr_xdg_surface.surface.*.events.commit, &view.listen_commit); + self.listen_commit.notify = handleCommit; + c.wl_signal_add(&self.wlr_xdg_surface.surface.*.events.commit, &self.listen_commit); - view.mapped = true; + self.mapped = true; // Focus the newly mapped view. Note: if a seat is focusing a different output // it will continue to do so. var it = root.server.input_manager.seats.first; while (it) |seat_node| : (it = seat_node.next) { - seat_node.data.focus(view); + seat_node.data.focus(self); } - c.wlr_surface_send_enter(view.wlr_xdg_surface.surface, view.output.wlr_output); + c.wlr_surface_send_enter(self.wlr_xdg_surface.surface, self.output.wlr_output); - view.output.root.arrange(); + self.output.root.arrange(); } /// Called when the surface is unmapped and will no longer be displayed. fn handleUnmap(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const view = @fieldParentPtr(View, "listen_unmap", listener.?); - const root = view.output.root; - view.mapped = false; + const self = @fieldParentPtr(Self, "listen_unmap", listener.?); + const root = self.output.root; + self.mapped = false; // Inform all seats that the view has been unmapped so they can handle focus var it = root.server.input_manager.seats.first; while (it) |node| : (it = node.next) { const seat = &node.data; - seat.handleViewUnmap(view); + seat.handleViewUnmap(self); } root.arrange(); // Remove listeners that are only active while mapped - c.wl_list_remove(&view.listen_commit.link); + c.wl_list_remove(&self.listen_commit.link); } fn handleCommit(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - const view = @fieldParentPtr(View, "listen_commit", listener.?); - if (view.pending_serial) |s| { - if (s == view.wlr_xdg_surface.configure_serial) { - view.output.root.notifyConfigured(); - view.pending_serial = null; + const self = @fieldParentPtr(Self, "listen_commit", listener.?); + if (self.pending_serial) |s| { + if (s == self.wlr_xdg_surface.configure_serial) { + self.output.root.notifyConfigured(); + self.pending_serial = null; } } // TODO: check for unexpected change in size and react as needed