diff options
Diffstat (limited to 'rootston/output.c')
-rw-r--r-- | rootston/output.c | 543 |
1 files changed, 412 insertions, 131 deletions
diff --git a/rootston/output.c b/rootston/output.c index 689956ad..4cd0cb44 100644 --- a/rootston/output.c +++ b/rootston/output.c @@ -2,7 +2,6 @@ #include <time.h> #include <stdlib.h> #include <stdbool.h> -#include <GLES2/gl2.h> #include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_compositor.h> #include <wlr/types/wlr_wl_shell.h> @@ -10,9 +9,12 @@ #include <wlr/render/matrix.h> #include <wlr/util/log.h> #include "rootston/server.h" -#include "rootston/desktop.h" +#include "rootston/output.h" #include "rootston/config.h" +typedef void (*surface_iterator_func_t)(struct wlr_surface *surface, + double lx, double ly, float rotation, void *data); + /** * Rotate a child's position relative to a parent. The parent size is (pw, ph), * the child position is (*sx, *sy) and its size is (sw, sh). @@ -31,66 +33,33 @@ static void rotate_child_position(double *sx, double *sy, double sw, double sh, } } -static void render_surface(struct wlr_surface *surface, - struct roots_desktop *desktop, struct wlr_output *wlr_output, - struct timespec *when, double lx, double ly, float rotation) { - if (!wlr_surface_has_buffer(surface)) { - return; - } - - int width = surface->current->width; - int height = surface->current->height; - int render_width = width * wlr_output->scale; - int render_height = height * wlr_output->scale; - double ox = lx, oy = ly; - wlr_output_layout_output_coords(desktop->layout, wlr_output, &ox, &oy); - ox *= wlr_output->scale; - oy *= wlr_output->scale; - - struct wlr_box render_box = { - .x = lx, .y = ly, - .width = render_width, .height = render_height, - }; - if (wlr_output_layout_intersects(desktop->layout, wlr_output, &render_box)) { - struct wlr_box project_box = { - .x = ox, - .y = oy, - .width = render_width, - .height = render_height, - }; - float matrix[16]; - wlr_matrix_project_box(&matrix, &project_box, surface->current->transform, - rotation, &wlr_output->transform_matrix); - wlr_render_with_matrix(desktop->server->renderer, surface->texture, - &matrix); - - wlr_surface_send_frame_done(surface, when); - } +static void surface_for_each_surface(struct wlr_surface *surface, double lx, + double ly, float rotation, surface_iterator_func_t iterator, + void *user_data) { + iterator(surface, lx, ly, rotation, user_data); struct wlr_subsurface *subsurface; wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) { struct wlr_surface_state *state = subsurface->surface->current; double sx = state->subsurface_position.x; double sy = state->subsurface_position.y; - double sw = state->buffer_width / state->scale; - double sh = state->buffer_height / state->scale; - rotate_child_position(&sx, &sy, sw, sh, width, height, rotation); + rotate_child_position(&sx, &sy, state->width, state->height, + surface->current->width, surface->current->height, rotation); - render_surface(subsurface->surface, desktop, wlr_output, when, - lx + sx, - ly + sy, - rotation); + surface_for_each_surface(subsurface->surface, lx + sx, ly + sy, + rotation, iterator, user_data); } } -static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface, - struct roots_desktop *desktop, struct wlr_output *wlr_output, - struct timespec *when, double base_x, double base_y, float rotation) { +static void xdg_surface_v6_for_each_surface(struct wlr_xdg_surface_v6 *surface, + double base_x, double base_y, float rotation, + surface_iterator_func_t iterator, void *user_data) { double width = surface->surface->current->width; double height = surface->surface->current->height; - struct wlr_xdg_surface_v6 *popup; - wl_list_for_each(popup, &surface->popups, popup_link) { + struct wlr_xdg_popup_v6 *popup_state; + wl_list_for_each(popup_state, &surface->popups, link) { + struct wlr_xdg_surface_v6 *popup = popup_state->base; if (!popup->configured) { continue; } @@ -103,20 +72,20 @@ static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface, rotate_child_position(&popup_sx, &popup_sy, popup_width, popup_height, width, height, rotation); - render_surface(popup->surface, desktop, wlr_output, when, - base_x + popup_sx, base_y + popup_sy, rotation); - render_xdg_v6_popups(popup, desktop, wlr_output, when, - base_x + popup_sx, base_y + popup_sy, rotation); + surface_for_each_surface(popup->surface, base_x + popup_sx, + base_y + popup_sy, rotation, iterator, user_data); + xdg_surface_v6_for_each_surface(popup, base_x + popup_sx, + base_y + popup_sy, rotation, iterator, user_data); } } -static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface, - struct roots_desktop *desktop, struct wlr_output *wlr_output, - struct timespec *when, double lx, double ly, float rotation, - bool is_child) { +static void wl_shell_surface_for_each_surface( + struct wlr_wl_shell_surface *surface, double lx, double ly, + float rotation, bool is_child, surface_iterator_func_t iterator, + void *user_data) { if (is_child || surface->state != WLR_WL_SHELL_SURFACE_STATE_POPUP) { - render_surface(surface->surface, desktop, wlr_output, when, - lx, ly, rotation); + surface_for_each_surface(surface->surface, lx, ly, rotation, iterator, + user_data); double width = surface->surface->current->width; double height = surface->surface->current->height; @@ -131,30 +100,140 @@ static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface, rotate_child_position(&popup_x, &popup_y, popup_width, popup_height, width, height, rotation); - render_wl_shell_surface(popup, desktop, wlr_output, when, - lx + popup_x, ly + popup_y, rotation, true); + wl_shell_surface_for_each_surface(popup, lx + popup_x, ly + popup_y, + rotation, true, iterator, user_data); + } + } +} + +static void view_for_each_surface(struct roots_view *view, + surface_iterator_func_t iterator, void *user_data) { + switch (view->type) { + case ROOTS_XDG_SHELL_V6_VIEW: + surface_for_each_surface(view->wlr_surface, view->x, view->y, + view->rotation, iterator, user_data); + xdg_surface_v6_for_each_surface(view->xdg_surface_v6, view->x, view->y, + view->rotation, iterator, user_data); + break; + case ROOTS_WL_SHELL_VIEW: + wl_shell_surface_for_each_surface(view->wl_shell_surface, view->x, + view->y, view->rotation, false, iterator, user_data); + break; + case ROOTS_XWAYLAND_VIEW: + if (view->wlr_surface != NULL) { + surface_for_each_surface(view->wlr_surface, view->x, view->y, + view->rotation, iterator, user_data); } + break; } } -static void render_xwayland_children(struct wlr_xwayland_surface *surface, - struct roots_desktop *desktop, struct wlr_output *wlr_output, - struct timespec *when) { +static void xwayland_children_for_each_surface( + struct wlr_xwayland_surface *surface, + surface_iterator_func_t iterator, void *user_data) { struct wlr_xwayland_surface *child; wl_list_for_each(child, &surface->children, parent_link) { if (child->surface != NULL && child->added) { - render_surface(child->surface, desktop, wlr_output, when, - child->x, child->y, 0); + surface_for_each_surface(child->surface, child->x, child->y, 0, + iterator, user_data); } - render_xwayland_children(child, desktop, wlr_output, when); + xwayland_children_for_each_surface(child, iterator, user_data); + } +} + + +struct render_data { + struct roots_output *output; + struct timespec *when; + pixman_region32_t *damage; +}; + +/** + * Checks whether a surface at (lx, ly) intersects an output. Sets `box` to the + * surface box in the output, in output-local coordinates. + */ +static bool surface_intersect_output(struct wlr_surface *surface, + struct wlr_output_layout *output_layout, struct wlr_output *wlr_output, + double lx, double ly, struct wlr_box *box) { + double ox = lx, oy = ly; + wlr_output_layout_output_coords(output_layout, wlr_output, &ox, &oy); + box->x = ox * wlr_output->scale; + box->y = oy * wlr_output->scale; + box->width = surface->current->width * wlr_output->scale; + box->height = surface->current->height * wlr_output->scale; + + struct wlr_box layout_box = { + .x = lx, .y = ly, + .width = surface->current->width, .height = surface->current->height, + }; + return wlr_output_layout_intersects(output_layout, wlr_output, &layout_box); +} + +static void render_surface(struct wlr_surface *surface, double lx, double ly, + float rotation, void *_data) { + struct render_data *data = _data; + struct roots_output *output = data->output; + struct timespec *when = data->when; + pixman_region32_t *damage = data->damage; + + if (!wlr_surface_has_buffer(surface)) { + return; + } + + struct wlr_box box; + bool intersects = surface_intersect_output(surface, output->desktop->layout, + output->wlr_output, lx, ly, &box); + if (!intersects) { + return; + } + + // TODO: output scale, output transform support + pixman_region32_t surface_damage; + pixman_region32_init(&surface_damage); + pixman_region32_union_rect(&surface_damage, &surface_damage, box.x, box.y, + box.width, box.height); + pixman_region32_intersect(&surface_damage, &surface_damage, damage); + bool damaged = pixman_region32_not_empty(&surface_damage); + if (!damaged) { + goto surface_damage_finish; + } + + float matrix[16]; + enum wl_output_transform transform = + wlr_output_transform_invert(surface->current->transform); + wlr_matrix_project_box(&matrix, &box, transform, rotation, + &output->wlr_output->transform_matrix); + + int nrects; + pixman_box32_t *rects = + pixman_region32_rectangles(&surface_damage, &nrects); + for (int i = 0; i < nrects; ++i) { + struct wlr_box scissor = { + .x = rects[i].x1, + .y = output->wlr_output->height - rects[i].y2, + .width = rects[i].x2 - rects[i].x1, + .height = rects[i].y2 - rects[i].y1, + }; + wlr_renderer_scissor(output->desktop->server->renderer, &scissor); + wlr_render_with_matrix(output->desktop->server->renderer, + surface->texture, &matrix); } + + wlr_surface_send_frame_done(surface, when); + +surface_damage_finish: + pixman_region32_fini(&surface_damage); } static void render_decorations(struct roots_view *view, - struct roots_desktop *desktop, struct wlr_output *output) { + struct render_data *data) { if (!view->decorated) { return; } + + struct roots_output *output = data->output; + struct wlr_output *wlr_output = output->wlr_output; + struct wlr_box deco_box; view_get_deco_box(view, &deco_box); double sx = deco_box.x - view->x; @@ -162,47 +241,28 @@ static void render_decorations(struct roots_view *view, rotate_child_position(&sx, &sy, deco_box.width, deco_box.height, view->wlr_surface->current->width, view->wlr_surface->current->height, view->rotation); - double ox = sx + view->x; - double oy = sy + view->y; - - wlr_output_layout_output_coords(desktop->layout, output, &ox, &oy); - ox *= output->scale; - oy *= output->scale; - - struct wlr_box project_box = { - .x = ox, - .y = oy, - .width = deco_box.width, - .height = deco_box.height, + double x = sx + view->x; + double y = sy + view->y; + + wlr_output_layout_output_coords(output->desktop->layout, wlr_output, &x, &y); + + struct wlr_box box = { + .x = x * wlr_output->scale, + .y = y * wlr_output->scale, + .width = deco_box.width * wlr_output->scale, + .height = deco_box.height * wlr_output->scale, }; float matrix[16]; - wlr_matrix_project_box(&matrix, &project_box, WL_OUTPUT_TRANSFORM_NORMAL, - view->rotation, &output->transform_matrix); + wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, + view->rotation, &wlr_output->transform_matrix); float color[4] = { 0.2, 0.2, 0.2, 1 }; - wlr_render_colored_quad(desktop->server->renderer, &color, &matrix); + wlr_render_colored_quad(output->desktop->server->renderer, &color, &matrix); } -static void render_view(struct roots_view *view, struct roots_desktop *desktop, - struct wlr_output *wlr_output, struct timespec *when) { - render_decorations(view, desktop, wlr_output); - - switch (view->type) { - case ROOTS_XDG_SHELL_V6_VIEW: - render_surface(view->wlr_surface, desktop, wlr_output, when, - view->x, view->y, view->rotation); - render_xdg_v6_popups(view->xdg_surface_v6, desktop, wlr_output, - when, view->x, view->y, view->rotation); - break; - case ROOTS_WL_SHELL_VIEW: - render_wl_shell_surface(view->wl_shell_surface, desktop, wlr_output, - when, view->x, view->y, view->rotation, false); - break; - case ROOTS_XWAYLAND_VIEW: - render_surface(view->wlr_surface, desktop, wlr_output, when, - view->x, view->y, view->rotation); - break; - } +static void render_view(struct roots_view *view, struct render_data *data) { + render_decorations(view, data); + view_for_each_surface(view, render_surface, data); } static bool has_standalone_surface(struct roots_view *view) { @@ -221,22 +281,22 @@ static bool has_standalone_surface(struct roots_view *view) { return true; } -static void output_frame_notify(struct wl_listener *listener, void *data) { - struct wlr_output *wlr_output = data; - struct roots_output *output = wl_container_of(listener, output, frame); +static void render_output(struct roots_output *output) { + struct wlr_output *wlr_output = output->wlr_output; struct roots_desktop *desktop = output->desktop; struct roots_server *server = desktop->server; if (!wlr_output->enabled) { + output->frame_pending = false; return; } struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); - wlr_output_make_current(wlr_output); - wlr_renderer_begin(server->renderer, wlr_output); + float clear_color[] = {0.25f, 0.25f, 0.25f}; + // Check if we can delegate the fullscreen surface to the output if (output->fullscreen_view != NULL) { struct roots_view *view = output->fullscreen_view; @@ -255,33 +315,99 @@ static void output_frame_notify(struct wl_listener *listener, void *data) { wlr_output_set_fullscreen_surface(wlr_output, view->wlr_surface); } else { wlr_output_set_fullscreen_surface(wlr_output, NULL); + } + + // Fullscreen views are rendered on a black background + clear_color[0] = clear_color[1] = clear_color[2] = 0; + } else { + wlr_output_set_fullscreen_surface(wlr_output, NULL); + } - glClearColor(0, 0, 0, 0); - glClear(GL_COLOR_BUFFER_BIT); + int buffer_age = -1; + wlr_output_make_current(wlr_output, &buffer_age); - render_view(view, desktop, wlr_output, &now); + // Check if we can use damage tracking + pixman_region32_t damage; + pixman_region32_init(&damage); + if (buffer_age <= 0 || buffer_age - 1 > ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN) { + // Buffer new or too old, damage the whole output + pixman_region32_union_rect(&damage, &damage, 0, 0, + wlr_output->width, wlr_output->height); + } else { + pixman_region32_copy(&damage, &output->damage); - // During normal rendering the xwayland window tree isn't traversed - // because all windows are rendered. Here we only want to render - // the fullscreen window's children so we have to traverse the tree. - if (view->type == ROOTS_XWAYLAND_VIEW) { - render_xwayland_children(view->xwayland_surface, desktop, - wlr_output, &now); - } + // Accumulate damage from old buffers + size_t idx = output->previous_damage_idx; + for (int i = 0; i < buffer_age - 1; ++i) { + int j = (idx + i) % ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; + pixman_region32_union(&damage, &damage, &output->previous_damage[j]); } - wlr_renderer_end(server->renderer); - wlr_output_swap_buffers(wlr_output); - output->last_frame = desktop->last_frame = now; - return; - } else { - wlr_output_set_fullscreen_surface(wlr_output, NULL); } + pixman_region32_intersect_rect(&damage, &damage, 0, 0, + wlr_output->width, wlr_output->height); + + if (!pixman_region32_not_empty(&damage) && !wlr_output->needs_swap) { + // Output doesn't need swap and isn't damaged, skip rendering completely + output->frame_pending = false; + goto damage_finish; + } + + struct render_data data = { + .output = output, + .when = &now, + .damage = &damage, + }; + wlr_renderer_begin(server->renderer, wlr_output); + + if (!pixman_region32_not_empty(&damage)) { + // Output isn't damaged but needs buffer swap + goto renderer_end; + } + + int nrects; + pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects); + for (int i = 0; i < nrects; ++i) { + struct wlr_box scissor = { + .x = rects[i].x1, + .y = wlr_output->height - rects[i].y2, + .width = rects[i].x2 - rects[i].x1, + .height = rects[i].y2 - rects[i].y1, + }; + wlr_renderer_scissor(output->desktop->server->renderer, &scissor); + wlr_renderer_clear(output->desktop->server->renderer, + clear_color[0], clear_color[1], clear_color[2], 1); + } + + // If a view is fullscreen on this output, render it + if (output->fullscreen_view != NULL) { + struct roots_view *view = output->fullscreen_view; + + if (wlr_output->fullscreen_surface == view->wlr_surface) { + // The output will render the fullscreen view + goto renderer_end; + } + + view_for_each_surface(view, render_surface, &data); + + // During normal rendering the xwayland window tree isn't traversed + // because all windows are rendered. Here we only want to render + // the fullscreen window's children so we have to traverse the tree. + if (view->type == ROOTS_XWAYLAND_VIEW) { + xwayland_children_for_each_surface(view->xwayland_surface, + render_surface, &data); + } + + goto renderer_end; + } + + // Render all views struct roots_view *view; wl_list_for_each_reverse(view, &desktop->views, link) { - render_view(view, desktop, wlr_output, &now); + render_view(view, &data); } + // Render drag icons struct wlr_drag_icon *drag_icon = NULL; struct roots_seat *seat = NULL; wl_list_for_each(seat, &server->input->seats, link) { @@ -295,23 +421,161 @@ static void output_frame_notify(struct wl_listener *listener, void *data) { if (drag_icon->is_pointer) { icon_x = cursor->x + drag_icon->sx; icon_y = cursor->y + drag_icon->sy; - render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0); + render_surface(icon, icon_x, icon_y, 0, &data); } else { struct wlr_touch_point *point = wlr_seat_touch_get_point(seat->seat, drag_icon->touch_id); if (point) { icon_x = seat->touch_x + drag_icon->sx; icon_y = seat->touch_y + drag_icon->sy; - render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0); + render_surface(icon, icon_x, icon_y, 0, &data); } } } } +renderer_end: + wlr_renderer_scissor(output->desktop->server->renderer, NULL); wlr_renderer_end(server->renderer); - wlr_output_swap_buffers(wlr_output); - + wlr_output_swap_buffers(wlr_output, &now, &damage); + output->frame_pending = true; + // same as decrementing, but works on unsigned integers + output->previous_damage_idx += ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN - 1; + output->previous_damage_idx %= ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; + pixman_region32_copy(&output->previous_damage[output->previous_damage_idx], + &output->damage); + pixman_region32_clear(&output->damage); output->last_frame = desktop->last_frame = now; + +damage_finish: + pixman_region32_fini(&damage); +} + +static void output_handle_frame(struct wl_listener *listener, void *data) { + struct roots_output *output = wl_container_of(listener, output, frame); + render_output(output); +} + +static void handle_idle_render(void *data) { + struct roots_output *output = data; + render_output(output); +} + +static void schedule_render(struct roots_output *output) { + if (!output->frame_pending) { + // TODO: ask the backend to send a frame event when appropriate instead + struct wl_event_loop *ev = + wl_display_get_event_loop(output->desktop->server->wl_display); + wl_event_loop_add_idle(ev, handle_idle_render, output); + output->frame_pending = true; + } +} + +static void output_damage_whole(struct roots_output *output) { + pixman_region32_union_rect(&output->damage, &output->damage, + 0, 0, output->wlr_output->width, output->wlr_output->height); + + schedule_render(output); +} + +static bool view_accept_damage(struct roots_output *output, + struct roots_view *view) { + if (output->fullscreen_view == NULL) { + return true; + } + if (output->fullscreen_view == view) { + return true; + } + if (output->fullscreen_view->type == ROOTS_XWAYLAND_VIEW && + view->type == ROOTS_XWAYLAND_VIEW) { + // Special case: accept damage from children + struct wlr_xwayland_surface *xsurface = view->xwayland_surface; + while (xsurface != NULL) { + if (output->fullscreen_view->xwayland_surface == xsurface) { + return true; + } + xsurface = xsurface->parent; + } + } + return false; +} + +static void damage_whole_surface(struct wlr_surface *surface, + double lx, double ly, float rotation, void *data) { + struct roots_output *output = data; + + if (!wlr_surface_has_buffer(surface)) { + return; + } + + struct wlr_box box; + bool intersects = surface_intersect_output(surface, + output->desktop->layout, output->wlr_output, lx, ly, &box); + if (!intersects) { + return; + } + + pixman_region32_union_rect(&output->damage, &output->damage, + box.x, box.y, box.width, box.height); + + schedule_render(output); +} + +void output_damage_whole_view(struct roots_output *output, + struct roots_view *view) { + if (!view_accept_damage(output, view)) { + return; + } + + view_for_each_surface(view, damage_whole_surface, output); +} + +static void damage_from_surface(struct wlr_surface *surface, + double lx, double ly, float rotation, void *data) { + struct roots_output *output = data; + + if (!wlr_surface_has_buffer(surface)) { + return; + } + + struct wlr_box box; + bool intersects = surface_intersect_output(surface, + output->desktop->layout, output->wlr_output, lx, ly, &box); + if (!intersects) { + return; + } + + // TODO: output scale, output transform support + pixman_region32_t damage; + pixman_region32_init(&damage); + pixman_region32_copy(&damage, &surface->current->surface_damage); + pixman_region32_translate(&damage, box.x, box.y); + pixman_region32_union(&output->damage, &output->damage, &damage); + pixman_region32_fini(&damage); + + schedule_render(output); +} + +void output_damage_from_view(struct roots_output *output, + struct roots_view *view) { + if (!view_accept_damage(output, view)) { + return; + } + + view_for_each_surface(view, damage_from_surface, output); +} + +static void output_handle_mode(struct wl_listener *listener, void *data) { + struct roots_output *output = wl_container_of(listener, output, mode); + output_damage_whole(output); +} + +static void output_handle_needs_swap(struct wl_listener *listener, void *data) { + struct roots_output *output = + wl_container_of(listener, output, needs_swap); + pixman_region32_union(&output->damage, &output->damage, + &output->wlr_output->damage); + schedule_render(output); } static void set_mode(struct wlr_output *output, @@ -364,9 +628,18 @@ void output_add_notify(struct wl_listener *listener, void *data) { clock_gettime(CLOCK_MONOTONIC, &output->last_frame); output->desktop = desktop; output->wlr_output = wlr_output; - output->frame.notify = output_frame_notify; - wl_signal_add(&wlr_output->events.frame, &output->frame); wl_list_insert(&desktop->outputs, &output->link); + pixman_region32_init(&output->damage); + for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) { + pixman_region32_init(&output->previous_damage[i]); + } + + output->frame.notify = output_handle_frame; + wl_signal_add(&wlr_output->events.frame, &output->frame); + output->mode.notify = output_handle_mode; + wl_signal_add(&wlr_output->events.mode, &output->mode); + output->needs_swap.notify = output_handle_needs_swap; + wl_signal_add(&wlr_output->events.needs_swap, &output->needs_swap); struct roots_output_config *output_config = roots_config_get_output(config, wlr_output); @@ -391,6 +664,8 @@ void output_add_notify(struct wl_listener *listener, void *data) { roots_seat_configure_cursor(seat); roots_seat_configure_xcursor(seat); } + + output_damage_whole(output); } void output_remove_notify(struct wl_listener *listener, void *data) { @@ -415,7 +690,13 @@ void output_remove_notify(struct wl_listener *listener, void *data) { //example_config_configure_cursor(sample->config, sample->cursor, // sample->compositor); + pixman_region32_fini(&output->damage); + for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) { + pixman_region32_fini(&output->previous_damage[i]); + } wl_list_remove(&output->link); wl_list_remove(&output->frame.link); + wl_list_remove(&output->mode.link); + wl_list_remove(&output->needs_swap.link); free(output); } |