WIP massive refactor

src/view.zig

@@ -0,0 +1,92 @@
+const std = @import("std");
+const c = @import("c.zig").c;
+
+pub const View = struct {
+    server: *Server,
+    xdg_surface: *c.wlr_xdg_surface,
+    map: c.wl_listener,
+    unmap: c.wl_listener,
+    destroy: c.wl_listener,
+    request_move: c.wl_listener,
+    request_resize: c.wl_listener,
+    mapped: bool,
+    x: c_int,
+    y: c_int,
+};
+
+fn focus_view(view: *View, surface: *c.wlr_surface) void {
+    const server = view.server;
+    const seat = server.*.seat;
+    const prev_surface = seat.*.keyboard_state.focused_surface;
+
+    if (prev_surface == surface) {
+        // Don't re-focus an already focused surface.
+        return;
+    }
+
+    if (prev_surface != null) {
+        // 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);
+        _ = c.wlr_xdg_toplevel_set_activated(prev_xdg_surface, false);
+    }
+
+    // Find the index
+    const idx = for (server.*.views.span()) |*v, i| {
+        if (v == view) {
+            break i;
+        }
+    } else unreachable;
+
+    // Move the view to the front
+    server.*.views.append(server.*.views.orderedRemove(idx)) catch unreachable;
+
+    var moved_view = &server.*.views.span()[server.*.views.span().len - 1];
+
+    // Activate the new surface
+    _ = c.wlr_xdg_toplevel_set_activated(moved_view.*.xdg_surface, true);
+
+    // 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_seat_get_keyboard(seat);
+    c.wlr_seat_keyboard_notify_enter(seat, moved_view.*.xdg_surface.*.surface, &keyboard.*.keycodes, keyboard.*.num_keycodes, &keyboard.*.modifiers);
+}
+
+fn view_at(view: *View, lx: f64, ly: f64, surface: *?*c.wlr_surface, sx: *f64, sy: *f64) bool {
+    // XDG toplevels may have nested surfaces, such as popup windows for context
+    // menus or tooltips. This function tests if any of those are underneath the
+    // 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, view.*.x);
+    var view_sy = ly - @intToFloat(f64, view.*.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(view.*.xdg_surface, view_sx, view_sy, &_sx, &_sy);
+
+    if (_surface) |surface_at| {
+        sx.* = _sx;
+        sy.* = _sy;
+        surface.* = surface_at;
+        return true;
+    }
+
+    return false;
+}
+
+fn desktop_view_at(server: *Server, lx: f64, ly: f64, surface: *?*c.wlr_surface, sx: *f64, sy: *f64) ?*View {
+    // This iterates over all of our surfaces and attempts to find one under the
+    // cursor. This relies on server.*.views being ordered from top-to-bottom.
+    for (server.*.views.span()) |*view| {
+        if (view_at(view, lx, ly, surface, sx, sy)) {
+            return view;
+        }
+    }
+    return null;
+}