Update to new wlroots.

Turns out that the one on Github is ancient and the project was moved
long ago ... which is quite annoying that. No wonder where all the
confusion was coming from.

2 files changed, 391 insertions, 430 deletions

diff --git a/harness/src/wl.c b/harness/src/wl.c
index 2bbef59..1535c6d 100644
--- a/harness/src/wl.c
+++ b/harness/src/wl.c
@@ -1,11 +1,11 @@
 #define _POSIX_C_SOURCE 200112L
 
-#include "wl.h"
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
+#include <wl.h>
+
 // This macro is responsible for calling a handler on a plugin. This macro will
 // acquire the plugin's lock, call the member with the arguments and update the
 // state.
@@ -24,13 +24,14 @@
     plugin_run_requested_actions(pl__);                                        \
   } while (0)
 
-static void focus_view(struct tinywl_view *view, struct wlr_surface *surface)
+static void focus_toplevel(struct tinywl_toplevel *toplevel,
+                           struct wlr_surface *surface)
 {
   /* Note: this function only deals with keyboard focus. */
-  if (view == NULL) {
+  if (toplevel == NULL) {
     return;
   }
-  struct tinywl_server *server = view->server;
+  struct tinywl_server *server = toplevel->server;
   struct wlr_seat *seat = server->seat;
   struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface;
   if (prev_surface == surface) {
@@ -43,24 +44,29 @@ static void focus_view(struct tinywl_view *view, struct wlr_surface *surface)
      * it no longer has focus and the client will repaint accordingly, e.g.
      * stop displaying a caret.
      */
-    struct wlr_xdg_surface *previous =
-        wlr_xdg_surface_from_wlr_surface(seat->keyboard_state.focused_surface);
-    wlr_xdg_toplevel_set_activated(previous, false);
+    struct wlr_xdg_toplevel *prev_toplevel =
+        wlr_xdg_toplevel_try_from_wlr_surface(prev_surface);
+    if (prev_toplevel != NULL) {
+      wlr_xdg_toplevel_set_activated(prev_toplevel, false);
+    }
   }
   struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat);
-  /* Move the view to the front */
-  wl_list_remove(&view->link);
-  wl_list_insert(&server->views, &view->link);
+  /* Move the toplevel to the front */
+  wlr_scene_node_raise_to_top(&toplevel->scene_tree->node);
+  wl_list_remove(&toplevel->link);
+  wl_list_insert(&server->toplevels, &toplevel->link);
   /* Activate the new surface */
-  wlr_xdg_toplevel_set_activated(view->xdg_surface, true);
+  wlr_xdg_toplevel_set_activated(toplevel->xdg_toplevel, 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.
    */
-  wlr_seat_keyboard_notify_enter(seat, view->xdg_surface->surface,
-                                 keyboard->keycodes, keyboard->num_keycodes,
-                                 &keyboard->modifiers);
+  if (keyboard != NULL) {
+    wlr_seat_keyboard_notify_enter(seat, toplevel->xdg_toplevel->base->surface,
+                                   keyboard->keycodes, keyboard->num_keycodes,
+                                   &keyboard->modifiers);
+  }
 }
 
 static void keyboard_handle_modifiers(struct wl_listener *listener, void *data)
@@ -75,10 +81,38 @@ static void keyboard_handle_modifiers(struct wl_listener *listener, void *data)
    * same seat. You can swap out the underlying wlr_keyboard like this and
    * wlr_seat handles this transparently.
    */
-  wlr_seat_set_keyboard(keyboard->server->seat, keyboard->device);
+  wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr_keyboard);
   /* Send modifiers to the client. */
   wlr_seat_keyboard_notify_modifiers(keyboard->server->seat,
-                                     &keyboard->device->keyboard->modifiers);
+                                     &keyboard->wlr_keyboard->modifiers);
+}
+
+static bool handle_keybinding(struct tinywl_server *server, xkb_keysym_t sym)
+{
+  /*
+   * Here we handle compositor keybindings. This is when the compositor is
+   * processing keys, rather than passing them on to the client for its own
+   * processing.
+   *
+   * This function assumes Alt is held down.
+   */
+  switch (sym) {
+  case XKB_KEY_Escape:
+    wl_display_terminate(server->wl_display);
+    break;
+  case XKB_KEY_F1:
+    /* Cycle to the next toplevel */
+    if (wl_list_length(&server->toplevels) < 2) {
+      break;
+    }
+    struct tinywl_toplevel *next_toplevel =
+        wl_container_of(server->toplevels.prev, next_toplevel, link);
+    focus_toplevel(next_toplevel, next_toplevel->xdg_toplevel->base->surface);
+    break;
+  default:
+    return false;
+  }
+  return true;
 }
 
 static void keyboard_handle_key(struct wl_listener *listener, void *data)
@@ -86,66 +120,79 @@ static void keyboard_handle_key(struct wl_listener *listener, void *data)
   /* This event is raised when a key is pressed or released. */
   struct tinywl_keyboard *keyboard = wl_container_of(listener, keyboard, key);
   struct tinywl_server *server = keyboard->server;
-  struct wlr_event_keyboard_key *event = data;
+  struct wlr_keyboard_key_event *event = data;
   struct wlr_seat *seat = server->seat;
 
   /* Translate libinput keycode -> xkbcommon */
   uint32_t keycode = event->keycode + 8;
   /* Get a list of keysyms based on the keymap for this keyboard */
   const xkb_keysym_t *syms;
-  int nsyms = xkb_state_key_get_syms(keyboard->device->keyboard->xkb_state,
-                                     keycode, &syms);
-  uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->device->keyboard);
+  int nsyms =
+      xkb_state_key_get_syms(keyboard->wlr_keyboard->xkb_state, keycode, &syms);
+
+  int handled = false;
+  uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr_keyboard);
   uint32_t codepoint;
   /* Pass the information along to the plugin for the plugin to handle. The
    * plugin will return via 'handled' whether or not the key event was handled
    * or not. */
-  int handled = 0;
   if (nsyms > 0) {
     codepoint =
-        xkb_state_key_get_utf32(keyboard->device->keyboard->xkb_state, keycode);
+        xkb_state_key_get_utf32(keyboard->wlr_keyboard->xkb_state, keycode);
     plugin_call_update_state(server->plugin, plugin_handle_keybinding,
-                             keyboard->device, event, modifiers, syms[0],
+                             keyboard->wlr_keyboard, event, modifiers, syms[0],
                              codepoint, &handled);
   }
+}
 
-  // if (!handled) {
-  //   /* Otherwise, we pass it along to the client. */
-  //   wlr_seat_set_keyboard(seat, keyboard->device);
-  //   wlr_seat_keyboard_notify_key(seat, event->time_msec, event->keycode,
-  //                                event->state);
-  // }
+static void keyboard_handle_destroy(struct wl_listener *listener, void *data)
+{
+  /* This event is raised by the keyboard base wlr_input_device to signal
+   * the destruction of the wlr_keyboard. It will no longer receive events
+   * and should be destroyed.
+   */
+  struct tinywl_keyboard *keyboard =
+      wl_container_of(listener, keyboard, destroy);
+  wl_list_remove(&keyboard->modifiers.link);
+  wl_list_remove(&keyboard->key.link);
+  wl_list_remove(&keyboard->destroy.link);
+  wl_list_remove(&keyboard->link);
+  free(keyboard);
 }
 
 static void server_new_keyboard(struct tinywl_server *server,
                                 struct wlr_input_device *device)
 {
-  struct tinywl_keyboard *keyboard = calloc(1, sizeof(struct tinywl_keyboard));
+  struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device);
+
+  struct tinywl_keyboard *keyboard = calloc(1, sizeof(*keyboard));
   keyboard->server = server;
-  keyboard->device = device;
+  keyboard->wlr_keyboard = wlr_keyboard;
 
-  /* We need to prepare an XKB keymap and assign it to the keyboard. This
-   * assumes the defaults (e.g. layout = "us"). */
-  struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
   struct xkb_rule_names names = (struct xkb_rule_names){0};
   names.layout = "jr";
   names.variant = "jdvprk";
   names.options = "numpad:mac";
+  /* We need to prepare an XKB keymap and assign it to the keyboard. This
+   * assumes the defaults (e.g. layout = "us"). */
+  struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
   struct xkb_keymap *keymap =
       xkb_keymap_new_from_names(context, &names, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-  wlr_keyboard_set_keymap(device->keyboard, keymap);
+  wlr_keyboard_set_keymap(wlr_keyboard, keymap);
   xkb_keymap_unref(keymap);
   xkb_context_unref(context);
-  wlr_keyboard_set_repeat_info(device->keyboard, 25, 600);
+  wlr_keyboard_set_repeat_info(wlr_keyboard, 25, 600);
 
   /* Here we set up listeners for keyboard events. */
   keyboard->modifiers.notify = keyboard_handle_modifiers;
-  wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);
+  wl_signal_add(&wlr_keyboard->events.modifiers, &keyboard->modifiers);
   keyboard->key.notify = keyboard_handle_key;
-  wl_signal_add(&device->keyboard->events.key, &keyboard->key);
+  wl_signal_add(&wlr_keyboard->events.key, &keyboard->key);
+  keyboard->destroy.notify = keyboard_handle_destroy;
+  wl_signal_add(&device->events.destroy, &keyboard->destroy);
 
-  wlr_seat_set_keyboard(server->seat, device);
+  wlr_seat_set_keyboard(server->seat, keyboard->wlr_keyboard);
 
   /* And add the keyboard to our list of keyboards */
   wl_list_insert(&server->keyboards, &keyboard->link);
@@ -219,71 +266,65 @@ static void seat_request_set_selection(struct wl_listener *listener, void *data)
   wlr_seat_set_selection(server->seat, event->source, event->serial);
 }
 
-static bool view_at(struct tinywl_view *view, double lx, double ly,
-                    struct wlr_surface **surface, double *sx, double *sy)
+static struct tinywl_toplevel *desktop_toplevel_at(struct tinywl_server *server,
+                                                   double lx, double ly,
+                                                   struct wlr_surface **surface,
+                                                   double *sx, double *sy)
 {
-  /*
-   * 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.
-   */
-  double view_sx = lx - view->x;
-  double view_sy = ly - view->y;
-
-  double _sx, _sy;
-  struct wlr_surface *_surface = NULL;
-  _surface = wlr_xdg_surface_surface_at(view->xdg_surface, view_sx, view_sy,
-                                        &_sx, &_sy);
-
-  if (_surface != NULL) {
-    *sx = _sx;
-    *sy = _sy;
-    *surface = _surface;
-    return true;
-  }
-
-  return false;
+  /* This returns the topmost node in the scene at the given layout coords.
+   * We only care about surface nodes as we are specifically looking for a
+   * surface in the surface tree of a tinywl_toplevel. */
+  struct wlr_scene_node *node =
+      wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy);
+  if (node == NULL || node->type != WLR_SCENE_NODE_BUFFER) {
+    return NULL;
+  }
+  struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
+  struct wlr_scene_surface *scene_surface =
+      wlr_scene_surface_try_from_buffer(scene_buffer);
+  if (!scene_surface) {
+    return NULL;
+  }
+
+  *surface = scene_surface->surface;
+  /* Find the node corresponding to the tinywl_toplevel at the root of this
+   * surface tree, it is the only one for which we set the data field. */
+  struct wlr_scene_tree *tree = node->parent;
+  while (tree != NULL && tree->node.data == NULL) {
+    tree = tree->node.parent;
+  }
+  return tree->node.data;
 }
 
-static struct tinywl_view *desktop_view_at(struct tinywl_server *server,
-                                           double lx, double ly,
-                                           struct wlr_surface **surface,
-                                           double *sx, double *sy)
+static void reset_cursor_mode(struct tinywl_server *server)
 {
-  /* 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. */
-  struct tinywl_view *view;
-  wl_list_for_each(view, &server->views, link)
-  {
-    if (view_at(view, lx, ly, surface, sx, sy)) {
-      return view;
-    }
-  }
-  return NULL;
+  /* Reset the cursor mode to passthrough. */
+  server->cursor_mode = TINYWL_CURSOR_PASSTHROUGH;
+  server->grabbed_toplevel = NULL;
 }
 
 static void process_cursor_move(struct tinywl_server *server, uint32_t time)
 {
-  /* Move the grabbed view to the new position. */
-  server->grabbed_view->x = server->cursor->x - server->grab_x;
-  server->grabbed_view->y = server->cursor->y - server->grab_y;
+  /* Move the grabbed toplevel to the new position. */
+  struct tinywl_toplevel *toplevel = server->grabbed_toplevel;
+  wlr_scene_node_set_position(&toplevel->scene_tree->node,
+                              server->cursor->x - server->grab_x,
+                              server->cursor->y - server->grab_y);
 }
 
 static void process_cursor_resize(struct tinywl_server *server, uint32_t time)
 {
   /*
-   * Resizing the grabbed view can be a little bit complicated, because we
-   * could be resizing from any corner or edge. This not only resizes the view
-   * on one or two axes, but can also move the view if you resize from the top
-   * or left edges (or top-left corner).
+   * Resizing the grabbed toplevel can be a little bit complicated, because we
+   * could be resizing from any corner or edge. This not only resizes the
+   * toplevel on one or two axes, but can also move the toplevel if you resize
+   * from the top or left edges (or top-left corner).
    *
-   * Note that I took some shortcuts here. In a more fleshed-out compositor,
-   * you'd wait for the client to prepare a buffer at the new size, then
-   * commit any movement that was prepared.
+   * Note that some shortcuts are taken here. In a more fleshed-out
+   * compositor, you'd wait for the client to prepare a buffer at the new
+   * size, then commit any movement that was prepared.
    */
-  struct tinywl_view *view = server->grabbed_view;
+  struct tinywl_toplevel *toplevel = server->grabbed_toplevel;
   double border_x = server->cursor->x - server->grab_x;
   double border_y = server->cursor->y - server->grab_y;
   int new_left = server->grab_geobox.x;
@@ -317,13 +358,13 @@ static void process_cursor_resize(struct tinywl_server *server, uint32_t time)
   }
 
   struct wlr_box geo_box;
-  wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);
-  view->x = new_left - geo_box.x;
-  view->y = new_top - geo_box.y;
+  wlr_xdg_surface_get_geometry(toplevel->xdg_toplevel->base, &geo_box);
+  wlr_scene_node_set_position(&toplevel->scene_tree->node, new_left - geo_box.x,
+                              new_top - geo_box.y);
 
   int new_width = new_right - new_left;
   int new_height = new_bottom - new_top;
-  wlr_xdg_toplevel_set_size(view->xdg_surface, new_width, new_height);
+  wlr_xdg_toplevel_set_size(toplevel->xdg_toplevel, new_width, new_height);
 }
 
 static void process_cursor_motion(struct tinywl_server *server, uint32_t time)
@@ -338,18 +379,17 @@ static void process_cursor_motion(struct tinywl_server *server, uint32_t time)
     return;
   }
 
-  /* Otherwise, find the view under the pointer and send the event along. */
+  /* Otherwise, find the toplevel under the pointer and send the event along. */
   double sx, sy;
   struct wlr_seat *seat = server->seat;
   struct wlr_surface *surface = NULL;
-  struct tinywl_view *view = desktop_view_at(
+  struct tinywl_toplevel *toplevel = desktop_toplevel_at(
       server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
-  if (!view) {
-    /* If there's no view under the cursor, set the cursor image to a
+  if (!toplevel) {
+    /* If there's no toplevel under the cursor, set the cursor image to a
      * default. This is what makes the cursor image appear when you move it
-     * around the screen, not over any views. */
-    wlr_xcursor_manager_set_cursor_image(server->cursor_mgr, "left_ptr",
-                                         server->cursor);
+     * around the screen, not over any toplevels. */
+    wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default");
   }
   if (surface) {
     /*
@@ -379,13 +419,13 @@ static void server_cursor_motion(struct wl_listener *listener, void *data)
    * pointer motion event (i.e. a delta) */
   struct tinywl_server *server =
       wl_container_of(listener, server, cursor_motion);
-  struct wlr_event_pointer_motion *event = data;
+  struct wlr_pointer_motion_event *event = data;
   /* The cursor doesn't move unless we tell it to. The cursor automatically
    * handles constraining the motion to the output layout, as well as any
    * 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. */
-  wlr_cursor_move(server->cursor, event->device, event->delta_x,
+  wlr_cursor_move(server->cursor, &event->pointer->base, event->delta_x,
                   event->delta_y);
   process_cursor_motion(server, event->time_msec);
 }
@@ -401,8 +441,9 @@ static void server_cursor_motion_absolute(struct wl_listener *listener,
    * emits these events. */
   struct tinywl_server *server =
       wl_container_of(listener, server, cursor_motion_absolute);
-  struct wlr_event_pointer_motion_absolute *event = data;
-  wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y);
+  struct wlr_pointer_motion_absolute_event *event = data;
+  wlr_cursor_warp_absolute(server->cursor, &event->pointer->base, event->x,
+                           event->y);
   process_cursor_motion(server, event->time_msec);
 }
 
@@ -412,21 +453,21 @@ static void server_cursor_button(struct wl_listener *listener, void *data)
    * event. */
   struct tinywl_server *server =
       wl_container_of(listener, server, cursor_button);
-  struct wlr_event_pointer_button *event = data;
+  struct wlr_pointer_button_event *event = data;
   /* Notify the client with pointer focus that a button press has occurred */
   wlr_seat_pointer_notify_button(server->seat, event->time_msec, event->button,
                                  event->state);
   double sx, sy;
-  struct wlr_surface *surface;
-  struct tinywl_view *view = desktop_view_at(
+  struct wlr_surface *surface = NULL;
+  struct tinywl_toplevel *toplevel = desktop_toplevel_at(
       server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
   if (event->state == WLR_BUTTON_RELEASED) {
     /* If you released any buttons, we exit interactive move/resize mode. */
-    server->cursor_mode = TINYWL_CURSOR_PASSTHROUGH;
+    reset_cursor_mode(server);
   }
   else {
     /* Focus that client if the button was _pressed_ */
-    focus_view(view, surface);
+    focus_toplevel(toplevel, surface);
   }
 }
 
@@ -435,7 +476,7 @@ static void server_cursor_axis(struct wl_listener *listener, void *data)
   /* This event is forwarded by the cursor when a pointer emits an axis event,
    * for example when you move the scroll wheel. */
   struct tinywl_server *server = wl_container_of(listener, server, cursor_axis);
-  struct wlr_event_pointer_axis *event = data;
+  struct wlr_pointer_axis_event *event = data;
   /* Notify the client with pointer focus of the axis event. */
   wlr_seat_pointer_notify_axis(server->seat, event->time_msec,
                                event->orientation, event->delta,
@@ -454,131 +495,44 @@ static void server_cursor_frame(struct wl_listener *listener, void *data)
   wlr_seat_pointer_notify_frame(server->seat);
 }
 
-/* Used to move all of the data necessary to render a surface from the top-level
- * frame handler to the per-surface render function. */
-struct render_data {
-  struct wlr_output *output;
-  struct wlr_renderer *renderer;
-  struct tinywl_view *view;
-  struct timespec *when;
-};
-
-static void render_surface(struct wlr_surface *surface, int sx, int sy,
-                           void *data)
-{
-  /* This function is called for every surface that needs to be rendered. */
-  struct render_data *rdata = data;
-  struct tinywl_view *view = rdata->view;
-  struct wlr_output *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. */
-  struct wlr_texture *texture = wlr_surface_get_texture(surface);
-  if (texture == NULL) {
-    return;
-  }
-
-  /* The view has a position in layout coordinates. If you have two displays,
-   * one next to the other, both 1080p, a view on the rightmost display might
-   * have layout coordinates of 2000,100. We need to translate that to
-   * output-local coordinates, or (2000 - 1920). */
-  double ox = 0, oy = 0;
-  wlr_output_layout_output_coords(view->server->output_layout, output, &ox,
-                                  &oy);
-  ox += view->x + sx, oy += view->y + sy;
-
-  /* We also have to apply the scale factor for HiDPI outputs. This is only
-   * part of the puzzle, TinyWL does not fully support HiDPI. */
-  struct wlr_box box = {
-      .x = ox * output->scale,
-      .y = oy * output->scale,
-      .width = surface->current.width * output->scale,
-      .height = surface->current.height * output->scale,
-  };
-
-  /*
-   * Those familiar with OpenGL are also familiar with the role of matricies
-   * in graphics programming. We need to prepare a matrix to render the view
-   * with. wlr_matrix_project_box is a helper which takes a box with a desired
-   * x, y coordinates, width and height, and an output geometry, then
-   * prepares an orthographic projection and multiplies the necessary
-   * transforms to produce a model-view-projection matrix.
-   *
-   * Naturally you can do this any way you like, for example to make a 3D
-   * compositor.
-   */
-  float matrix[9];
-  enum wl_output_transform transform =
-      wlr_output_transform_invert(surface->current.transform);
-  wlr_matrix_project_box(matrix, &box, transform, 0, output->transform_matrix);
-
-  /* This takes our matrix, the texture, and an alpha, and performs the actual
-   * rendering on the GPU. */
-  wlr_render_texture_with_matrix(rdata->renderer, texture, matrix, 1);
-
-  /* This lets the client know that we've displayed that frame and it can
-   * prepare another one now if it likes. */
-  wlr_surface_send_frame_done(surface, rdata->when);
-}
-
 static void output_frame(struct wl_listener *listener, void *data)
 {
   /* This function is called every time an output is ready to display a frame,
    * generally at the output's refresh rate (e.g. 60Hz). */
   struct tinywl_output *output = wl_container_of(listener, output, frame);
-  struct wlr_renderer *renderer = output->server->renderer;
+  struct wlr_scene *scene = output->server->scene;
+
+  struct wlr_scene_output *scene_output =
+      wlr_scene_get_scene_output(scene, output->wlr_output);
+
+  /* Render the scene if needed and commit the output */
+  wlr_scene_output_commit(scene_output, NULL);
 
   struct timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
+  wlr_scene_output_send_frame_done(scene_output, &now);
+}
 
-  /* wlr_output_attach_render makes the OpenGL context current. */
-  if (!wlr_output_attach_render(output->wlr_output, NULL)) {
-    return;
-  }
-  /* The "effective" resolution can change if you rotate your outputs. */
-  int width, height;
-  wlr_output_effective_resolution(output->wlr_output, &width, &height);
-  /* Begin the renderer (calls glViewport and some other GL sanity checks) */
-  wlr_renderer_begin(renderer, width, height);
-
-  float color[4] = {0.3, 0.3, 0.3, 1.0};
-  wlr_renderer_clear(renderer, color);
-
-  /* Each subsequent window we render is rendered on top of the last. Because
-   * our view list is ordered front-to-back, we iterate over it backwards. */
-  struct tinywl_view *view;
-  wl_list_for_each_reverse(view, &output->server->views, link)
-  {
-    if (!view->mapped) {
-      /* An unmapped view should not be rendered. */
-      continue;
-    }
-    struct render_data rdata = {
-        .output = output->wlr_output,
-        .view = view,
-        .renderer = renderer,
-        .when = &now,
-    };
-    /* This calls our render_surface function for each surface among the
-     * xdg_surface's toplevel and popups. */
-    wlr_xdg_surface_for_each_surface(view->xdg_surface, render_surface, &rdata);
-  }
-
-  /* Hardware cursors are rendered by the GPU on a separate plane, and can be
-   * moved around without re-rendering what's beneath them - which is more
-   * efficient. However, not all hardware supports hardware cursors. For this
-   * reason, wlroots provides a software fallback, which we ask it to render
-   * here. wlr_cursor handles configuring hardware vs software cursors for you,
-   * and this function is a no-op when hardware cursors are in use. */
-  wlr_output_render_software_cursors(output->wlr_output, NULL);
-
-  /* Conclude rendering and swap the buffers, showing the final frame
-   * on-screen. */
-  wlr_renderer_end(renderer);
-  wlr_output_commit(output->wlr_output);
+static void output_request_state(struct wl_listener *listener, void *data)
+{
+  /* This function is called when the backend requests a new state for
+   * the output. For example, Wayland and X11 backends request a new mode
+   * when the output window is resized. */
+  struct tinywl_output *output =
+      wl_container_of(listener, output, request_state);
+  const struct wlr_output_event_request_state *event = data;
+  wlr_output_commit_state(output->wlr_output, event->state);
+}
+
+static void output_destroy(struct wl_listener *listener, void *data)
+{
+  struct tinywl_output *output = wl_container_of(listener, output, destroy);
+
+  wl_list_remove(&output->frame.link);
+  wl_list_remove(&output->request_state.link);
+  wl_list_remove(&output->destroy.link);
+  wl_list_remove(&output->link);
+  free(output);
 }
 
 static void server_new_output(struct wl_listener *listener, void *data)
@@ -588,27 +542,46 @@ static void server_new_output(struct wl_listener *listener, void *data)
   struct tinywl_server *server = wl_container_of(listener, server, new_output);
   struct wlr_output *wlr_output = data;
 
+  /* Configures the output created by the backend to use our allocator
+   * and our renderer. Must be done once, before commiting the output */
+  wlr_output_init_render(wlr_output, server->allocator, server->renderer);
+
+  /* The output may be disabled, switch it on. */
+  struct wlr_output_state state;
+  wlr_output_state_init(&state);
+  wlr_output_state_set_enabled(&state, true);
+
   /* Some backends don't have modes. DRM+KMS does, and we need to set a mode
    * before we can use the output. The mode is a tuple of (width, height,
    * refresh rate), and each monitor supports only a specific set of modes. We
    * just pick the monitor's preferred mode, a more sophisticated compositor
    * would let the user configure it. */
-  if (!wl_list_empty(&wlr_output->modes)) {
-    struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
-    wlr_output_set_mode(wlr_output, mode);
-    wlr_output_enable(wlr_output, true);
-    if (!wlr_output_commit(wlr_output)) {
-      return;
-    }
+  struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
+  if (mode != NULL) {
+    wlr_output_state_set_mode(&state, mode);
   }
 
+  /* Atomically applies the new output state. */
+  wlr_output_commit_state(wlr_output, &state);
+  wlr_output_state_finish(&state);
+
   /* Allocates and configures our state for this output */
-  struct tinywl_output *output = calloc(1, sizeof(struct tinywl_output));
+  struct tinywl_output *output = calloc(1, sizeof(*output));
   output->wlr_output = wlr_output;
   output->server = server;
-  /* Sets up a listener for the frame notify event. */
+
+  /* Sets up a listener for the frame event. */
   output->frame.notify = output_frame;
   wl_signal_add(&wlr_output->events.frame, &output->frame);
+
+  /* Sets up a listener for the state request event. */
+  output->request_state.notify = output_request_state;
+  wl_signal_add(&wlr_output->events.request_state, &output->request_state);
+
+  /* Sets up a listener for the destroy event. */
+  output->destroy.notify = output_destroy;
+  wl_signal_add(&wlr_output->events.destroy, &output->destroy);
+
   wl_list_insert(&server->outputs, &output->link);
 
   /* Adds this to the output layout. The add_auto function arranges outputs
@@ -620,72 +593,98 @@ static void server_new_output(struct wl_listener *listener, void *data)
    * display, which Wayland clients can see to find out information about the
    * output (such as DPI, scale factor, manufacturer, etc).
    */
-  wlr_output_layout_add_auto(server->output_layout, wlr_output);
+  struct wlr_output_layout_output *l_output =
+      wlr_output_layout_add_auto(server->output_layout, wlr_output);
+  struct wlr_scene_output *scene_output =
+      wlr_scene_output_create(server->scene, wlr_output);
+  wlr_scene_output_layout_add_output(server->scene_layout, l_output,
+                                     scene_output);
 }
 
-static void xdg_surface_map(struct wl_listener *listener, void *data)
+static void xdg_toplevel_map(struct wl_listener *listener, void *data)
 {
   /* Called when the surface is mapped, or ready to display on-screen. */
-  struct tinywl_view *view = wl_container_of(listener, view, map);
-  plugin_call_update_state(view->server->plugin, plugin_handle_surface, data,
-                           SURFACE_MAP);
-  view->mapped = true;
-  focus_view(view, view->xdg_surface->surface);
+  struct tinywl_toplevel *toplevel = wl_container_of(listener, toplevel, map);
+
+  wl_list_insert(&toplevel->server->toplevels, &toplevel->link);
+
+  plugin_call_update_state(toplevel->server->plugin, plugin_handle_surface,
+                           data, SURFACE_MAP);
+
+  focus_toplevel(toplevel, toplevel->xdg_toplevel->base->surface);
 }
 
-static void xdg_surface_unmap(struct wl_listener *listener, void *data)
+static void xdg_toplevel_unmap(struct wl_listener *listener, void *data)
 {
   /* Called when the surface is unmapped, and should no longer be shown. */
-  struct tinywl_view *view = wl_container_of(listener, view, unmap);
-  plugin_call_update_state(view->server->plugin, plugin_handle_surface, data,
-                           SURFACE_UNMAP);
-  view->mapped = false;
+  struct tinywl_toplevel *toplevel = wl_container_of(listener, toplevel, unmap);
+
+  /* Reset the cursor mode if the grabbed toplevel was unmapped. */
+  if (toplevel == toplevel->server->grabbed_toplevel) {
+    reset_cursor_mode(toplevel->server);
+  }
+
+  plugin_call_update_state(toplevel->server->plugin, plugin_handle_surface,
+                           data, SURFACE_UNMAP);
+
+  wl_list_remove(&toplevel->link);
 }
 
-static void xdg_surface_destroy(struct wl_listener *listener, void *data)
+static void xdg_toplevel_destroy(struct wl_listener *listener, void *data)
 {
-  /* Called when the surface is destroyed and should never be shown again. */
-  struct tinywl_view *view = wl_container_of(listener, view, destroy);
-  plugin_call_update_state(view->server->plugin, plugin_handle_surface, data,
-                           SURFACE_DELETE);
-  wl_list_remove(&view->link);
-  free(view);
+  /* Called when the xdg_toplevel is destroyed. */
+  struct tinywl_toplevel *toplevel =
+      wl_container_of(listener, toplevel, destroy);
+
+  wl_list_remove(&toplevel->map.link);
+  wl_list_remove(&toplevel->unmap.link);
+  wl_list_remove(&toplevel->destroy.link);
+  wl_list_remove(&toplevel->request_move.link);
+  wl_list_remove(&toplevel->request_resize.link);
+  wl_list_remove(&toplevel->request_maximize.link);
+  wl_list_remove(&toplevel->request_fullscreen.link);
+
+  plugin_call_update_state(toplevel->server->plugin, plugin_handle_surface,
+                           data, SURFACE_DELETE);
+
+  free(toplevel);
 }
 
-static void begin_interactive(struct tinywl_view *view,
+static void begin_interactive(struct tinywl_toplevel *toplevel,
                               enum tinywl_cursor_mode mode, uint32_t edges)
 {
   /* This function sets up an interactive move or resize operation, where the
    * compositor stops propegating pointer events to clients and instead
    * consumes them itself, to move or resize windows. */
-  struct tinywl_server *server = view->server;
+  struct tinywl_server *server = toplevel->server;
   struct wlr_surface *focused_surface =
       server->seat->pointer_state.focused_surface;
-  if (view->xdg_surface->surface != focused_surface) {
+  if (toplevel->xdg_toplevel->base->surface !=
+      wlr_surface_get_root_surface(focused_surface)) {
     /* Deny move/resize requests from unfocused clients. */
     return;
   }
-  server->grabbed_view = view;
+  server->grabbed_toplevel = toplevel;
   server->cursor_mode = mode;
 
   if (mode == TINYWL_CURSOR_MOVE) {
-    server->grab_x = server->cursor->x - view->x;
-    server->grab_y = server->cursor->y - view->y;
+    server->grab_x = server->cursor->x - toplevel->scene_tree->node.x;
+    server->grab_y = server->cursor->y - toplevel->scene_tree->node.y;
   }
   else {
     struct wlr_box geo_box;
-    wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);
+    wlr_xdg_surface_get_geometry(toplevel->xdg_toplevel->base, &geo_box);
 
-    double border_x =
-        (view->x + geo_box.x) + ((edges & WLR_EDGE_RIGHT) ? geo_box.width : 0);
-    double border_y = (view->y + geo_box.y) +
+    double border_x = (toplevel->scene_tree->node.x + geo_box.x) +
+                      ((edges & WLR_EDGE_RIGHT) ? geo_box.width : 0);
+    double border_y = (toplevel->scene_tree->node.y + geo_box.y) +
                       ((edges & WLR_EDGE_BOTTOM) ? geo_box.height : 0);
     server->grab_x = server->cursor->x - border_x;
     server->grab_y = server->cursor->y - border_y;
 
     server->grab_geobox = geo_box;
-    server->grab_geobox.x += view->x;
-    server->grab_geobox.y += view->y;
+    server->grab_geobox.x += toplevel->scene_tree->node.x;
+    server->grab_geobox.y += toplevel->scene_tree->node.y;
 
     server->resize_edges = edges;
   }
@@ -698,8 +697,9 @@ static void xdg_toplevel_request_move(struct wl_listener *listener, void *data)
    * decorations. Note that a more sophisticated compositor should check the
    * provided serial against a list of button press serials sent to this
    * client, to prevent the client from requesting this whenever they want. */
-  struct tinywl_view *view = wl_container_of(listener, view, request_move);
-  begin_interactive(view, TINYWL_CURSOR_MOVE, 0);
+  struct tinywl_toplevel *toplevel =
+      wl_container_of(listener, toplevel, request_move);
+  begin_interactive(toplevel, TINYWL_CURSOR_MOVE, 0);
 }
 
 static void xdg_toplevel_request_resize(struct wl_listener *listener,
@@ -711,8 +711,31 @@ static void xdg_toplevel_request_resize(struct wl_listener *listener,
    * provided serial against a list of button press serials sent to this
    * client, to prevent the client from requesting this whenever they want. */
   struct wlr_xdg_toplevel_resize_event *event = data;
-  struct tinywl_view *view = wl_container_of(listener, view, request_resize);
-  begin_interactive(view, TINYWL_CURSOR_RESIZE, event->edges);
+  struct tinywl_toplevel *toplevel =
+      wl_container_of(listener, toplevel, request_resize);
+  begin_interactive(toplevel, TINYWL_CURSOR_RESIZE, event->edges);
+}
+
+static void xdg_toplevel_request_maximize(struct wl_listener *listener,
+                                          void *data)
+{
+  /* This event is raised when a client would like to maximize itself,
+   * typically because the user clicked on the maximize button on
+   * client-side decorations. tinywl doesn't support maximization, but
+   * to conform to xdg-shell protocol we still must send a configure.
+   * wlr_xdg_surface_schedule_configure() is used to send an empty reply. */
+  struct tinywl_toplevel *toplevel =
+      wl_container_of(listener, toplevel, request_maximize);
+  wlr_xdg_surface_schedule_configure(toplevel->xdg_toplevel->base);
+}
+
+static void xdg_toplevel_request_fullscreen(struct wl_listener *listener,
+                                            void *data)
+{
+  /* Just as with request_maximize, we must send a configure here. */
+  struct tinywl_toplevel *toplevel =
+      wl_container_of(listener, toplevel, request_fullscreen);
+  wlr_xdg_surface_schedule_configure(toplevel->xdg_toplevel->base);
 }
 
 static void server_new_xdg_surface(struct wl_listener *listener, void *data)
@@ -722,32 +745,52 @@ static void server_new_xdg_surface(struct wl_listener *listener, void *data)
   struct tinywl_server *server =
       wl_container_of(listener, server, new_xdg_surface);
   struct wlr_xdg_surface *xdg_surface = data;
-  if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
+
+  /* We must add xdg popups to the scene graph so they get rendered. The
+   * wlroots scene graph provides a helper for this, but to use it we must
+   * provide the proper parent scene node of the xdg popup. To enable this,
+   * we always set the user data field of xdg_surfaces to the corresponding
+   * scene node. */
+  if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) {
+    struct wlr_xdg_surface *parent =
+        wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
+    assert(parent != NULL);
+    struct wlr_scene_tree *parent_tree = parent->data;
+    xdg_surface->data = wlr_scene_xdg_surface_create(parent_tree, xdg_surface);
     return;
   }
+  assert(xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL);
 
-  /* Allocate a tinywl_view for this surface */
-  struct tinywl_view *view = calloc(1, sizeof(struct tinywl_view));
-  view->server = server;
-  view->xdg_surface = xdg_surface;
+  /* Allocate a tinywl_toplevel for this surface */
+  struct tinywl_toplevel *toplevel = calloc(1, sizeof(*toplevel));
+  toplevel->server = server;
+  toplevel->xdg_toplevel = xdg_surface->toplevel;
+  toplevel->scene_tree = wlr_scene_xdg_surface_create(
+      &toplevel->server->scene->tree, toplevel->xdg_toplevel->base);
+  toplevel->scene_tree->node.data = toplevel;
+  xdg_surface->data = toplevel->scene_tree;
 
   /* Listen to the various events it can emit */
-  view->map.notify = xdg_surface_map;
-  wl_signal_add(&xdg_surface->events.map, &view->map);
-  view->unmap.notify = xdg_surface_unmap;
-  wl_signal_add(&xdg_surface->events.unmap, &view->unmap);
-  view->destroy.notify = xdg_surface_destroy;
-  wl_signal_add(&xdg_surface->events.destroy, &view->destroy);
+  toplevel->map.notify = xdg_toplevel_map;
+  wl_signal_add(&xdg_surface->surface->events.map, &toplevel->map);
+  toplevel->unmap.notify = xdg_toplevel_unmap;
+  wl_signal_add(&xdg_surface->surface->events.unmap, &toplevel->unmap);
+  toplevel->destroy.notify = xdg_toplevel_destroy;
+  wl_signal_add(&xdg_surface->events.destroy, &toplevel->destroy);
 
   /* cotd */
-  struct wlr_xdg_toplevel *toplevel = xdg_surface->toplevel;
-  view->request_move.notify = xdg_toplevel_request_move;
-  wl_signal_add(&toplevel->events.request_move, &view->request_move);
-  view->request_resize.notify = xdg_toplevel_request_resize;
-  wl_signal_add(&toplevel->events.request_resize, &view->request_resize);
-
-  /* Add it to the list of views. */
-  wl_list_insert(&server->views, &view->link);
+  struct wlr_xdg_toplevel *xdg_toplevel = xdg_surface->toplevel;
+  toplevel->request_move.notify = xdg_toplevel_request_move;
+  wl_signal_add(&xdg_toplevel->events.request_move, &toplevel->request_move);
+  toplevel->request_resize.notify = xdg_toplevel_request_resize;
+  wl_signal_add(&xdg_toplevel->events.request_resize,
+                &toplevel->request_resize);
+  toplevel->request_maximize.notify = xdg_toplevel_request_maximize;
+  wl_signal_add(&xdg_toplevel->events.request_maximize,
+                &toplevel->request_maximize);
+  toplevel->request_fullscreen.notify = xdg_toplevel_request_fullscreen;
+  wl_signal_add(&xdg_toplevel->events.request_fullscreen,
+                &toplevel->request_fullscreen);
 }
 
 int main(int argc, char *argv[])
@@ -757,11 +800,6 @@ int main(int argc, char *argv[])
   char *plugin = NULL;
 
   int c;
-
-  for (int i = 0; i < argc; ++i) {
-    printf("ARG: %s\n", argv[i]);
-  }
-
   while ((c = getopt(argc, argv, "s:p:h")) != -1) {
     switch (c) {
     case 's':
@@ -771,13 +809,12 @@ int main(int argc, char *argv[])
       plugin = optarg;
       break;
     default:
-      printf("Usage: %s [-s startup command] -p plugin\n", argv[0]);
+      printf("Usage: %s -p [plugin] [-s startup command]\n", argv[0]);
       return 0;
     }
   }
-
   if (optind < argc || !plugin) {
-    printf("Usage: %s [-s startup command] -p plugin\n", argv[0]);
+    printf("Usage: %s -p [plugin] [-s startup command]\n", argv[0]);
     return 0;
   }
 
@@ -788,7 +825,6 @@ int main(int argc, char *argv[])
     return 1;
   }
 
-  // server.plugin.plugin_metaload(argc, argv);
   plugin_cold_start(&server.plugin);
 
   /* The Wayland display is managed by libwayland. It handles accepting
@@ -798,22 +834,43 @@ int main(int argc, char *argv[])
    * output hardware. The autocreate option will choose the most suitable
    * backend based on the current environment, such as opening an X11 window
    * if an X11 server is running. */
-  server.backend = wlr_backend_autocreate(server.wl_display);
+  server.backend = wlr_backend_autocreate(server.wl_display, NULL);
+  if (server.backend == NULL) {
+    wlr_log(WLR_ERROR, "failed to create wlr_backend");
+    return 1;
+  }
 
-  /* If we don't provide a renderer, autocreate makes a GLES2 renderer for us.
+  /* Autocreates a renderer, either Pixman, GLES2 or Vulkan for us. The user
+   * can also specify a renderer using the WLR_RENDERER env var.
    * The renderer is responsible for defining the various pixel formats it
    * supports for shared memory, this configures that for clients. */
-  server.renderer = wlr_backend_get_renderer(server.backend);
+  server.renderer = wlr_renderer_autocreate(server.backend);
+  if (server.renderer == NULL) {
+    wlr_log(WLR_ERROR, "failed to create wlr_renderer");
+    return 1;
+  }
+
   wlr_renderer_init_wl_display(server.renderer, server.wl_display);
 
+  /* Autocreates an allocator for us.
+   * The allocator is the bridge between the renderer and the backend. It
+   * handles the buffer creation, allowing wlroots to render onto the
+   * screen */
+  server.allocator = wlr_allocator_autocreate(server.backend, server.renderer);
+  if (server.allocator == NULL) {
+    wlr_log(WLR_ERROR, "failed to create wlr_allocator");
+    return 1;
+  }
+
   /* This creates some hands-off wlroots interfaces. The compositor is
-   * necessary for clients to allocate surfaces and the data device manager
+   * necessary for clients to allocate surfaces, the subcompositor allows to
+   * assign the role of subsurfaces to surfaces and the data device manager
    * handles the clipboard. Each of these wlroots interfaces has room for you
    * to dig your fingers in and play with their behavior if you want. Note that
    * the clients cannot set the selection directly without compositor approval,
    * see the handling of the request_set_selection event below.*/
-  struct wlr_compositor *compositor;
-  compositor = wlr_compositor_create(server.wl_display, server.renderer);
+  wlr_compositor_create(server.wl_display, 5, server.renderer);
+  wlr_subcompositor_create(server.wl_display);
   wlr_data_device_manager_create(server.wl_display);
 
   /* Creates an output layout, which a wlroots utility for working with an
@@ -826,14 +883,22 @@ int main(int argc, char *argv[])
   server.new_output.notify = server_new_output;
   wl_signal_add(&server.backend->events.new_output, &server.new_output);
 
-  /* Set up our list of views and the xdg-shell. The xdg-shell is a Wayland
-   * protocol which is used for application windows. For more detail on
-   * shells, refer to my article:
-   *
-   * https://drewdevault.com/2018/07/29/Wayland-shells.html
+  /* Create a scene graph. This is a wlroots abstraction that handles all
+   * rendering and damage tracking. All the compositor author needs to do
+   * is add things that should be rendered to the scene graph at the proper
+   * positions and then call wlr_scene_output_commit() to render a frame if
+   * necessary.
    */
-  wl_list_init(&server.views);
-  server.xdg_shell = wlr_xdg_shell_create(server.wl_display);
+  server.scene = wlr_scene_create();
+  server.scene_layout =
+      wlr_scene_attach_output_layout(server.scene, server.output_layout);
+
+  /* Set up xdg-shell version 3. The xdg-shell is a Wayland protocol which is
+   * used for application windows. For more detail on shells, refer to
+   * https://drewdevault.com/2018/07/29/Wayland-shells.html.
+   */
+  wl_list_init(&server.toplevels);
+  server.xdg_shell = wlr_xdg_shell_create(server.wl_display, 3);
   server.new_xdg_surface.notify = server_new_xdg_surface;
   wl_signal_add(&server.xdg_shell->events.new_surface, &server.new_xdg_surface);
 
@@ -847,22 +912,20 @@ int main(int argc, char *argv[])
   /* Creates an xcursor manager, another wlroots utility which loads up
    * Xcursor themes to source cursor images from and makes sure that cursor
    * images are available at all scale factors on the screen (necessary for
-   * HiDPI support). We add a cursor theme at scale factor 1 to begin with. */
+   * HiDPI support). */
   server.cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
-  wlr_xcursor_manager_load(server.cursor_mgr, 1);
 
   /*
    * wlr_cursor *only* displays an image on screen. It does not move around
    * when the pointer moves. However, we can attach input devices to it, and
    * it will generate aggregate events for all of them. In these events, we
    * can choose how we want to process them, forwarding them to clients and
-   * moving the cursor around. More detail on this process is described in my
-   * input handling blog post:
-   *
-   * https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
+   * moving the cursor around. More detail on this process is described in
+   * https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html.
    *
    * And more comments are sprinkled throughout the notify functions above.
    */
+  server.cursor_mode = TINYWL_CURSOR_PASSTHROUGH;
   server.cursor_motion.notify = server_cursor_motion;
   wl_signal_add(&server.cursor->events.motion, &server.cursor_motion);
   server.cursor_motion_absolute.notify = server_cursor_motion_absolute;
@@ -906,21 +969,6 @@ int main(int argc, char *argv[])
     wl_display_destroy(server.wl_display);
     return 1;
   }
-  /* Run the Wayland event loop. This does not return until you exit the
-   * compositor. Starting the backend rigged up all of the necessary event
-   * loop configuration to listen to libinput events, DRM events, generate
-   * frame events at the refresh rate, and so on. */
-  wlr_log(WLR_INFO, "Running Wayland compositor on WAYLAND_DISPLAY=%s", socket);
-  struct wlr_xwayland *xwayland;
-  if ((xwayland = wlr_xwayland_create(server.wl_display, compositor, false))) {
-    printf("======= DISPLAY=%s\n", xwayland->display_name);
-    setenv("DISPLAY", xwayland->display_name, 1);
-  }
-  else {
-    fprintf(
-        stderr,
-        "======= failed to setup XWayland X server. Continuing without it.\n");
-  }
 
   /* Set the WAYLAND_DISPLAY environment variable to our socket and run the
    * startup command if requested. */
@@ -930,11 +978,19 @@ int main(int argc, char *argv[])
       execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL);
     }
   }
-
+  /* Run the Wayland event loop. This does not return until you exit the
+   * compositor. Starting the backend rigged up all of the necessary event
+   * loop configuration to listen to libinput events, DRM events, generate
+   * frame events at the refresh rate, and so on. */
+  wlr_log(WLR_INFO, "Running Wayland compositor on WAYLAND_DISPLAY=%s", socket);
   wl_display_run(server.wl_display);
 
-  /* Once wl_display_run returns, we shut down the server. */
+  /* Once wl_display_run returns, we destroy all clients then shut down the
+   * server. */
   wl_display_destroy_clients(server.wl_display);
+  wlr_scene_node_destroy(&server.scene->tree.node);
+  wlr_xcursor_manager_destroy(server.cursor_mgr);
+  wlr_output_layout_destroy(server.output_layout);
   wl_display_destroy(server.wl_display);
   return 0;
 }
diff --git a/harness/src/wl.h b/harness/src/wl.h
deleted file mode 100644
index f24dc1b..0000000
--- a/harness/src/wl.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include "plugin.h"
-#include <getopt.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <wayland-server-core.h>
-#include <wlr/backend.h>
-#include <wlr/render/wlr_renderer.h>
-#include <wlr/types/wlr_compositor.h>
-#include <wlr/types/wlr_cursor.h>
-#include <wlr/types/wlr_data_device.h>
-#include <wlr/types/wlr_input_device.h>
-#include <wlr/types/wlr_keyboard.h>
-#include <wlr/types/wlr_matrix.h>
-#include <wlr/types/wlr_output.h>
-#include <wlr/types/wlr_output_layout.h>
-#include <wlr/types/wlr_pointer.h>
-#include <wlr/types/wlr_seat.h>
-#include <wlr/types/wlr_xcursor_manager.h>
-#include <wlr/types/wlr_xdg_shell.h>
-#include <wlr/util/log.h>
-#include <wlr/xwayland.h>
-#include <xkbcommon/xkbcommon.h>
-
-/* For brevity's sake, struct members are annotated where they are used. */
-enum tinywl_cursor_mode {
-  TINYWL_CURSOR_PASSTHROUGH,
-  TINYWL_CURSOR_MOVE,
-  TINYWL_CURSOR_RESIZE,
-};
-
-struct tinywl_server {
-  struct wl_display *wl_display;
-  struct wlr_backend *backend;
-  struct wlr_renderer *renderer;
-
-  struct wlr_xdg_shell *xdg_shell;
-  struct wl_listener new_xdg_surface;
-  struct wl_list views;
-
-  struct wlr_cursor *cursor;
-  struct wlr_xcursor_manager *cursor_mgr;
-  struct wl_listener cursor_motion;
-  struct wl_listener cursor_motion_absolute;
-  struct wl_listener cursor_button;
-  struct wl_listener cursor_axis;
-  struct wl_listener cursor_frame;
-
-  struct wlr_seat *seat;
-  struct wl_listener new_input;
-  struct wl_listener request_cursor;
-  struct wl_listener request_set_selection;
-  struct wl_list keyboards;
-  enum tinywl_cursor_mode cursor_mode;
-  struct tinywl_view *grabbed_view;
-  double grab_x, grab_y;
-  struct wlr_box grab_geobox;
-  uint32_t resize_edges;
-
-  struct wlr_output_layout *output_layout;
-  struct wl_list outputs;
-  struct wl_listener new_output;
-
-  plugin_t plugin;
-};
-
-struct tinywl_output {
-  struct wl_list link;
-  struct tinywl_server *server;
-  struct wlr_output *wlr_output;
-  struct wl_listener frame;
-};
-
-struct tinywl_view {
-  struct wl_list link;
-  struct tinywl_server *server;
-  struct wlr_xdg_surface *xdg_surface;
-  struct wl_listener map;
-  struct wl_listener unmap;
-  struct wl_listener destroy;
-  struct wl_listener request_move;
-  struct wl_listener request_resize;
-  bool mapped;
-  int x, y;
-};
-
-struct tinywl_keyboard {
-  struct wl_list link;
-  struct tinywl_server *server;
-  struct wlr_input_device *device;
-
-  struct wl_listener modifiers;
-  struct wl_listener key;
-};