diff options
Diffstat (limited to 'dwl.c')
| -rw-r--r-- | dwl.c | 281 |
1 files changed, 135 insertions, 146 deletions
@@ -35,38 +35,6 @@ /* enums */ enum { CurNormal, CurMove, CurResize }; /* cursor */ -struct dwl_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_list keyboards; - unsigned int cursor_mode; - struct dwl_view *grabbed_view; - double grab_x, grab_y; - int grab_width, grab_height; - uint32_t resize_edges; - - struct wlr_output_layout *output_layout; - struct wl_list outputs; - struct wl_listener new_output; -}; - struct dwl_output { struct wl_list link; struct wlr_output *wlr_output; @@ -153,7 +121,35 @@ static struct dwl_view * xytoview(double lx, double ly, struct wlr_surface **surface, double *sx, double *sy); /* variables */ -static struct dwl_server server; +static struct wl_display *wl_display; +static struct wlr_backend *backend; +static struct wlr_renderer *renderer; + +static struct wlr_xdg_shell *xdg_shell; +static struct wl_listener new_xdg_surface; +static struct wl_list views; + +static struct wlr_cursor *cursor; +static struct wlr_xcursor_manager *cursor_mgr; +static struct wl_listener cursor_motion; +static struct wl_listener cursor_motion_absolute; +static struct wl_listener cursor_button; +static struct wl_listener cursor_axis; +static struct wl_listener cursor_frame; + +static struct wlr_seat *seat; +static struct wl_listener new_input; +static struct wl_listener request_cursor; +static struct wl_list keyboards; +static unsigned int cursor_mode; +static struct dwl_view *grabbed_view; +static double grab_x, grab_y; +static int grab_width, grab_height; +static uint32_t resize_edges; + +static struct wlr_output_layout *output_layout; +static struct wl_list outputs; +static struct wl_listener new_output; #include "config.h" @@ -161,7 +157,6 @@ static struct dwl_server server; * frame handler to the per-surface render function. */ struct render_data { struct wlr_output *output; - struct wlr_renderer *renderer; struct dwl_view *view; struct timespec *when; }; @@ -173,7 +168,7 @@ axisnotify(struct wl_listener *listener, void *data) * for example when you move the scroll wheel. */ 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(seat, event->time_msec, event->orientation, event->delta, event->delta_discrete, event->source); } @@ -185,16 +180,15 @@ buttonpress(struct wl_listener *listener, void *data) * event. */ 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(seat, event->time_msec, event->button, event->state); double sx, sy; - struct wlr_seat *seat = server.seat; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + struct dwl_view *view = xytoview(cursor->x, 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; + cursor_mode = CurNormal; } else { /* Focus that client if the button was _pressed_ */ focus(view, surface); @@ -235,10 +229,10 @@ createkeyboard(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(seat, device); /* And add the keyboard to our list of keyboards */ - wl_list_insert(&server.keyboards, &keyboard->link); + wl_list_insert(&keyboards, &keyboard->link); } void @@ -272,7 +266,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(&views, &view->link); } void @@ -303,13 +297,13 @@ createoutput(struct wl_listener *listener, void *data) /* 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(&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(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 @@ -324,7 +318,7 @@ createpointer(struct wlr_input_device *device) * 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(cursor, device); } void @@ -335,7 +329,7 @@ cursorframe(struct wl_listener *listener, void *data) * 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. */ /* Notify the client with pointer focus of the frame event. */ - wlr_seat_pointer_notify_frame(server.seat); + wlr_seat_pointer_notify_frame(seat); } void @@ -354,7 +348,6 @@ focus(struct dwl_view *view, struct wlr_surface *surface) if (view == NULL) { return; } - 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. */ @@ -373,7 +366,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(&views, &view->link); /* Activate the new surface */ wlr_xdg_toplevel_set_activated(view->xdg_surface, true); /* @@ -389,25 +382,25 @@ void focusnext(const Arg *arg) { /* Cycle to the next view */ - if (wl_list_length(&server.views) < 2) { + if (wl_list_length(&views) < 2) { return; } struct dwl_view *current_view = wl_container_of( - server.views.next, current_view, link); + 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(views.prev, ¤t_view->link); } void 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; + grabbed_view->x = cursor->x - grab_x; + grabbed_view->y = cursor->y - grab_y; } void @@ -423,29 +416,29 @@ handleresize(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 = grabbed_view; + double dx = cursor->x - grab_x; + double dy = cursor->y - 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 = grab_width; + int height = grab_height; + if (resize_edges & WLR_EDGE_TOP) { + y = grab_y + dy; height -= dy; if (height < 1) { y += height; } - } else if (server.resize_edges & WLR_EDGE_BOTTOM) { + } else if (resize_edges & WLR_EDGE_BOTTOM) { height += dy; } - if (server.resize_edges & WLR_EDGE_LEFT) { - x = server.grab_x + dx; + if (resize_edges & WLR_EDGE_LEFT) { + x = grab_x + dx; width -= dx; if (width < 1) { x += width; } - } else if (server.resize_edges & WLR_EDGE_RIGHT) { + } else if (resize_edges & WLR_EDGE_RIGHT) { width += dx; } view->x = x; @@ -473,10 +466,10 @@ 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(&keyboards)) { caps |= WL_SEAT_CAPABILITY_KEYBOARD; } - wlr_seat_set_capabilities(server.seat, caps); + wlr_seat_set_capabilities(seat, caps); } bool @@ -506,7 +499,6 @@ keypress(struct wl_listener *listener, void *data) struct dwl_keyboard *keyboard = wl_container_of(listener, keyboard, key); struct wlr_event_keyboard_key *event = data; - struct wlr_seat *seat = server.seat; /* Translate libinput keycode -> xkbcommon */ uint32_t keycode = event->keycode + 8; @@ -545,9 +537,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(server.seat, keyboard->device); + wlr_seat_set_keyboard(seat, keyboard->device); /* Send modifiers to the client. */ - wlr_seat_keyboard_notify_modifiers(server.seat, + wlr_seat_keyboard_notify_modifiers(seat, &keyboard->device->keyboard->modifiers); } @@ -570,7 +562,7 @@ motionabsolute(struct wl_listener *listener, void *data) * so we have to warp the mouse there. There is also some hardware which * emits these events. */ struct wlr_event_pointer_motion_absolute *event = data; - wlr_cursor_warp_absolute(server.cursor, event->device, event->x, event->y); + wlr_cursor_warp_absolute(cursor, event->device, event->x, event->y); motionnotify(event->time_msec); } @@ -578,26 +570,25 @@ void motionnotify(uint32_t time) { /* If the mode is non-passthrough, delegate to those functions. */ - if (server.cursor_mode == CurMove) { + if (cursor_mode == CurMove) { handlemove(time); return; - } else if (server.cursor_mode == CurResize) { + } else if (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_surface *surface = NULL; - struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + struct dwl_view *view = xytoview(cursor->x, 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); + cursor_mgr, "left_ptr", cursor); } if (surface) { bool focus_changed = seat->pointer_state.focused_surface != surface; @@ -633,7 +624,7 @@ motionrelative(struct wl_listener *listener, void *data) * 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(cursor, event->device, event->delta_x, event->delta_y); motionnotify(event->time_msec); } @@ -643,7 +634,7 @@ movemouse(const Arg *arg) { double sx, sy; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + struct dwl_view *view = xytoview(cursor->x, cursor->y, &surface, &sx, &sy); if (!view) { return; @@ -670,31 +661,31 @@ moveresize(struct dwl_view *view, unsigned int mode, uint32_t edges) * compositor stops propagating pointer events to clients and instead * consumes them itself, to move or resize windows. */ struct wlr_surface *focused_surface = - server.seat->pointer_state.focused_surface; + 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; + grabbed_view = view; + 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; + grab_x = cursor->x - view->x; + grab_y = cursor->y - view->y; } else { - server.grab_x = server.cursor->x + geo_box.x; - server.grab_y = server.cursor->y + geo_box.y; + grab_x = cursor->x + geo_box.x; + grab_y = cursor->y + geo_box.y; } - server.grab_width = geo_box.width; - server.grab_height = geo_box.height; - server.resize_edges = edges; + grab_width = geo_box.width; + grab_height = geo_box.height; + resize_edges = edges; } void quit(const Arg *arg) { - wl_display_terminate(server.wl_display); + wl_display_terminate(wl_display); } void @@ -721,7 +712,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( - server.output_layout, output, &ox, &oy); + 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 @@ -752,7 +743,7 @@ render(struct wlr_surface *surface, int sx, int sy, void *data) /* 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); + wlr_render_texture_with_matrix(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. */ @@ -766,7 +757,6 @@ 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 = server.renderer; struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); @@ -787,7 +777,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, &server.views, link) { + wl_list_for_each_reverse(view, &views, link) { if (!view->mapped) { /* An unmapped view should not be rendered. */ continue; @@ -795,7 +785,6 @@ renderoutput(struct wl_listener *listener, void *data) struct render_data rdata = { .output = output->wlr_output, .view = view, - .renderer = renderer, .when = &now, }; /* This calls our render function for each surface among the @@ -823,14 +812,14 @@ resizemouse(const Arg *arg) { double sx, sy; struct wlr_surface *surface; - struct dwl_view *view = xytoview(server.cursor->x, server.cursor->y, + struct dwl_view *view = xytoview(cursor->x, 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(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); @@ -855,7 +844,7 @@ setcursor(struct wl_listener *listener, void *data) /* 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; + 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) { @@ -863,7 +852,7 @@ 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(cursor, event->surface, event->hotspot_x, event->hotspot_y); } } @@ -924,9 +913,9 @@ 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 views being ordered from top-to-bottom. */ struct dwl_view *view; - wl_list_for_each(view, &server.views, link) { + wl_list_for_each(view, &views, link) { if (xytosurface(view, lx, ly, surface, sx, sy)) { return view; } @@ -959,7 +948,7 @@ main(int argc, char *argv[]) /* 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(); + wl_display = wl_display_create(); /* The backend is a wlroots feature which abstracts the underlying input and * output hardware. The autocreate option will choose the most suitable * backend based on the current environment, such as opening an X11 window @@ -968,30 +957,30 @@ main(int argc, char *argv[]) * backend uses the renderer, for example, to fall back to software cursors * if the backend does not support hardware cursors (some older GPUs * don't). */ - server.backend = wlr_backend_autocreate(server.wl_display, NULL); + backend = wlr_backend_autocreate(wl_display, NULL); /* If we don't provide a renderer, autocreate makes a GLES2 renderer for us. * 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); - wlr_renderer_init_wl_display(server.renderer, server.wl_display); + renderer = wlr_backend_get_renderer(backend); + wlr_renderer_init_wl_display(renderer, wl_display); /* This creates some hands-off wlroots interfaces. The compositor is * necessary for clients to allocate 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. */ - wlr_compositor_create(server.wl_display, server.renderer); - wlr_data_device_manager_create(server.wl_display); + wlr_compositor_create(wl_display, renderer); + wlr_data_device_manager_create(wl_display); /* Creates an output layout, which a wlroots utility for working with an * arrangement of screens in a physical layout. */ - server.output_layout = wlr_output_layout_create(); + output_layout = wlr_output_layout_create(); /* Configure a listener to be notified when new outputs are available on the * backend. */ - wl_list_init(&server.outputs); - server.new_output.notify = createoutput; - wl_signal_add(&server.backend->events.new_output, &server.new_output); + wl_list_init(&outputs); + new_output.notify = createoutput; + wl_signal_add(&backend->events.new_output, &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 @@ -999,25 +988,25 @@ main(int argc, char *argv[]) * * https://drewdevault.com/2018/07/29/Wayland-shells.html */ - wl_list_init(&server.views); - server.xdg_shell = wlr_xdg_shell_create(server.wl_display); - server.new_xdg_surface.notify = createnotify; - wl_signal_add(&server.xdg_shell->events.new_surface, - &server.new_xdg_surface); + wl_list_init(&views); + xdg_shell = wlr_xdg_shell_create(wl_display); + new_xdg_surface.notify = createnotify; + wl_signal_add(&xdg_shell->events.new_surface, + &new_xdg_surface); /* * Creates a cursor, which is a wlroots utility for tracking the cursor * image shown on screen. */ - server.cursor = wlr_cursor_create(); - wlr_cursor_attach_output_layout(server.cursor, server.output_layout); + cursor = wlr_cursor_create(); + wlr_cursor_attach_output_layout(cursor, output_layout); /* 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. */ - server.cursor_mgr = wlr_xcursor_manager_create(NULL, 24); - wlr_xcursor_manager_load(server.cursor_mgr, 1); + cursor_mgr = wlr_xcursor_manager_create(NULL, 24); + wlr_xcursor_manager_load(cursor_mgr, 1); /* * wlr_cursor *only* displays an image on screen. It does not move around @@ -1031,17 +1020,17 @@ main(int argc, char *argv[]) * * And more comments are sprinkled throughout the notify functions above. */ - server.cursor_motion.notify = motionrelative; - wl_signal_add(&server.cursor->events.motion, &server.cursor_motion); - server.cursor_motion_absolute.notify = motionabsolute; - wl_signal_add(&server.cursor->events.motion_absolute, - &server.cursor_motion_absolute); - server.cursor_button.notify = buttonpress; - wl_signal_add(&server.cursor->events.button, &server.cursor_button); - server.cursor_axis.notify = axisnotify; - wl_signal_add(&server.cursor->events.axis, &server.cursor_axis); - server.cursor_frame.notify = cursorframe; - wl_signal_add(&server.cursor->events.frame, &server.cursor_frame); + cursor_motion.notify = motionrelative; + wl_signal_add(&cursor->events.motion, &cursor_motion); + cursor_motion_absolute.notify = motionabsolute; + wl_signal_add(&cursor->events.motion_absolute, + &cursor_motion_absolute); + cursor_button.notify = buttonpress; + wl_signal_add(&cursor->events.button, &cursor_button); + cursor_axis.notify = axisnotify; + wl_signal_add(&cursor->events.axis, &cursor_axis); + cursor_frame.notify = cursorframe; + wl_signal_add(&cursor->events.frame, &cursor_frame); /* * Configures a seat, which is a single "seat" at which a user sits and @@ -1049,26 +1038,26 @@ main(int argc, char *argv[]) * pointer, touch, and drawing tablet device. We also rig up a listener to * let us know when new input devices are available on the backend. */ - wl_list_init(&server.keyboards); - server.new_input.notify = inputdevice; - wl_signal_add(&server.backend->events.new_input, &server.new_input); - server.seat = wlr_seat_create(server.wl_display, "seat0"); - server.request_cursor.notify = setcursor; - wl_signal_add(&server.seat->events.request_set_cursor, - &server.request_cursor); + wl_list_init(&keyboards); + new_input.notify = inputdevice; + wl_signal_add(&backend->events.new_input, &new_input); + seat = wlr_seat_create(wl_display, "seat0"); + request_cursor.notify = setcursor; + wl_signal_add(&seat->events.request_set_cursor, + &request_cursor); /* Add a Unix socket to the Wayland display. */ - const char *socket = wl_display_add_socket_auto(server.wl_display); + const char *socket = wl_display_add_socket_auto(wl_display); if (!socket) { - wlr_backend_destroy(server.backend); + wlr_backend_destroy(backend); return 1; } /* Start the backend. This will enumerate outputs and inputs, become the DRM * master, etc */ - if (!wlr_backend_start(server.backend)) { - wlr_backend_destroy(server.backend); - wl_display_destroy(server.wl_display); + if (!wlr_backend_start(backend)) { + wlr_backend_destroy(backend); + wl_display_destroy(wl_display); return 1; } @@ -1079,13 +1068,13 @@ main(int argc, char *argv[]) startup_pid = fork(); if (startup_pid < 0) { perror("startup: fork"); - wl_display_destroy(server.wl_display); + wl_display_destroy(wl_display); return 1; } if (startup_pid == 0) { execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL); perror("startup: execl"); - wl_display_destroy(server.wl_display); + wl_display_destroy(wl_display); return 1; } } @@ -1095,7 +1084,7 @@ main(int argc, char *argv[]) * 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); + wl_display_run(wl_display); if (startup_cmd) { kill(startup_pid, SIGTERM); @@ -1103,7 +1092,7 @@ main(int argc, char *argv[]) } /* Once wl_display_run returns, we shut down the server. */ - wl_display_destroy_clients(server.wl_display); - wl_display_destroy(server.wl_display); + wl_display_destroy_clients(wl_display); + wl_display_destroy(wl_display); return 0; } |