diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h index 392b0271..91ac87b7 100644 --- a/include/rootston/desktop.h +++ b/include/rootston/desktop.h @@ -52,7 +52,8 @@ struct roots_desktop *desktop_create(struct roots_server *server, void desktop_destroy(struct roots_desktop *desktop); void view_destroy(struct roots_view *view); -struct roots_view *view_at(struct roots_desktop *desktop, int x, int y); +struct roots_view *view_at(struct roots_desktop *desktop, double lx, double ly, + struct wlr_surface **surface, double *sx, double *sy); void view_activate(struct roots_view *view, bool activate); void output_add_notify(struct wl_listener *listener, void *data); diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 87d421e3..ae278815 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -18,6 +18,8 @@ struct wlr_frame_callback { #define WLR_SURFACE_INVALID_INPUT_REGION 16 #define WLR_SURFACE_INVALID_TRANSFORM 32 #define WLR_SURFACE_INVALID_SCALE 64 +#define WLR_SURFACE_INVALID_SUBSURFACE_POSITION 128 +#define WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST 256 struct wlr_surface_state { uint32_t invalid; @@ -29,13 +31,36 @@ struct wlr_surface_state { int32_t scale; int width, height; int buffer_width, buffer_height; + + struct { + int32_t x, y; + } subsurface_position; + + struct wl_list frame_callback_list; // wl_surface.frame +}; + +struct wlr_subsurface { + struct wl_resource *resource; + struct wlr_surface *surface; + struct wlr_surface *parent; + + struct wlr_surface_state *cached; + bool has_cache; + + bool synchronized; + bool reordered; + + struct wl_list parent_link; + struct wl_list parent_pending_link; + + struct wl_listener parent_destroy_listener; }; struct wlr_surface { struct wl_resource *resource; struct wlr_renderer *renderer; struct wlr_texture *texture; - struct wlr_surface_state current, pending; + struct wlr_surface_state *current, *pending; const char *role; // the lifetime-bound role or null float buffer_to_surface_matrix[16]; @@ -47,11 +72,16 @@ struct wlr_surface { struct wl_signal destroy; } signals; - struct wl_list frame_callback_list; // wl_surface.frame - - struct wl_listener compositor_listener; // destroy listener used by compositor + // destroy listener used by compositor + struct wl_listener compositor_listener; void *compositor_data; + // subsurface properties + struct wlr_subsurface *subsurface; + struct wl_list subsurface_list; // wlr_subsurface::parent_link + + // wlr_subsurface::parent_pending_link + struct wl_list subsurface_pending_list; void *data; }; @@ -80,4 +110,15 @@ void wlr_surface_get_matrix(struct wlr_surface *surface, int wlr_surface_set_role(struct wlr_surface *surface, const char *role, struct wl_resource *error_resource, uint32_t error_code); +/** + * Create the subsurface implementation for this surface. + */ +void wlr_surface_make_subsurface(struct wlr_surface *surface, + struct wlr_surface *parent, uint32_t id); + +/** + * Get the top of the subsurface tree for this surface. + */ +struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface); + #endif diff --git a/rootston/cursor.c b/rootston/cursor.c index bd8f91d2..c24e6989 100644 --- a/rootston/cursor.c +++ b/rootston/cursor.c @@ -48,15 +48,14 @@ void view_begin_resize(struct roots_input *input, struct wlr_cursor *cursor, void cursor_update_position(struct roots_input *input, uint32_t time) { struct roots_desktop *desktop = input->server->desktop; struct roots_view *view; + struct wlr_surface *surface; + double sx, sy; switch (input->mode) { case ROOTS_CURSOR_PASSTHROUGH: - view = view_at(desktop, input->cursor->x, input->cursor->y); + view = view_at(desktop, input->cursor->x, input->cursor->y, &surface, + &sx, &sy); if (view) { - struct wlr_box box; - view_get_input_bounds(view, &box); - double sx = input->cursor->x - view->x; - double sy = input->cursor->y - view->y; - wlr_seat_pointer_enter(input->wl_seat, view->wlr_surface, sx, sy); + wlr_seat_pointer_enter(input->wl_seat, surface, sx, sy); wlr_seat_pointer_send_motion(input->wl_seat, time, sx, sy); } else { wlr_seat_pointer_clear_focus(input->wl_seat); @@ -146,8 +145,10 @@ static void do_cursor_button_press(struct roots_input *input, struct wlr_cursor *cursor, struct wlr_input_device *device, uint32_t time, uint32_t button, uint32_t state) { struct roots_desktop *desktop = input->server->desktop; + struct wlr_surface *surface; + double sx, sy; struct roots_view *view = view_at(desktop, - input->cursor->x, input->cursor->y); + input->cursor->x, input->cursor->y, &surface, &sx, &sy); uint32_t serial = wlr_seat_pointer_send_button( input->wl_seat, time, button, state); int i; @@ -165,7 +166,7 @@ static void do_cursor_button_press(struct roots_input *input, % (sizeof(input->input_events) / sizeof(input->input_events[0])); set_view_focus(input, desktop, view); if (view) { - wlr_seat_keyboard_enter(input->wl_seat, view->wlr_surface); + wlr_seat_keyboard_enter(input->wl_seat, surface); } break; } diff --git a/rootston/desktop.c b/rootston/desktop.c index 3d307ee4..fcfc0ccf 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -31,8 +31,8 @@ void view_get_size(struct roots_view *view, struct wlr_box *box) { return; } box->x = box->y = 0; - box->width = view->wlr_surface->current.width; - box->height = view->wlr_surface->current.height; + box->width = view->wlr_surface->current->width; + box->height = view->wlr_surface->current->height; } void view_get_input_bounds(struct roots_view *view, struct wlr_box *box) { @@ -41,8 +41,8 @@ void view_get_input_bounds(struct roots_view *view, struct wlr_box *box) { return; } box->x = box->y = 0; - box->width = view->wlr_surface->current.width; - box->height = view->wlr_surface->current.height; + box->width = view->wlr_surface->current->width; + box->height = view->wlr_surface->current->height; } void view_activate(struct roots_view *view, bool activate) { @@ -57,14 +57,60 @@ void view_resize(struct roots_view *view, uint32_t width, uint32_t height) { } } -struct roots_view *view_at(struct roots_desktop *desktop, int x, int y) { +static struct wlr_subsurface *subsurface_at(struct wlr_surface *surface, + double sx, double sy, double *sub_x, double *sub_y) { + struct wlr_subsurface *subsurface; + wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) { + double _sub_x = subsurface->surface->current->subsurface_position.x; + double _sub_y = subsurface->surface->current->subsurface_position.y; + struct wlr_subsurface *sub = + subsurface_at(subsurface->surface, _sub_x + sx, _sub_y + sy, + sub_x, sub_y); + if (sub) { + // TODO: convert sub_x and sub_y to the parent coordinate system + return sub; + } + + int sub_width = subsurface->surface->current->buffer_width; + int sub_height = subsurface->surface->current->buffer_height; + if ((sx > _sub_x && sx < _sub_x + sub_width) && + (sy > _sub_y && sub_y < sub_y + sub_height)) { + *sub_x = _sub_x; + *sub_y = _sub_y; + return subsurface; + } + } + + return NULL; +} + +struct roots_view *view_at(struct roots_desktop *desktop, double lx, double ly, + struct wlr_surface **surface, double *sx, double *sy) { for (size_t i = 0; i < desktop->views->length; ++i) { struct roots_view *view = desktop->views->items[i]; + + double view_sx = lx - view->x; + double view_sy = ly - view->y; + + double sub_x, sub_y; + struct wlr_subsurface *subsurface = + subsurface_at(view->wlr_surface, view_sx, view_sy, &sub_x, &sub_y); + + if (subsurface) { + *sx = view_sx - sub_x; + *sy = view_sy - sub_y; + *surface = subsurface->surface; + return view; + } + struct wlr_box box; view_get_input_bounds(view, &box); box.x += view->x; box.y += view->y; - if (wlr_box_contains_point(&box, x, y)) { + if (wlr_box_contains_point(&box, lx, ly)) { + *sx = view_sx; + *sy = view_sy; + *surface = view->wlr_surface; return view; } } diff --git a/rootston/output.c b/rootston/output.c index 5aeb71b1..14d1783e 100644 --- a/rootston/output.c +++ b/rootston/output.c @@ -16,28 +16,49 @@ static inline int64_t timespec_to_msec(const struct timespec *a) { return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000; } -static void render_view(struct roots_desktop *desktop, - struct wlr_output *wlr_output, struct timespec *when, - struct roots_view *view, double ox, double oy) { - struct wlr_surface *surface = view->wlr_surface; - float matrix[16]; - float transform[16]; +static void render_surface(struct wlr_surface *surface, + struct roots_desktop *desktop, struct wlr_output *wlr_output, + struct timespec *when, double lx, double ly) { wlr_surface_flush_damage(surface); if (surface->texture->valid) { - wlr_matrix_translate(&transform, ox, oy, 0); - wlr_surface_get_matrix(surface, &matrix, - &wlr_output->transform_matrix, &transform); - wlr_render_with_matrix(desktop->server->renderer, - surface->texture, &matrix); + int width = surface->current->buffer_width; + int height = surface->current->buffer_height; + double ox = lx, oy = ly; + wlr_output_layout_output_coords(desktop->layout, wlr_output, &ox, &oy); - struct wlr_frame_callback *cb, *cnext; - wl_list_for_each_safe(cb, cnext, &surface->frame_callback_list, link) { - wl_callback_send_done(cb->resource, timespec_to_msec(when)); - wl_resource_destroy(cb->resource); + if (wlr_output_layout_intersects(desktop->layout, wlr_output, + lx, ly, lx + width, ly + height)) { + float matrix[16]; + float transform[16]; + wlr_matrix_translate(&transform, ox, oy, 0); + wlr_surface_get_matrix(surface, &matrix, + &wlr_output->transform_matrix, &transform); + wlr_render_with_matrix(desktop->server->renderer, + surface->texture, &matrix); + + struct wlr_frame_callback *cb, *cnext; + wl_list_for_each_safe(cb, cnext, + &surface->current->frame_callback_list, link) { + wl_callback_send_done(cb->resource, timespec_to_msec(when)); + wl_resource_destroy(cb->resource); + } + } + + struct wlr_subsurface *subsurface; + wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) { + render_surface(subsurface->surface, desktop, wlr_output, when, + lx + subsurface->surface->current->subsurface_position.x, + ly + subsurface->surface->current->subsurface_position.y); } } } +static void render_view(struct roots_view *view, struct roots_desktop *desktop, + struct wlr_output *wlr_output, struct timespec *when) { + render_surface(view->wlr_surface, desktop, wlr_output, when, + view->x, view->y); +} + 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); @@ -52,16 +73,7 @@ static void output_frame_notify(struct wl_listener *listener, void *data) { for (size_t i = 0; i < desktop->views->length; ++i) { struct roots_view *view = desktop->views->items[i]; - int width = view->wlr_surface->current.buffer_width; - int height = view->wlr_surface->current.buffer_height; - - if (wlr_output_layout_intersects(desktop->layout, wlr_output, - view->x, view->y, view->x + width, view->y + height)) { - double ox = view->x, oy = view->y; - wlr_output_layout_output_coords( - desktop->layout, wlr_output, &ox, &oy); - render_view(desktop, wlr_output, &now, view, ox, oy); - } + render_view(view, desktop, wlr_output, &now); } wlr_renderer_end(server->renderer); diff --git a/types/wlr_compositor.c b/types/wlr_compositor.c index 0658f65e..12903cda 100644 --- a/types/wlr_compositor.c +++ b/types/wlr_compositor.c @@ -19,9 +19,11 @@ static void wl_compositor_create_surface(struct wl_client *client, compositor->renderer); surface->compositor_data = compositor; surface->compositor_listener.notify = &destroy_surface_listener; - wl_resource_add_destroy_listener(surface_resource, &surface->compositor_listener); + wl_resource_add_destroy_listener(surface_resource, + &surface->compositor_listener); - wl_list_insert(&compositor->surfaces, wl_resource_get_link(surface_resource)); + wl_list_insert(&compositor->surfaces, + wl_resource_get_link(surface_resource)); wl_signal_emit(&compositor->events.create_surface, surface); } @@ -52,15 +54,17 @@ static void wl_compositor_bind(struct wl_client *wl_client, void *_compositor, struct wlr_compositor *compositor = _compositor; assert(wl_client && compositor); if (version > 4) { - wlr_log(L_ERROR, "Client requested unsupported wl_compositor version, disconnecting"); + wlr_log(L_ERROR, "Client requested unsupported wl_compositor version, " + "disconnecting"); wl_client_destroy(wl_client); return; } - struct wl_resource *wl_resource = wl_resource_create( - wl_client, &wl_compositor_interface, version, id); + struct wl_resource *wl_resource = + wl_resource_create(wl_client, &wl_compositor_interface, version, id); wl_resource_set_implementation(wl_resource, &wl_compositor_impl, - compositor, wl_compositor_destroy); - wl_list_insert(&compositor->wl_resources, wl_resource_get_link(wl_resource)); + compositor, wl_compositor_destroy); + wl_list_insert(&compositor->wl_resources, + wl_resource_get_link(wl_resource)); } void wlr_compositor_destroy(struct wlr_compositor *compositor) { @@ -68,19 +72,96 @@ void wlr_compositor_destroy(struct wlr_compositor *compositor) { free(compositor); } +static void subcompositor_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static void subcompositor_get_subsurface(struct wl_client *client, + struct wl_resource *resource, uint32_t id, + struct wl_resource *surface_resource, + struct wl_resource *parent_resource) { + struct wlr_surface *surface = wl_resource_get_user_data(surface_resource); + struct wlr_surface *parent = wl_resource_get_user_data(parent_resource); + + static const char msg[] = "get_subsurface: wl_subsurface@"; + + if (surface == parent) { + wl_resource_post_error(resource, + WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE, + "%s%d: wl_surface@%d cannot be its own parent", + msg, id, wl_resource_get_id(surface_resource)); + return; + } + + if (surface->subsurface) { + wl_resource_post_error(resource, + WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE, + "%s%d: wl_surface@%d is already a sub-surface", + msg, id, wl_resource_get_id(surface_resource)); + return; + } + + if (wlr_surface_get_main_surface(parent) == surface) { + wl_resource_post_error(resource, + WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE, + "%s%d: wl_surface@%d is an ancestor of parent", + msg, id, wl_resource_get_id(surface_resource)); + return; + } + + if (wlr_surface_set_role(surface, "wl_subsurface", resource, + WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE) < 0) { + return; + } + + wlr_surface_make_subsurface(surface, parent, id); + if (!surface->subsurface) { + wl_resource_post_no_memory(resource); + return; + } +} + + +static const struct wl_subcompositor_interface subcompositor_interface = { + .destroy = subcompositor_destroy, + .get_subsurface = subcompositor_get_subsurface, +}; + +static void subcompositor_bind(struct wl_client *client, void *data, + uint32_t version, uint32_t id) { + struct wlr_compositor *compositor = data; + struct wl_resource *resource = + wl_resource_create(client, &wl_subcompositor_interface, 1, id); + if (resource == NULL) { + wl_client_post_no_memory(client); + return; + } + wl_resource_set_implementation(resource, &subcompositor_interface, + compositor, NULL); +} + struct wlr_compositor *wlr_compositor_create(struct wl_display *display, struct wlr_renderer *renderer) { - struct wlr_compositor *compositor = calloc(1, sizeof(struct wlr_compositor)); + struct wlr_compositor *compositor = + calloc(1, sizeof(struct wlr_compositor)); if (!compositor) { wlr_log_errno(L_ERROR, "Could not allocate wlr compositor"); return NULL; } - struct wl_global *wl_global = wl_global_create(display, + + struct wl_global *compositor_global = wl_global_create(display, &wl_compositor_interface, 4, compositor, wl_compositor_bind); - compositor->wl_global = wl_global; + + compositor->wl_global = compositor_global; compositor->renderer = renderer; + + wl_global_create(display, &wl_subcompositor_interface, 1, compositor, + subcompositor_bind); + wl_list_init(&compositor->wl_resources); wl_list_init(&compositor->surfaces); wl_signal_init(&compositor->events.create_surface); + return compositor; } diff --git a/types/wlr_surface.c b/types/wlr_surface.c index a9a54abe..e44ea9fc 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -7,7 +7,8 @@ #include #include -static void surface_destroy(struct wl_client *client, struct wl_resource *resource) { +static void surface_destroy(struct wl_client *client, + struct wl_resource *resource) { wl_resource_destroy(resource); } @@ -15,8 +16,9 @@ static void surface_attach(struct wl_client *client, struct wl_resource *resource, struct wl_resource *buffer, int32_t sx, int32_t sy) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - surface->pending.invalid |= WLR_SURFACE_INVALID_BUFFER; - surface->pending.buffer = buffer; + + surface->pending->invalid |= WLR_SURFACE_INVALID_BUFFER; + surface->pending->buffer = buffer; } static void surface_damage(struct wl_client *client, @@ -26,9 +28,9 @@ static void surface_damage(struct wl_client *client, if (width < 0 || height < 0) { return; } - surface->pending.invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE; - pixman_region32_union_rect(&surface->pending.surface_damage, - &surface->pending.surface_damage, + surface->pending->invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE; + pixman_region32_union_rect(&surface->pending->surface_damage, + &surface->pending->surface_damage, x, y, width, height); } @@ -60,22 +62,24 @@ static void surface_frame(struct wl_client *client, wl_resource_set_implementation(cb->resource, NULL, cb, destroy_frame_callback); - wl_list_insert(surface->frame_callback_list.prev, &cb->link); + wl_list_insert(surface->pending->frame_callback_list.prev, &cb->link); + + surface->pending->invalid |= WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST; } static void surface_set_opaque_region(struct wl_client *client, struct wl_resource *resource, struct wl_resource *region_resource) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - if ((surface->pending.invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { - pixman_region32_clear(&surface->pending.opaque); + if ((surface->pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { + pixman_region32_clear(&surface->pending->opaque); } - surface->pending.invalid |= WLR_SURFACE_INVALID_OPAQUE_REGION; + surface->pending->invalid |= WLR_SURFACE_INVALID_OPAQUE_REGION; if (region_resource) { pixman_region32_t *region = wl_resource_get_user_data(region_resource); - pixman_region32_copy(&surface->pending.opaque, region); + pixman_region32_copy(&surface->pending->opaque, region); } else { - pixman_region32_clear(&surface->pending.opaque); + pixman_region32_clear(&surface->pending->opaque); } } @@ -83,28 +87,28 @@ static void surface_set_input_region(struct wl_client *client, struct wl_resource *resource, struct wl_resource *region_resource) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - if ((surface->pending.invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { - pixman_region32_clear(&surface->pending.input); + if ((surface->pending->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { + pixman_region32_clear(&surface->pending->input); } - surface->pending.invalid |= WLR_SURFACE_INVALID_INPUT_REGION; + surface->pending->invalid |= WLR_SURFACE_INVALID_INPUT_REGION; if (region_resource) { pixman_region32_t *region = wl_resource_get_user_data(region_resource); - pixman_region32_copy(&surface->pending.input, region); + pixman_region32_copy(&surface->pending->input, region); } else { - pixman_region32_init_rect(&surface->pending.input, + pixman_region32_init_rect(&surface->pending->input, INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX); } } -static void wlr_surface_update_size(struct wlr_surface *surface) { - int scale = surface->current.scale; - enum wl_output_transform transform = surface->current.transform; +static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surface_state *state) { + int scale = state->scale; + enum wl_output_transform transform = state->transform; - wlr_texture_get_buffer_size(surface->texture, surface->current.buffer, - &surface->current.buffer_width, &surface->current.buffer_height); + wlr_texture_get_buffer_size(surface->texture, state->buffer, + &state->buffer_width, &state->buffer_height); - int _width = surface->current.buffer_width / scale; - int _height = surface->current.buffer_height / scale; + int _width = state->buffer_width / scale; + int _height = state->buffer_height / scale; if (transform == WL_OUTPUT_TRANSFORM_90 || transform == WL_OUTPUT_TRANSFORM_270 || @@ -115,17 +119,18 @@ static void wlr_surface_update_size(struct wlr_surface *surface) { _height = tmp; } - surface->current.width = _width; - surface->current.height = _height; + wl_list_init(&state->frame_callback_list); + + state->width = _width; + state->height = _height; } -static void wlr_surface_to_buffer_region(struct wlr_surface *surface, - pixman_region32_t *surface_region, pixman_region32_t *buffer_region, +static void wlr_surface_to_buffer_region(int scale, + enum wl_output_transform transform, pixman_region32_t *surface_region, + pixman_region32_t *buffer_region, int width, int height) { pixman_box32_t *src_rects, *dest_rects; int nrects, i; - int scale = surface->current.scale; - enum wl_output_transform transform = surface->current.transform; src_rects = pixman_region32_rectangles(surface_region, &nrects); dest_rects = malloc(nrects * sizeof(*dest_rects)); @@ -201,89 +206,227 @@ static void wlr_surface_to_buffer_region(struct wlr_surface *surface, free(dest_rects); } -static void surface_commit(struct wl_client *client, - struct wl_resource *resource) { - struct wlr_surface *surface = wl_resource_get_user_data(resource); - bool update_size = false; +/** + * Append pending state to current state and clear pending state. + */ +static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surface_state *next, + struct wlr_surface_state *state) { bool update_damage = false; + bool update_size = false; - if ((surface->pending.invalid & WLR_SURFACE_INVALID_SCALE)) { - surface->current.scale = surface->pending.scale; + if ((next->invalid & WLR_SURFACE_INVALID_SCALE)) { + state->scale = next->scale; update_size = true; } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_TRANSFORM)) { - surface->current.transform = surface->pending.transform; + if ((next->invalid & WLR_SURFACE_INVALID_TRANSFORM)) { + state->transform = next->transform; update_size = true; } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER)) { - surface->current.buffer = surface->pending.buffer; + if ((next->invalid & WLR_SURFACE_INVALID_BUFFER)) { + if (state->buffer) { + wl_resource_post_event(state->buffer, WL_BUFFER_RELEASE); + } + + state->buffer = next->buffer; + next->buffer = NULL; update_size = true; } if (update_size) { - int32_t oldw = surface->current.buffer_width; - int32_t oldh = surface->current.buffer_height; - wlr_surface_update_size(surface); - - surface->reupload_buffer = oldw != surface->current.buffer_width || - oldh != surface->current.buffer_height; + wlr_surface_update_size(surface, state); } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) { - pixman_region32_union(&surface->current.surface_damage, - &surface->current.surface_damage, - &surface->pending.surface_damage); - pixman_region32_intersect_rect(&surface->current.surface_damage, - &surface->current.surface_damage, 0, 0, surface->current.width, - surface->current.height); + if ((next->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) { + pixman_region32_union(&state->surface_damage, + &state->surface_damage, + &next->surface_damage); + pixman_region32_intersect_rect(&state->surface_damage, + &state->surface_damage, 0, 0, state->width, + state->height); - pixman_region32_clear(&surface->pending.surface_damage); + pixman_region32_clear(&next->surface_damage); update_damage = true; } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) { - pixman_region32_union(&surface->current.buffer_damage, - &surface->current.buffer_damage, - &surface->pending.buffer_damage); + if ((next->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) { + pixman_region32_union(&state->buffer_damage, + &state->buffer_damage, + &next->buffer_damage); - pixman_region32_clear(&surface->pending.buffer_damage); + pixman_region32_clear(&next->buffer_damage); update_damage = true; } if (update_damage) { pixman_region32_t buffer_damage; pixman_region32_init(&buffer_damage); - wlr_surface_to_buffer_region(surface, &surface->current.surface_damage, - &buffer_damage, surface->current.width, surface->current.height); - pixman_region32_union(&surface->current.buffer_damage, - &surface->current.buffer_damage, &buffer_damage); + wlr_surface_to_buffer_region(state->scale, state->transform, + &state->surface_damage, &buffer_damage, state->width, + state->height); + pixman_region32_union(&state->buffer_damage, + &state->buffer_damage, &buffer_damage); pixman_region32_fini(&buffer_damage); - pixman_region32_intersect_rect(&surface->current.buffer_damage, - &surface->current.buffer_damage, 0, 0, - surface->current.buffer_width, surface->current.buffer_height); + pixman_region32_intersect_rect(&state->buffer_damage, + &state->buffer_damage, 0, 0, + state->buffer_width, state->buffer_height); } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { + if ((next->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { // TODO: process buffer - pixman_region32_clear(&surface->pending.opaque); + pixman_region32_clear(&next->opaque); } - if ((surface->pending.invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { + if ((next->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { // TODO: process buffer - pixman_region32_clear(&surface->pending.input); + pixman_region32_clear(&next->input); + } + if ((next->invalid & WLR_SURFACE_INVALID_SUBSURFACE_POSITION)) { + state->subsurface_position.x = next->subsurface_position.x; + state->subsurface_position.y = next->subsurface_position.y; + next->subsurface_position.x = 0; + next->subsurface_position.y = 0; + } + if ((next->invalid & WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST)) { + wl_list_insert_list(&state->frame_callback_list, &next->frame_callback_list); + wl_list_init(&next->frame_callback_list); } - surface->pending.invalid = 0; + state->invalid |= next->invalid; + next->invalid = 0; +} + +static void wlr_surface_damage_subsurfaces(struct wlr_subsurface *subsurface) { + // XXX: This is probably the wrong way to do it, because this damage should + // come from the client, but weston doesn't do it correctly either and it + // seems to work ok. See the comment on weston_surface_damage for more info + // about a better approach. + struct wlr_surface *surface = subsurface->surface; + pixman_region32_union_rect(&surface->current->surface_damage, + &surface->current->surface_damage, + 0, 0, surface->current->width, + surface->current->height); + + subsurface->reordered = false; + + struct wlr_subsurface *child; + wl_list_for_each(child, &subsurface->surface->subsurface_list, parent_link) { + wlr_surface_damage_subsurfaces(child); + } +} + +static void wlr_surface_commit_pending(struct wlr_surface *surface) { + int32_t oldw = surface->current->buffer_width; + int32_t oldh = surface->current->buffer_height; + + wlr_surface_move_state(surface, surface->pending, surface->current); + + // commit subsurface order + struct wlr_subsurface *subsurface; + wl_list_for_each_reverse(subsurface, &surface->subsurface_pending_list, + parent_pending_link) { + wl_list_remove(&subsurface->parent_link); + wl_list_insert(&surface->subsurface_list, &subsurface->parent_link); + + if (subsurface->reordered) { + // TODO: damage all the subsurfaces + wlr_surface_damage_subsurfaces(subsurface); + } + } + + surface->reupload_buffer = oldw != surface->current->buffer_width || + oldh != surface->current->buffer_height; + // TODO: add the invalid bitfield to this callback wl_signal_emit(&surface->signals.commit, surface); } +static bool wlr_subsurface_is_synchronized(struct wlr_subsurface *subsurface) { + while (subsurface) { + if (subsurface->synchronized) { + return true; + } + + if (!subsurface->parent) { + return false; + } + + subsurface = subsurface->parent->subsurface; + } + + return false; +} + +/** + * Recursive function to commit the effectively synchronized children. + */ +static void wlr_subsurface_parent_commit(struct wlr_subsurface *subsurface, + bool synchronized) { + struct wlr_surface *surface = subsurface->surface; + if (synchronized || subsurface->synchronized) { + + if (subsurface->has_cache) { + wlr_surface_move_state(surface, subsurface->cached, surface->pending); + wlr_surface_commit_pending(surface); + subsurface->has_cache = false; + subsurface->cached->invalid = 0; + } + + struct wlr_subsurface *tmp; + wl_list_for_each(tmp, &surface->subsurface_list, parent_link) { + wlr_subsurface_parent_commit(tmp, true); + } + } +} + +static void wlr_subsurface_commit(struct wlr_subsurface *subsurface) { + struct wlr_surface *surface = subsurface->surface; + + if (wlr_subsurface_is_synchronized(subsurface)) { + wlr_surface_move_state(surface, surface->pending, subsurface->cached); + subsurface->has_cache = true; + } else { + if (subsurface->has_cache) { + wlr_surface_move_state(surface, subsurface->cached, surface->pending); + wlr_surface_commit_pending(surface); + subsurface->has_cache = false; + + } else { + wlr_surface_commit_pending(surface); + } + + struct wlr_subsurface *tmp; + wl_list_for_each(tmp, &surface->subsurface_list, parent_link) { + wlr_subsurface_parent_commit(tmp, false); + } + } + +} + +static void surface_commit(struct wl_client *client, + struct wl_resource *resource) { + struct wlr_surface *surface = wl_resource_get_user_data(resource); + struct wlr_subsurface *subsurface = surface->subsurface; + + if (subsurface) { + wlr_subsurface_commit(subsurface); + return; + } + + wlr_surface_commit_pending(surface); + + struct wlr_subsurface *tmp; + wl_list_for_each(tmp, &surface->subsurface_list, parent_link) { + wlr_subsurface_parent_commit(tmp, false); + } +} + void wlr_surface_flush_damage(struct wlr_surface *surface) { - if (!surface->current.buffer) { + if (!surface->current->buffer) { if (surface->texture->valid) { // TODO: Detach buffers } return; } - struct wl_shm_buffer *buffer = wl_shm_buffer_get(surface->current.buffer); + struct wl_shm_buffer *buffer = wl_shm_buffer_get(surface->current->buffer); if (!buffer) { - if (wlr_renderer_buffer_is_drm(surface->renderer, surface->pending.buffer)) { - wlr_texture_upload_drm(surface->texture, surface->pending.buffer); + if (wlr_renderer_buffer_is_drm(surface->renderer, + surface->current->buffer)) { + wlr_texture_upload_drm(surface->texture, surface->current->buffer); goto release; } else { wlr_log(L_INFO, "Unknown buffer handle attached"); @@ -295,7 +438,7 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) { if (surface->reupload_buffer) { wlr_texture_upload_shm(surface->texture, format, buffer); } else { - pixman_region32_t damage = surface->current.buffer_damage; + pixman_region32_t damage = surface->current->buffer_damage; if (!pixman_region32_not_empty(&damage)) { goto release; } @@ -314,26 +457,26 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) { } release: - pixman_region32_clear(&surface->current.surface_damage); - pixman_region32_clear(&surface->current.buffer_damage); + pixman_region32_clear(&surface->current->surface_damage); + pixman_region32_clear(&surface->current->buffer_damage); - wl_resource_post_event(surface->current.buffer, WL_BUFFER_RELEASE); - surface->current.buffer = NULL; + wl_resource_post_event(surface->current->buffer, WL_BUFFER_RELEASE); + surface->current->buffer = NULL; } static void surface_set_buffer_transform(struct wl_client *client, struct wl_resource *resource, int transform) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - surface->pending.invalid |= WLR_SURFACE_INVALID_TRANSFORM; - surface->pending.transform = transform; + surface->pending->invalid |= WLR_SURFACE_INVALID_TRANSFORM; + surface->pending->transform = transform; } static void surface_set_buffer_scale(struct wl_client *client, struct wl_resource *resource, int32_t scale) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - surface->pending.invalid |= WLR_SURFACE_INVALID_SCALE; - surface->pending.scale = scale; + surface->pending->invalid |= WLR_SURFACE_INVALID_SCALE; + surface->pending->scale = scale; } static void surface_damage_buffer(struct wl_client *client, @@ -344,9 +487,9 @@ static void surface_damage_buffer(struct wl_client *client, if (width < 0 || height < 0) { return; } - surface->pending.invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE; - pixman_region32_union_rect(&surface->pending.buffer_damage, - &surface->pending.buffer_damage, + surface->pending->invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE; + pixman_region32_union_rect(&surface->pending->buffer_damage, + &surface->pending->buffer_damage, x, y, width, height); } @@ -363,19 +506,62 @@ const struct wl_surface_interface surface_interface = { .damage_buffer = surface_damage_buffer }; +static struct wlr_surface_state *wlr_surface_state_create() { + struct wlr_surface_state *state = calloc(1, sizeof(struct wlr_surface_state)); + state->scale = 1; + state->transform = WL_OUTPUT_TRANSFORM_NORMAL; + + wl_list_init(&state->frame_callback_list); + + pixman_region32_init(&state->surface_damage); + pixman_region32_init(&state->buffer_damage); + pixman_region32_init(&state->opaque); + pixman_region32_init(&state->input); + + return state; +} + +static void wlr_surface_state_destroy(struct wlr_surface_state *state) { + struct wlr_frame_callback *cb, *tmp; + wl_list_for_each_safe(cb, tmp, &state->frame_callback_list, link) { + wl_resource_destroy(cb->resource); + } + + pixman_region32_fini(&state->surface_damage); + pixman_region32_fini(&state->buffer_damage); + pixman_region32_fini(&state->opaque); + pixman_region32_fini(&state->input); + + free(state); +} + +void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { + wlr_surface_state_destroy(subsurface->cached); + + if (subsurface->parent) { + wl_list_remove(&subsurface->parent_link); + wl_list_remove(&subsurface->parent_pending_link); + wl_list_remove(&subsurface->parent_destroy_listener.link); + } + + wl_resource_set_user_data(subsurface->resource, NULL); + if (subsurface->surface) { + subsurface->surface->subsurface = NULL; + } + free(subsurface); +} + static void destroy_surface(struct wl_resource *resource) { struct wlr_surface *surface = wl_resource_get_user_data(resource); wl_signal_emit(&surface->signals.destroy, surface); - wlr_texture_destroy(surface->texture); - struct wlr_frame_callback *cb, *next; - wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link) { - wl_resource_destroy(cb->resource); + if (surface->subsurface) { + wlr_subsurface_destroy(surface->subsurface); } - pixman_region32_fini(&surface->pending.surface_damage); - pixman_region32_fini(&surface->pending.buffer_damage); - pixman_region32_fini(&surface->pending.opaque); - pixman_region32_fini(&surface->pending.input); + + wlr_texture_destroy(surface->texture); + wlr_surface_state_destroy(surface->pending); + wlr_surface_state_destroy(surface->current); free(surface); } @@ -391,17 +577,14 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res, surface->renderer = renderer; surface->texture = wlr_render_texture_create(renderer); surface->resource = res; - surface->current.scale = 1; - surface->pending.scale = 1; - surface->current.transform = WL_OUTPUT_TRANSFORM_NORMAL; - surface->pending.transform = WL_OUTPUT_TRANSFORM_NORMAL; - pixman_region32_init(&surface->pending.surface_damage); - pixman_region32_init(&surface->pending.buffer_damage); - pixman_region32_init(&surface->pending.opaque); - pixman_region32_init(&surface->pending.input); + + surface->current = wlr_surface_state_create(); + surface->pending = wlr_surface_state_create(); + wl_signal_init(&surface->signals.commit); wl_signal_init(&surface->signals.destroy); - wl_list_init(&surface->frame_callback_list); + wl_list_init(&surface->subsurface_list); + wl_list_init(&surface->subsurface_pending_list); wl_resource_set_implementation(res, &surface_interface, surface, destroy_surface); return surface; @@ -411,8 +594,8 @@ void wlr_surface_get_matrix(struct wlr_surface *surface, float (*matrix)[16], const float (*projection)[16], const float (*transform)[16]) { - int width = surface->texture->width / surface->current.scale; - int height = surface->texture->height / surface->current.scale; + int width = surface->texture->width / surface->current->scale; + int height = surface->texture->height / surface->current->scale; float scale[16]; wlr_matrix_identity(matrix); if (transform) { @@ -443,3 +626,180 @@ int wlr_surface_set_role(struct wlr_surface *surface, const char *role, return -1; } + +static void subsurface_resource_destroy(struct wl_resource *resource) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + + if (subsurface) { + wlr_subsurface_destroy(subsurface); + } +} + +static void subsurface_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static void subsurface_set_position(struct wl_client *client, + struct wl_resource *resource, int32_t x, int32_t y) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + struct wlr_surface *surface = subsurface->surface; + + surface->pending->invalid |= WLR_SURFACE_INVALID_SUBSURFACE_POSITION; + + surface->pending->subsurface_position.x = x; + surface->pending->subsurface_position.y = y; +} + +static struct wlr_subsurface *subsurface_find_sibling( + struct wlr_subsurface *subsurface, struct wlr_surface *surface) { + struct wlr_surface *parent = subsurface->parent; + + struct wlr_subsurface *sibling; + wl_list_for_each(sibling, &parent->subsurface_list, parent_link) { + if (sibling->surface == surface && sibling != subsurface) + return sibling; + } + + return NULL; +} + +static void subsurface_place_above(struct wl_client *client, + struct wl_resource *resource, struct wl_resource *sibling_resource) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + + if (!subsurface) { + return; + } + + struct wlr_surface *sibling_surface = + wl_resource_get_user_data(sibling_resource); + struct wlr_subsurface *sibling = + subsurface_find_sibling(subsurface, sibling_surface); + + if (!sibling) { + wl_resource_post_error(subsurface->resource, + WL_SUBSURFACE_ERROR_BAD_SURFACE, + "%s: wl_surface@%d is not a parent or sibling", + "place_above", wl_resource_get_id(sibling_surface->resource)); + return; + } + + wl_list_remove(&subsurface->parent_pending_link); + wl_list_insert(sibling->parent_pending_link.prev, + &subsurface->parent_pending_link); + + subsurface->reordered = true; +} + +static void subsurface_place_below(struct wl_client *client, + struct wl_resource *resource, struct wl_resource *sibling_resource) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + + struct wlr_surface *sibling_surface = + wl_resource_get_user_data(sibling_resource); + struct wlr_subsurface *sibling = + subsurface_find_sibling(subsurface, sibling_surface); + + if (!sibling) { + wl_resource_post_error(subsurface->resource, + WL_SUBSURFACE_ERROR_BAD_SURFACE, + "%s: wl_surface@%d is not a parent or sibling", + "place_below", wl_resource_get_id(sibling_surface->resource)); + return; + } + + wl_list_remove(&subsurface->parent_pending_link); + wl_list_insert(&sibling->parent_pending_link, + &subsurface->parent_pending_link); + + subsurface->reordered = true; +} + +static void subsurface_set_sync(struct wl_client *client, + struct wl_resource *resource) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + + if (subsurface) { + subsurface->synchronized = true; + } +} + +static void subsurface_set_desync(struct wl_client *client, + struct wl_resource *resource) { + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + + if (subsurface && subsurface->synchronized) { + subsurface->synchronized = false; + + if (!wlr_subsurface_is_synchronized(subsurface)) { + // TODO: do a synchronized commit to flush the cache + wlr_subsurface_parent_commit(subsurface, true); + } + } +} + +static const struct wl_subsurface_interface subsurface_implementation = { + .destroy = subsurface_destroy, + .set_position = subsurface_set_position, + .place_above = subsurface_place_above, + .place_below = subsurface_place_below, + .set_sync = subsurface_set_sync, + .set_desync = subsurface_set_desync, +}; + +static void subsurface_handle_parent_destroy(struct wl_listener *listener, + void *data) { + struct wlr_subsurface *subsurface = + wl_container_of(listener, subsurface, parent_destroy_listener); + wl_list_remove(&subsurface->parent_link); + wl_list_remove(&subsurface->parent_pending_link); + wl_list_remove(&subsurface->parent_destroy_listener.link); + subsurface->parent = NULL; +} + +void wlr_surface_make_subsurface(struct wlr_surface *surface, + struct wlr_surface *parent, uint32_t id) { + assert(surface->subsurface == NULL); + + struct wlr_subsurface *subsurface = + calloc(1, sizeof(struct wlr_subsurface)); + if (!subsurface) { + return; + } + subsurface->cached = wlr_surface_state_create(); + subsurface->synchronized = true; + subsurface->surface = surface; + + // link parent + subsurface->parent = parent; + wl_signal_add(&parent->signals.destroy, + &subsurface->parent_destroy_listener); + subsurface->parent_destroy_listener.notify = + subsurface_handle_parent_destroy; + wl_list_insert(&parent->subsurface_list, &subsurface->parent_link); + wl_list_insert(&parent->subsurface_pending_list, + &subsurface->parent_pending_link); + + struct wl_client *client = wl_resource_get_client(surface->resource); + + subsurface->resource = + wl_resource_create(client, &wl_subsurface_interface, 1, id); + + wl_resource_set_implementation(subsurface->resource, + &subsurface_implementation, subsurface, + subsurface_resource_destroy); + + surface->subsurface = subsurface; +} + + +struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface) { + struct wlr_subsurface *sub; + + while (surface && (sub = surface->subsurface)) { + surface = sub->parent; + } + + return surface; +} diff --git a/types/wlr_xdg_shell_v6.c b/types/wlr_xdg_shell_v6.c index a7450add..9f623420 100644 --- a/types/wlr_xdg_shell_v6.c +++ b/types/wlr_xdg_shell_v6.c @@ -496,7 +496,7 @@ static void wlr_xdg_surface_v6_toplevel_committed( struct wlr_xdg_surface_v6 *surface) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); - if (!surface->surface->current.buffer && !surface->toplevel_state->added) { + if (!surface->surface->current->buffer && !surface->toplevel_state->added) { // on the first commit, send a configure request to tell the client it // is added wlr_xdg_surface_v6_schedule_configure(surface, true); @@ -504,7 +504,7 @@ static void wlr_xdg_surface_v6_toplevel_committed( return; } - if (!surface->surface->current.buffer) { + if (!surface->surface->current->buffer) { return; } @@ -516,7 +516,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener, struct wlr_xdg_surface_v6 *surface = wl_container_of(listener, surface, surface_commit_listener); - if (surface->surface->current.buffer && !surface->configured) { + if (surface->surface->current->buffer && !surface->configured) { wl_resource_post_error(surface->resource, ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER, "xdg_surface has never been configured"); @@ -580,7 +580,7 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client, &zxdg_surface_v6_interface, wl_resource_get_version(client_resource), id); - if (surface->surface->current.buffer != NULL) { + if (surface->surface->current->buffer != NULL) { wl_resource_post_error(surface->resource, ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER, "xdg_surface must not have a buffer at creation");