diff options
| -rw-r--r-- | dwl.c | 237 |
1 files changed, 105 insertions, 132 deletions
@@ -69,14 +69,12 @@ struct dwl_server { struct dwl_output { struct wl_list link; - struct dwl_server *server; struct wlr_output *wlr_output; struct wl_listener frame; }; struct dwl_view { struct wl_list link; - struct dwl_server *server; struct wlr_xdg_surface *xdg_surface; struct wl_listener map; struct wl_listener unmap; @@ -89,7 +87,6 @@ struct dwl_view { struct dwl_keyboard { struct wl_list link; - struct dwl_server *server; struct wlr_input_device *device; struct wl_listener modifiers; @@ -106,57 +103,58 @@ typedef union { typedef struct { uint32_t mod; xkb_keysym_t keysym; - void (*func)(struct dwl_server *, const Arg *); + void (*func)(const Arg *); const Arg arg; } Key; typedef struct { unsigned int mod; unsigned int button; - void (*func)(struct dwl_server *, const Arg *); + void (*func)(const Arg *); const Arg arg; } Button; /* function declarations */ static void axisnotify(struct wl_listener *listener, void *data); static void buttonpress(struct wl_listener *listener, void *data); -static void createkeyboard(struct dwl_server *server, - struct wlr_input_device *device); +static void createkeyboard(struct wlr_input_device *device); static void createnotify(struct wl_listener *listener, void *data); static void createoutput(struct wl_listener *listener, void *data); -static void createpointer(struct dwl_server *server, - struct wlr_input_device *device); +static void createpointer(struct wlr_input_device *device); static void cursorframe(struct wl_listener *listener, void *data); static void destroynotify(struct wl_listener *listener, void *data); static void focus(struct dwl_view *view, struct wlr_surface *surface); -static void focusnext(struct dwl_server *server, const Arg *arg); -static void handlemove(struct dwl_server *server, uint32_t time); -static void handleresize(struct dwl_server *server, uint32_t time); +static void focusnext(const Arg *arg); +static void handlemove(uint32_t time); +static void handleresize(uint32_t time); static void inputdevice(struct wl_listener *listener, void *data); -static bool keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym); +static bool keybinding(uint32_t mods, xkb_keysym_t sym); static void keypress(struct wl_listener *listener, void *data); static void keypressmod(struct wl_listener *listener, void *data); static void maprequest(struct wl_listener *listener, void *data); static void motionabsolute(struct wl_listener *listener, void *data); -static void motionnotify(struct dwl_server *server, uint32_t time); +static void motionnotify(uint32_t time); static void motionrelative(struct wl_listener *listener, void *data); -static void movemouse(struct dwl_server *server, const Arg *arg); +static void movemouse(const Arg *arg); static void moverequest(struct wl_listener *listener, void *data); static void moveresize(struct dwl_view *view, unsigned int mode, uint32_t edges); -static void quit(struct dwl_server *server, const Arg *arg); +static void quit(const Arg *arg); static void render(struct wlr_surface *surface, int sx, int sy, void *data); static void renderoutput(struct wl_listener *listener, void *data); -static void resizemouse(struct dwl_server *server, const Arg *arg); +static void resizemouse(const Arg *arg); static void resizerequest(struct wl_listener *listener, void *data); static void setcursor(struct wl_listener *listener, void *data); -static void spawn(struct dwl_server *server, const Arg *arg); +static void spawn(const Arg *arg); static void unmapnotify(struct wl_listener *listener, void *data); static bool xytosurface(struct dwl_view *view, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy); -static struct dwl_view * xytoview(struct dwl_server *server, double lx, double ly, +static struct dwl_view * xytoview(double lx, double ly, struct wlr_surface **surface, double *sx, double *sy); +/* variables */ +static struct dwl_server server; + #include "config.h" /* Used to move all of the data necessary to render a surface from the top-level @@ -173,11 +171,9 @@ axisnotify(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 dwl_server *server = - wl_container_of(listener, server, cursor_axis); struct wlr_event_pointer_axis *event = data; /* Notify the client with pointer focus of the axis event. */ - wlr_seat_pointer_notify_axis(server->seat, + wlr_seat_pointer_notify_axis(server.seat, event->time_msec, event->orientation, event->delta, event->delta_discrete, event->source); } @@ -187,20 +183,18 @@ buttonpress(struct wl_listener *listener, void *data) { /* This event is forwarded by the cursor when a pointer emits a button * event. */ - struct dwl_server *server = - wl_container_of(listener, server, cursor_button); struct wlr_event_pointer_button *event = data; /* Notify the client with pointer focus that a button press has occurred */ - wlr_seat_pointer_notify_button(server->seat, + wlr_seat_pointer_notify_button(server.seat, event->time_msec, event->button, event->state); double sx, sy; - struct wlr_seat *seat = server->seat; + struct wlr_seat *seat = server.seat; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server, - server->cursor->x, server->cursor->y, &surface, &sx, &sy); + struct dwl_view *view = xytoview(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 = CurNormal; + server.cursor_mode = CurNormal; } else { /* Focus that client if the button was _pressed_ */ focus(view, surface); @@ -211,18 +205,17 @@ buttonpress(struct wl_listener *listener, void *data) if (event->button == buttons[i].button && CLEANMASK(mods) == CLEANMASK(buttons[i].mod) && buttons[i].func) { - buttons[i].func(server, &buttons[i].arg); + buttons[i].func(&buttons[i].arg); } } } } void -createkeyboard(struct dwl_server *server, struct wlr_input_device *device) +createkeyboard(struct wlr_input_device *device) { struct dwl_keyboard *keyboard = calloc(1, sizeof(struct dwl_keyboard)); - keyboard->server = server; keyboard->device = device; /* We need to prepare an XKB keymap and assign it to the keyboard. This @@ -242,10 +235,10 @@ createkeyboard(struct dwl_server *server, struct wlr_input_device *device) keyboard->key.notify = keypress; wl_signal_add(&device->keyboard->events.key, &keyboard->key); - wlr_seat_set_keyboard(server->seat, device); + wlr_seat_set_keyboard(server.seat, device); /* And add the keyboard to our list of keyboards */ - wl_list_insert(&server->keyboards, &keyboard->link); + wl_list_insert(&server.keyboards, &keyboard->link); } void @@ -253,8 +246,6 @@ createnotify(struct wl_listener *listener, void *data) { /* This event is raised when wlr_xdg_shell receives a new xdg surface from a * client, either a toplevel (application window) or popup. */ - struct dwl_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) { return; @@ -263,7 +254,6 @@ createnotify(struct wl_listener *listener, void *data) /* Allocate a dwl_view for this surface */ struct dwl_view *view = calloc(1, sizeof(struct dwl_view)); - view->server = server; view->xdg_surface = xdg_surface; /* Listen to the various events it can emit */ @@ -282,7 +272,7 @@ createnotify(struct wl_listener *listener, void *data) wl_signal_add(&toplevel->events.request_resize, &view->request_resize); /* Add it to the list of views. */ - wl_list_insert(&server->views, &view->link); + wl_list_insert(&server.views, &view->link); } void @@ -290,8 +280,6 @@ createoutput(struct wl_listener *listener, void *data) { /* This event is rasied by the backend when a new output (aka a display or * monitor) becomes available. */ - struct dwl_server *server = - wl_container_of(listener, server, new_output); struct wlr_output *wlr_output = data; /* Some backends don't have modes. DRM+KMS does, and we need to set a mode @@ -312,17 +300,16 @@ createoutput(struct wl_listener *listener, void *data) struct dwl_output *output = calloc(1, sizeof(struct dwl_output)); output->wlr_output = wlr_output; - output->server = server; /* Sets up a listener for the frame notify event. */ output->frame.notify = renderoutput; wl_signal_add(&wlr_output->events.frame, &output->frame); - wl_list_insert(&server->outputs, &output->link); + wl_list_insert(&server.outputs, &output->link); /* Adds this to the output layout. The add_auto function arranges outputs * from left-to-right in the order they appear. A more sophisticated * compositor would let the user configure the arrangement of outputs in the * layout. */ - wlr_output_layout_add_auto(server->output_layout, wlr_output); + wlr_output_layout_add_auto(server.output_layout, wlr_output); /* Creating the global adds a wl_output global to the display, which Wayland * clients can see to find out information about the output (such as @@ -331,13 +318,13 @@ createoutput(struct wl_listener *listener, void *data) } void -createpointer(struct dwl_server *server, struct wlr_input_device *device) +createpointer(struct wlr_input_device *device) { /* We don't do anything special with pointers. All of our pointer handling * is proxied through wlr_cursor. On another compositor, you might take this * opportunity to do libinput configuration on the device to set * acceleration, etc. */ - wlr_cursor_attach_input_device(server->cursor, device); + wlr_cursor_attach_input_device(server.cursor, device); } void @@ -347,10 +334,8 @@ cursorframe(struct wl_listener *listener, void *data) * 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. */ - struct dwl_server *server = - wl_container_of(listener, server, cursor_frame); /* Notify the client with pointer focus of the frame event. */ - wlr_seat_pointer_notify_frame(server->seat); + wlr_seat_pointer_notify_frame(server.seat); } void @@ -369,8 +354,7 @@ focus(struct dwl_view *view, struct wlr_surface *surface) if (view == NULL) { return; } - struct dwl_server *server = view->server; - struct wlr_seat *seat = server->seat; + struct wlr_seat *seat = server.seat; struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface; if (prev_surface == surface) { /* Don't re-focus an already focused surface. */ @@ -389,7 +373,7 @@ focus(struct dwl_view *view, struct wlr_surface *surface) 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); + wl_list_insert(&server.views, &view->link); /* Activate the new surface */ wlr_xdg_toplevel_set_activated(view->xdg_surface, true); /* @@ -402,32 +386,32 @@ focus(struct dwl_view *view, struct wlr_surface *surface) } void -focusnext(struct dwl_server *server, const Arg *arg) +focusnext(const Arg *arg) { /* Cycle to the next view */ - if (wl_list_length(&server->views) < 2) { + if (wl_list_length(&server.views) < 2) { return; } struct dwl_view *current_view = wl_container_of( - server->views.next, current_view, link); + server.views.next, current_view, link); struct dwl_view *next_view = wl_container_of( current_view->link.next, next_view, link); focus(next_view, next_view->xdg_surface->surface); /* Move the previous view to the end of the list */ wl_list_remove(¤t_view->link); - wl_list_insert(server->views.prev, ¤t_view->link); + wl_list_insert(server.views.prev, ¤t_view->link); } void -handlemove(struct dwl_server *server, uint32_t time) +handlemove(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; + server.grabbed_view->x = server.cursor->x - server.grab_x; + server.grabbed_view->y = server.cursor->y - server.grab_y; } void -handleresize(struct dwl_server *server, uint32_t time) +handleresize(uint32_t time) { /* * Resizing the grabbed view can be a little bit complicated, because we @@ -439,29 +423,29 @@ handleresize(struct dwl_server *server, uint32_t time) * you'd wait for the client to prepare a buffer at the new size, then * commit any movement that was prepared. */ - struct dwl_view *view = server->grabbed_view; - double dx = server->cursor->x - server->grab_x; - double dy = server->cursor->y - server->grab_y; + struct dwl_view *view = server.grabbed_view; + double dx = server.cursor->x - server.grab_x; + double dy = server.cursor->y - server.grab_y; double x = view->x; double y = view->y; - int width = server->grab_width; - int height = server->grab_height; - if (server->resize_edges & WLR_EDGE_TOP) { - y = server->grab_y + dy; + int width = server.grab_width; + int height = server.grab_height; + if (server.resize_edges & WLR_EDGE_TOP) { + y = server.grab_y + dy; height -= dy; if (height < 1) { y += height; } - } else if (server->resize_edges & WLR_EDGE_BOTTOM) { + } else if (server.resize_edges & WLR_EDGE_BOTTOM) { height += dy; } - if (server->resize_edges & WLR_EDGE_LEFT) { - x = server->grab_x + dx; + if (server.resize_edges & WLR_EDGE_LEFT) { + x = server.grab_x + dx; width -= dx; if (width < 1) { x += width; } - } else if (server->resize_edges & WLR_EDGE_RIGHT) { + } else if (server.resize_edges & WLR_EDGE_RIGHT) { width += dx; } view->x = x; @@ -474,15 +458,13 @@ inputdevice(struct wl_listener *listener, void *data) { /* This event is raised by the backend when a new input device becomes * available. */ - struct dwl_server *server = - wl_container_of(listener, server, new_input); struct wlr_input_device *device = data; switch (device->type) { case WLR_INPUT_DEVICE_KEYBOARD: - createkeyboard(server, device); + createkeyboard(device); break; case WLR_INPUT_DEVICE_POINTER: - createpointer(server, device); + createpointer(device); break; default: break; @@ -491,14 +473,14 @@ inputdevice(struct wl_listener *listener, void *data) * communiciated to the client. In dwl we always have a cursor, even if * there are no pointer devices, so we always include that capability. */ uint32_t caps = WL_SEAT_CAPABILITY_POINTER; - if (!wl_list_empty(&server->keyboards)) { + if (!wl_list_empty(&server.keyboards)) { caps |= WL_SEAT_CAPABILITY_KEYBOARD; } - wlr_seat_set_capabilities(server->seat, caps); + wlr_seat_set_capabilities(server.seat, caps); } bool -keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym) +keybinding(uint32_t mods, xkb_keysym_t sym) { /* * Here we handle compositor keybindings. This is when the compositor is @@ -510,7 +492,7 @@ keybinding(struct dwl_server *server, uint32_t mods, xkb_keysym_t sym) if (sym == keys[i].keysym && CLEANMASK(mods) == CLEANMASK(keys[i].mod) && keys[i].func) { - keys[i].func(server, &keys[i].arg); + keys[i].func(&keys[i].arg); handled = true; } } @@ -523,9 +505,8 @@ keypress(struct wl_listener *listener, void *data) /* This event is raised when a key is pressed or released. */ struct dwl_keyboard *keyboard = wl_container_of(listener, keyboard, key); - struct dwl_server *server = keyboard->server; struct wlr_event_keyboard_key *event = data; - struct wlr_seat *seat = server->seat; + struct wlr_seat *seat = server.seat; /* Translate libinput keycode -> xkbcommon */ uint32_t keycode = event->keycode + 8; @@ -539,7 +520,7 @@ keypress(struct wl_listener *listener, void *data) if (event->state == WLR_KEY_PRESSED) { /* On _press_, attempt to process a compositor keybinding. */ for (int i = 0; i < nsyms; i++) { - handled = keybinding(server, mods, syms[i]) || handled; + handled = keybinding(mods, syms[i]) || handled; } } @@ -564,9 +545,9 @@ keypressmod(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(server.seat, keyboard->device); /* Send modifiers to the client. */ - wlr_seat_keyboard_notify_modifiers(keyboard->server->seat, + wlr_seat_keyboard_notify_modifiers(server.seat, &keyboard->device->keyboard->modifiers); } @@ -588,37 +569,35 @@ motionabsolute(struct wl_listener *listener, void *data) * 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. */ - struct dwl_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); - motionnotify(server, event->time_msec); + wlr_cursor_warp_absolute(server.cursor, event->device, event->x, event->y); + motionnotify(event->time_msec); } void -motionnotify(struct dwl_server *server, uint32_t time) +motionnotify(uint32_t time) { /* If the mode is non-passthrough, delegate to those functions. */ - if (server->cursor_mode == CurMove) { - handlemove(server, time); + if (server.cursor_mode == CurMove) { + handlemove(time); return; - } else if (server->cursor_mode == CurResize) { - handleresize(server, time); + } else if (server.cursor_mode == CurResize) { + handleresize(time); return; } /* Otherwise, find the view under the pointer and send the event along. */ double sx, sy; - struct wlr_seat *seat = server->seat; + struct wlr_seat *seat = server.seat; struct wlr_surface *surface = NULL; - struct dwl_view *view = xytoview(server, - server->cursor->x, server->cursor->y, &surface, &sx, &sy); + struct dwl_view *view = xytoview(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 * 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); + server.cursor_mgr, "left_ptr", server.cursor); } if (surface) { bool focus_changed = seat->pointer_state.focused_surface != surface; @@ -648,26 +627,24 @@ motionrelative(struct wl_listener *listener, void *data) { /* This event is forwarded by the cursor when a pointer emits a _relative_ * pointer motion event (i.e. a delta) */ - struct dwl_server *server = - wl_container_of(listener, server, cursor_motion); struct wlr_event_pointer_motion *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, + wlr_cursor_move(server.cursor, event->device, event->delta_x, event->delta_y); - motionnotify(server, event->time_msec); + motionnotify(event->time_msec); } void -movemouse(struct dwl_server *server, const Arg *arg) +movemouse(const Arg *arg) { double sx, sy; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server, - server->cursor->x, server->cursor->y, &surface, &sx, &sy); + struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + &surface, &sx, &sy); if (!view) { return; } @@ -692,33 +669,32 @@ moveresize(struct dwl_view *view, unsigned int mode, uint32_t edges) /* This function sets up an interactive move or resize operation, where the * compositor stops propagating pointer events to clients and instead * consumes them itself, to move or resize windows. */ - struct dwl_server *server = view->server; struct wlr_surface *focused_surface = - server->seat->pointer_state.focused_surface; + server.seat->pointer_state.focused_surface; if (view->xdg_surface->surface != focused_surface) { /* Deny move/resize requests from unfocused clients. */ return; } - server->grabbed_view = view; - server->cursor_mode = mode; + server.grabbed_view = view; + server.cursor_mode = mode; struct wlr_box geo_box; wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box); if (mode == CurMove) { - server->grab_x = server->cursor->x - view->x; - server->grab_y = server->cursor->y - view->y; + server.grab_x = server.cursor->x - view->x; + server.grab_y = server.cursor->y - view->y; } else { - server->grab_x = server->cursor->x + geo_box.x; - server->grab_y = server->cursor->y + geo_box.y; + server.grab_x = server.cursor->x + geo_box.x; + server.grab_y = server.cursor->y + geo_box.y; } - server->grab_width = geo_box.width; - server->grab_height = geo_box.height; - server->resize_edges = edges; + server.grab_width = geo_box.width; + server.grab_height = geo_box.height; + server.resize_edges = edges; } void -quit(struct dwl_server *server, const Arg *arg) +quit(const Arg *arg) { - wl_display_terminate(server->wl_display); + wl_display_terminate(server.wl_display); } void @@ -745,7 +721,7 @@ render(struct wlr_surface *surface, int sx, int sy, void *data) * output-local coordinates, or (2000 - 1920). */ double ox = 0, oy = 0; wlr_output_layout_output_coords( - view->server->output_layout, output, &ox, &oy); + 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 @@ -790,7 +766,7 @@ renderoutput(struct wl_listener *listener, void *data) * generally at the output's refresh rate (e.g. 60Hz). */ struct dwl_output *output = wl_container_of(listener, output, frame); - struct wlr_renderer *renderer = output->server->renderer; + struct wlr_renderer *renderer = server.renderer; struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); @@ -811,7 +787,7 @@ renderoutput(struct wl_listener *listener, void *data) /* 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 dwl_view *view; - wl_list_for_each_reverse(view, &output->server->views, link) { + wl_list_for_each_reverse(view, &server.views, link) { if (!view->mapped) { /* An unmapped view should not be rendered. */ continue; @@ -843,18 +819,18 @@ renderoutput(struct wl_listener *listener, void *data) } void -resizemouse(struct dwl_server *server, const Arg *arg) +resizemouse(const Arg *arg) { double sx, sy; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server, - server->cursor->x, server->cursor->y, &surface, &sx, &sy); + struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + &surface, &sx, &sy); if (!view) { return; } struct wlr_box geo_box; wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box); - wlr_cursor_warp_closest(server->cursor, NULL, + wlr_cursor_warp_closest(server.cursor, NULL, view->x + geo_box.x + geo_box.width, view->y + geo_box.y + geo_box.height); moveresize(view, CurResize, WLR_EDGE_BOTTOM|WLR_EDGE_RIGHT); @@ -876,12 +852,10 @@ resizerequest(struct wl_listener *listener, void *data) void setcursor(struct wl_listener *listener, void *data) { - struct dwl_server *server = wl_container_of( - listener, server, request_cursor); /* This event is rasied by the seat when a client provides a cursor image */ struct wlr_seat_pointer_request_set_cursor_event *event = data; struct wlr_seat_client *focused_client = - server->seat->pointer_state.focused_client; + server.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. */ if (focused_client == event->seat_client) { @@ -889,13 +863,13 @@ setcursor(struct wl_listener *listener, void *data) * provided surface as the cursor image. It will set the hardware cursor * on the output that it's currently on and continue to do so as the * cursor moves between outputs. */ - wlr_cursor_set_surface(server->cursor, event->surface, + wlr_cursor_set_surface(server.cursor, event->surface, event->hotspot_x, event->hotspot_y); } } void -spawn(struct dwl_server *server, const Arg *arg) +spawn(const Arg *arg) { if (fork() == 0) { setsid(); @@ -946,13 +920,13 @@ xytosurface(struct dwl_view *view, double lx, double ly, } struct dwl_view * -xytoview(struct dwl_server *server, double lx, double ly, +xytoview(double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { /* 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. */ + * cursor. This relies on server.views being ordered from top-to-bottom. */ struct dwl_view *view; - wl_list_for_each(view, &server->views, link) { + wl_list_for_each(view, &server.views, link) { if (xytosurface(view, lx, ly, surface, sx, sy)) { return view; } @@ -983,7 +957,6 @@ main(int argc, char *argv[]) return 0; } - struct dwl_server server; /* The Wayland display is managed by libwayland. It handles accepting * clients from the Unix socket, manging Wayland globals, and so on. */ server.wl_display = wl_display_create(); |