diff --git a/src/cursor.zig b/src/cursor.zig index 851d232..d403934 100644 --- a/src/cursor.zig +++ b/src/cursor.zig @@ -33,7 +33,7 @@ pub const Cursor = struct { resize_edges: u32, pub fn create(seat: *Seat) !@This() { - var cursor = @This(){ + const cursor = @This(){ .seat = seat, // Creates a wlroots utility for tracking the cursor image shown on screen. @@ -127,15 +127,17 @@ pub const Cursor = struct { // commit any movement that was prepared. // TODO: Handle null view - var view = self.grabbed_view; + const view = self.grabbed_view; + + const dx: f64 = self.wlr_cursor.x - self.grab_x; + const dy: f64 = self.wlr_cursor.y - self.grab_y; - var dx: f64 = self.wlr_cursor.x - self.grab_x; - var dy: f64 = self.wlr_cursor.y - self.grab_y; var x: f64 = @intToFloat(f64, view.?.x); var y: f64 = @intToFloat(f64, view.?.y); var width = @intToFloat(f64, self.grab_width); var height = @intToFloat(f64, self.grab_height); + if (self.resize_edges & @intCast(u32, c.WLR_EDGE_TOP) != 0) { y = self.grab_y + dy; height -= dy; @@ -177,7 +179,7 @@ pub const Cursor = struct { var sx: f64 = undefined; var sy: f64 = undefined; var opt_surface: ?*c.wlr_surface = null; - var view = self.seat.server.desktop_view_at( + const view = self.seat.server.desktop_view_at( self.wlr_cursor.x, self.wlr_cursor.y, &opt_surface, @@ -196,7 +198,7 @@ pub const Cursor = struct { ); } - var wlr_seat = self.seat.wlr_seat; + const wlr_seat = self.seat.wlr_seat; if (opt_surface) |surface| { const focus_changed = wlr_seat.pointer_state.focused_surface != surface; // "Enter" the surface if necessary. This lets the client know that the @@ -221,8 +223,8 @@ pub const Cursor = struct { fn handle_motion(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) - var cursor = @fieldParentPtr(Cursor, "listen_motion", listener.?); - var event = @ptrCast( + const cursor = @fieldParentPtr(Cursor, "listen_motion", listener.?); + const event = @ptrCast( *c.wlr_event_pointer_motion, @alignCast(@alignOf(*c.wlr_event_pointer_motion), data), ); @@ -242,8 +244,8 @@ 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. - var cursor = @fieldParentPtr(Cursor, "listen_motion_absolute", listener.?); - var event = @ptrCast( + const cursor = @fieldParentPtr(Cursor, "listen_motion_absolute", listener.?); + const event = @ptrCast( *c.wlr_event_pointer_motion_absolute, @alignCast(@alignOf(*c.wlr_event_pointer_motion_absolute), data), ); @@ -254,8 +256,8 @@ pub const Cursor = struct { fn handle_button(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is forwarded by the cursor when a pointer emits a button // event. - var cursor = @fieldParentPtr(Cursor, "listen_button", listener.?); - var event = @ptrCast( + const cursor = @fieldParentPtr(Cursor, "listen_button", listener.?); + const event = @ptrCast( *c.wlr_event_pointer_button, @alignCast(@alignOf(*c.wlr_event_pointer_button), data), ); @@ -271,7 +273,7 @@ pub const Cursor = struct { var sy: f64 = undefined; var surface: ?*c.wlr_surface = null; - var view = cursor.seat.server.desktop_view_at( + const view = cursor.seat.server.desktop_view_at( cursor.wlr_cursor.x, cursor.wlr_cursor.y, &surface, @@ -293,8 +295,8 @@ pub const Cursor = struct { fn handle_axis(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. - var cursor = @fieldParentPtr(Cursor, "listen_axis", listener.?); - var event = @ptrCast( + const cursor = @fieldParentPtr(Cursor, "listen_axis", listener.?); + const event = @ptrCast( *c.wlr_event_pointer_axis, @alignCast(@alignOf(*c.wlr_event_pointer_axis), data), ); @@ -315,15 +317,15 @@ 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. - var cursor = @fieldParentPtr(Cursor, "listen_frame", listener.?); + const cursor = @fieldParentPtr(Cursor, "listen_frame", listener.?); // Notify the client with pointer focus of the frame event. c.wlr_seat_pointer_notify_frame(cursor.seat.wlr_seat); } fn handle_request_set_cursor(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is rasied by the seat when a client provides a cursor image - var cursor = @fieldParentPtr(Cursor, "listen_request_set_cursor", listener.?); - var event = @ptrCast( + const cursor = @fieldParentPtr(Cursor, "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), ); diff --git a/src/keyboard.zig b/src/keyboard.zig index 1f84772..6aab328 100644 --- a/src/keyboard.zig +++ b/src/keyboard.zig @@ -52,7 +52,7 @@ pub const Keyboard = struct { fn handle_modifiers(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. */ - var keyboard = @fieldParentPtr(Keyboard, "listen_modifiers", listener.?); + const keyboard = @fieldParentPtr(Keyboard, "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 diff --git a/src/main.zig b/src/main.zig index 2367ba0..c5c2f67 100644 --- a/src/main.zig +++ b/src/main.zig @@ -18,7 +18,7 @@ pub fn main() !void { // Spawn an instance of alacritty // const argv = [_][]const u8{ "/bin/sh", "-c", "WAYLAND_DEBUG=1 alacritty" }; const argv = [_][]const u8{ "/bin/sh", "-c", "alacritty" }; - var child = try std.ChildProcess.init(&argv, std.heap.c_allocator); + const child = try std.ChildProcess.init(&argv, std.heap.c_allocator); try std.ChildProcess.spawn(child); server.run(); diff --git a/src/output.zig b/src/output.zig index 6f96a61..f0f1118 100644 --- a/src/output.zig +++ b/src/output.zig @@ -55,8 +55,8 @@ pub const Output = struct { fn handle_frame(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). - var output = @fieldParentPtr(Output, "listen_frame", listener.?); - var renderer = output.server.wlr_renderer; + const output = @fieldParentPtr(Output, "listen_frame", listener.?); + const renderer = output.server.wlr_renderer; var now: c.struct_timespec = undefined; _ = c.clock_gettime(c.CLOCK_MONOTONIC, &now); @@ -79,7 +79,7 @@ pub const Output = struct { // The first view in the list is "on top" so iterate in reverse. var it = output.server.views.last; while (it) |node| : (it = node.prev) { - var view = &node.data; + const view = &node.data; if (!view.mapped) { // An unmapped view should not be rendered. continue; @@ -112,18 +112,18 @@ pub const Output = struct { fn render_surface(opt_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void { // wlroots says this will never be null - var surface = opt_surface.?; + const surface = opt_surface.?; // This function is called for every surface that needs to be rendered. - var rdata = @ptrCast(*RenderData, @alignCast(@alignOf(RenderData), data)); - var view = rdata.view; - var output = rdata.output; + const rdata = @ptrCast(*RenderData, @alignCast(@alignOf(RenderData), data)); + const view = rdata.view; + const output = rdata.output; // We first obtain a wlr_texture, which is a GPU resource. wlroots // automatically handles negotiating these with the client. The underlying // resource could be an opaque handle passed from the client, or the client // could have sent a pixel buffer which we copied to the GPU, or a few other // means. You don't have to worry about this, wlroots takes care of it. - var texture = c.wlr_surface_get_texture(surface); + const texture = c.wlr_surface_get_texture(surface); if (texture == null) { return; } @@ -140,7 +140,7 @@ pub const Output = struct { // We also have to apply the scale factor for HiDPI outputs. This is only // part of the puzzle, TinyWL does not fully support HiDPI. - var box = c.wlr_box{ + const box = c.wlr_box{ .x = @floatToInt(c_int, ox * output.scale), .y = @floatToInt(c_int, oy * output.scale), .width = @floatToInt(c_int, @intToFloat(f32, surface.current.width) * output.scale), @@ -157,7 +157,7 @@ pub const Output = struct { // Naturally you can do this any way you like, for example to make a 3D // compositor. var matrix: [9]f32 = undefined; - var transform = c.wlr_output_transform_invert(surface.current.transform); + const transform = c.wlr_output_transform_invert(surface.current.transform); c.wlr_matrix_project_box(&matrix, &box, transform, 0.0, &output.transform_matrix); // This takes our matrix, the texture, and an alpha, and performs the actual diff --git a/src/seat.zig b/src/seat.zig index 5e6e7b0..b9d0ac1 100644 --- a/src/seat.zig +++ b/src/seat.zig @@ -47,7 +47,7 @@ pub const Seat = struct { fn add_keyboard(self: *@This(), device: *c.wlr_input_device) !void { c.wlr_seat_set_keyboard(self.wlr_seat, device); - var node = try self.keyboards.allocateNode(self.server.allocator); + const node = try self.keyboards.allocateNode(self.server.allocator); try node.data.init(self, device); self.keyboards.append(node); } @@ -62,8 +62,8 @@ pub const Seat = struct { fn handle_new_input(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // This event is raised by the backend when a new input device becomes available. - var seat = @fieldParentPtr(Seat, "listen_new_input", listener.?); - var device = @ptrCast(*c.wlr_input_device, @alignCast(@alignOf(*c.wlr_input_device), data)); + const seat = @fieldParentPtr(Seat, "listen_new_input", listener.?); + const device = @ptrCast(*c.wlr_input_device, @alignCast(@alignOf(*c.wlr_input_device), data)); switch (device.type) { .WLR_INPUT_DEVICE_KEYBOARD => seat.add_keyboard(device) catch unreachable, diff --git a/src/server.zig b/src/server.zig index d86e093..a5639a7 100644 --- a/src/server.zig +++ b/src/server.zig @@ -144,11 +144,11 @@ pub const Server = struct { } fn handle_new_output(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - var server = @fieldParentPtr(Server, "listen_new_output", listener.?); - var wlr_output = @ptrCast(*c.wlr_output, @alignCast(@alignOf(*c.wlr_output), data)); + const server = @fieldParentPtr(Server, "listen_new_output", listener.?); + const wlr_output = @ptrCast(*c.wlr_output, @alignCast(@alignOf(*c.wlr_output), data)); // TODO: Handle failure - var node = server.outputs.allocateNode(server.allocator) catch unreachable; + const node = server.outputs.allocateNode(server.allocator) catch unreachable; node.data.init(server, wlr_output) catch unreachable; server.outputs.append(node); } @@ -156,15 +156,15 @@ pub const Server = struct { fn handle_new_xdg_surface(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. - var server = @fieldParentPtr(Server, "listen_new_xdg_surface", listener.?); - var wlr_xdg_surface = @ptrCast(*c.wlr_xdg_surface, @alignCast(@alignOf(*c.wlr_xdg_surface), data)); + const server = @fieldParentPtr(Server, "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) { return; } // Create a View to handle this toplevel surface - var node = server.views.allocateNode(server.allocator) catch unreachable; + const node = server.views.allocateNode(server.allocator) catch unreachable; node.data.init(server, wlr_xdg_surface); server.views.append(node); } diff --git a/src/view.zig b/src/view.zig index 101ea68..546e892 100644 --- a/src/view.zig +++ b/src/view.zig @@ -34,26 +34,26 @@ pub const View = struct { self.listen_destroy.notify = handle_destroy; c.wl_signal_add(&self.wlr_xdg_surface.events.destroy, &self.listen_destroy); - // var toplevel = xdg_surface.unnamed_160.toplevel; + // const toplevel = xdg_surface.unnamed_160.toplevel; // c.wl_signal_add(&toplevel.events.request_move, &view.request_move); // c.wl_signal_add(&toplevel.events.request_resize, &view.request_resize); } fn handle_map(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { // Called when the surface is mapped, or ready to display on-screen. - var view = @fieldParentPtr(View, "listen_map", listener.?); + const view = @fieldParentPtr(View, "listen_map", listener.?); view.mapped = true; view.focus(view.wlr_xdg_surface.surface); } fn handle_unmap(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - var view = @fieldParentPtr(View, "listen_unmap", listener.?); + const view = @fieldParentPtr(View, "listen_unmap", listener.?); view.mapped = false; } fn handle_destroy(listener: ?*c.wl_listener, data: ?*c_void) callconv(.C) void { - var view = @fieldParentPtr(View, "listen_destroy", listener.?); - var server = view.server; + const view = @fieldParentPtr(View, "listen_destroy", listener.?); + const server = view.server; var it = server.views.first; const target = while (it) |node| : (it = node.next) { @@ -88,7 +88,7 @@ pub const View = struct { // Deactivate the previously focused surface. This lets the client know // it no longer has focus and the client will repaint accordingly, e.g. // stop displaying a caret. - var prev_xdg_surface = c.wlr_xdg_surface_from_wlr_surface(prev_surface); + const prev_xdg_surface = c.wlr_xdg_surface_from_wlr_surface(prev_surface); _ = c.wlr_xdg_toplevel_set_activated(prev_xdg_surface, false); } @@ -110,7 +110,7 @@ pub const View = struct { // 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 without additional work on your part. - var keyboard: *c.wlr_keyboard = c.wlr_seat_get_keyboard(wlr_seat); + const keyboard: *c.wlr_keyboard = c.wlr_seat_get_keyboard(wlr_seat); c.wlr_seat_keyboard_notify_enter( wlr_seat, self.wlr_xdg_surface.surface, @@ -126,15 +126,15 @@ pub const View = struct { // coordinates lx and ly (in output Layout Coordinates). If so, it sets the // surface pointer to that wlr_surface and the sx and sy coordinates to the // coordinates relative to that surface's top-left corner. - var view_sx = lx - @intToFloat(f64, self.x); - var view_sy = ly - @intToFloat(f64, self.y); + const view_sx = lx - @intToFloat(f64, self.x); + const view_sy = ly - @intToFloat(f64, self.y); // This variable seems to have been unsued in TinyWL // struct wlr_surface_state *state = &view->xdg_surface->surface->current; var _sx: f64 = undefined; var _sy: f64 = undefined; - var _surface = c.wlr_xdg_surface_surface_at(self.wlr_xdg_surface, view_sx, view_sy, &_sx, &_sy); + const _surface = c.wlr_xdg_surface_surface_at(self.wlr_xdg_surface, view_sx, view_sy, &_sx, &_sy); if (_surface) |surface_at| { sx.* = _sx;