Nulo/river
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Make all things const

Browse source 
The quest for idiomatic zig continues
This commit is contained in:
Isaac Freund 2020-03-24 20:35:45 +01:00
parent 4872a68378
commit b3bad0ca93
No known key found for this signature in database
GPG key ID: 86DED400DDFD7A11
7 changed files with 51 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/cursor.zig
View file

@ -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),
);

2
src/keyboard.zig
View file

@ -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

2
src/main.zig
View file

@ -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();

20
src/output.zig
View file

@ -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

6
src/seat.zig
View file

@ -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,

12
src/server.zig
View file

@ -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);
}

20
src/view.zig
View file

@ -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;