From 68eeebc6478373c07582237118ce828e3b469bae Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sun, 24 Sep 2017 08:23:18 -0400 Subject: subsurface implementation stubs --- include/wlr/types/wlr_surface.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 87d421e3..eb88a663 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -19,6 +19,12 @@ struct wlr_frame_callback { #define WLR_SURFACE_INVALID_TRANSFORM 32 #define WLR_SURFACE_INVALID_SCALE 64 +struct wlr_subsurface { + struct wl_resource *resource; + struct wlr_surface *surface; + struct wlr_surface *parent; +}; + struct wlr_surface_state { uint32_t invalid; struct wl_resource *buffer; @@ -52,6 +58,9 @@ struct wlr_surface { struct wl_listener compositor_listener; // destroy listener used by compositor void *compositor_data; + // subsurface properties + struct wlr_subsurface *subsurface; + void *data; }; @@ -80,4 +89,10 @@ 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); + #endif -- cgit v1.2.3 From 7f39578824b9732bec7925b3745deb59fab3681f Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sun, 24 Sep 2017 08:25:53 -0400 Subject: cleanup wlr_surface.[ch] --- include/wlr/types/wlr_surface.h | 4 ++-- types/wlr_surface.c | 6 ++++-- 2 files changed, 6 insertions(+), 4 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index eb88a663..04c64a72 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -54,8 +54,8 @@ struct wlr_surface { } 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 diff --git a/types/wlr_surface.c b/types/wlr_surface.c index de28f4df..d5e0e6a2 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); } @@ -282,7 +283,8 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) { } 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)) { + if (wlr_renderer_buffer_is_drm(surface->renderer, + surface->pending.buffer)) { wlr_texture_upload_drm(surface->texture, surface->pending.buffer); goto release; } else { -- cgit v1.2.3 From cb2d05e83b22ecd5d5bec8f1787aa7b15be6e276 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sun, 24 Sep 2017 11:17:17 -0400 Subject: subsurface sync and position --- include/wlr/types/wlr_surface.h | 25 +++++++++++++++++++------ types/wlr_surface.c | 37 ++++++++++++++++++++++++++++++++++--- 2 files changed, 53 insertions(+), 9 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 04c64a72..07f19b67 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -19,12 +19,6 @@ struct wlr_frame_callback { #define WLR_SURFACE_INVALID_TRANSFORM 32 #define WLR_SURFACE_INVALID_SCALE 64 -struct wlr_subsurface { - struct wl_resource *resource; - struct wlr_surface *surface; - struct wlr_surface *parent; -}; - struct wlr_surface_state { uint32_t invalid; struct wl_resource *buffer; @@ -37,6 +31,25 @@ struct wlr_surface_state { int buffer_width, buffer_height; }; +struct wlr_subsurface { + struct wl_resource *resource; + struct wlr_surface *surface; + struct wlr_surface *parent; + + struct wlr_surface_state cached; + + struct { + int32_t x, y; + } position; + + struct { + int32_t x, y; + bool set; + } pending_position; + + bool synchronized; +}; + struct wlr_surface { struct wl_resource *resource; struct wlr_renderer *renderer; diff --git a/types/wlr_surface.c b/types/wlr_surface.c index d5e0e6a2..3ac6c08e 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -450,6 +450,22 @@ void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { wlr_log(L_DEBUG, "TODO: wlr subsurface destroy"); } +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; +} + static void subsurface_resource_destroy(struct wl_resource *resource) { struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); @@ -465,7 +481,10 @@ static void subsurface_destroy(struct wl_client *client, static void subsurface_set_position(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y) { - wlr_log(L_DEBUG, "TODO: subsurface set position"); + struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); + subsurface->pending_position.set = true; + subsurface->pending_position.x = x; + subsurface->pending_position.y = y; } static void subsurface_place_above(struct wl_client *client, @@ -480,12 +499,24 @@ static void subsurface_place_below(struct wl_client *client, static void subsurface_set_sync(struct wl_client *client, struct wl_resource *resource) { - wlr_log(L_DEBUG, "TODO: subsurface set sync"); + 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) { - wlr_log(L_DEBUG, "TODO: subsurface set desync"); + 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 + } + } } static const struct wl_subsurface_interface subsurface_implementation = { -- cgit v1.2.3 From 86bc4840a069480cfcc71e38bc959d8133b2d7c6 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sun, 24 Sep 2017 18:24:48 -0400 Subject: subsurface commit and render --- include/wlr/types/wlr_surface.h | 26 +-- types/wlr_surface.c | 414 +++++++++++++++++++++++++++++----------- types/wlr_xdg_shell_v6.c | 8 +- 3 files changed, 318 insertions(+), 130 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 07f19b67..c9abf042 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,6 +31,12 @@ 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 { @@ -36,25 +44,19 @@ struct wlr_subsurface { struct wlr_surface *surface; struct wlr_surface *parent; - struct wlr_surface_state cached; - - struct { - int32_t x, y; - } position; - - struct { - int32_t x, y; - bool set; - } pending_position; + struct wlr_surface_state *cached; + bool has_cache; bool synchronized; + + struct wl_list parent_link; }; 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]; @@ -66,13 +68,13 @@ struct wlr_surface { struct wl_signal destroy; } signals; - struct wl_list frame_callback_list; // wl_surface.frame // 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 void *data; }; diff --git a/types/wlr_surface.c b/types/wlr_surface.c index 7ae22eaa..99e6b6dd 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -16,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, @@ -27,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); } @@ -61,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); } } @@ -84,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 *current) { + int scale = current->scale; + enum wl_output_transform transform = current->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, current->buffer, + ¤t->buffer_width, ¤t->buffer_height); - int _width = surface->current.buffer_width / scale; - int _height = surface->current.buffer_height / scale; + int _width = current->buffer_width / scale; + int _height = current->buffer_height / scale; if (transform == WL_OUTPUT_TRANSFORM_90 || transform == WL_OUTPUT_TRANSFORM_270 || @@ -116,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(¤t->frame_callback_list); + + current->width = _width; + current->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)); @@ -202,45 +206,129 @@ static void wlr_surface_to_buffer_region(struct wlr_surface *surface, free(dest_rects); } +/** + * Append pending state to current state and clear pending state. + */ +static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surface_state *pending, + struct wlr_surface_state *current) { + bool update_damage = false; + bool update_size = false; + + if ((pending->invalid & WLR_SURFACE_INVALID_SCALE)) { + current->scale = pending->scale; + update_size = true; + } + if ((pending->invalid & WLR_SURFACE_INVALID_TRANSFORM)) { + current->transform = pending->transform; + update_size = true; + } + if ((pending->invalid & WLR_SURFACE_INVALID_BUFFER)) { + if (current->buffer) { + wl_resource_post_event(current->buffer, WL_BUFFER_RELEASE); + } + + current->buffer = pending->buffer; + pending->buffer = NULL; + update_size = true; + } + if (update_size) { + wlr_surface_update_size(surface, current); + } + if ((pending->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) { + pixman_region32_union(¤t->surface_damage, + ¤t->surface_damage, + &pending->surface_damage); + pixman_region32_intersect_rect(¤t->surface_damage, + ¤t->surface_damage, 0, 0, current->width, + current->height); + + pixman_region32_clear(&pending->surface_damage); + update_damage = true; + } + if ((pending->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) { + pixman_region32_union(¤t->buffer_damage, + ¤t->buffer_damage, + &pending->buffer_damage); + + pixman_region32_clear(&pending->buffer_damage); + update_damage = true; + } + if (update_damage) { + pixman_region32_t buffer_damage; + pixman_region32_init(&buffer_damage); + wlr_surface_to_buffer_region(current->scale, current->transform, + ¤t->surface_damage, &buffer_damage, current->width, + current->height); + pixman_region32_union(¤t->buffer_damage, + ¤t->buffer_damage, &buffer_damage); + pixman_region32_fini(&buffer_damage); + + pixman_region32_intersect_rect(¤t->buffer_damage, + ¤t->buffer_damage, 0, 0, + current->buffer_width, current->buffer_height); + } + if ((pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { + // TODO: process buffer + pixman_region32_clear(&pending->opaque); + } + if ((pending->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { + // TODO: process buffer + pixman_region32_clear(&pending->input); + } + if ((pending->invalid & WLR_SURFACE_INVALID_SUBSURFACE_POSITION)) { + current->subsurface_position.x = pending->subsurface_position.x; + current->subsurface_position.y = pending->subsurface_position.y; + pending->subsurface_position.x = 0; + pending->subsurface_position.y = 0; + } + if ((pending->invalid & WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST)) { + wl_list_insert_list(¤t->frame_callback_list, &pending->frame_callback_list); + wl_list_init(&pending->frame_callback_list); + } + + current->invalid |= pending->invalid; + pending->invalid = 0; +} + static void wlr_surface_commit_state(struct wlr_surface *surface, struct wlr_surface_state *pending) { bool update_size = false; bool update_damage = false; if ((pending->invalid & WLR_SURFACE_INVALID_SCALE)) { - surface->current.scale = pending->scale; + surface->current->scale = pending->scale; update_size = true; } if ((pending->invalid & WLR_SURFACE_INVALID_TRANSFORM)) { - surface->current.transform = pending->transform; + surface->current->transform = pending->transform; update_size = true; } if ((pending->invalid & WLR_SURFACE_INVALID_BUFFER)) { - surface->current.buffer = pending->buffer; + surface->current->buffer = pending->buffer; 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); + int32_t oldw = surface->current->buffer_width; + int32_t oldh = surface->current->buffer_height; + wlr_surface_update_size(surface, surface->current); - surface->reupload_buffer = oldw != surface->current.buffer_width || - oldh != surface->current.buffer_height; + surface->reupload_buffer = oldw != surface->current->buffer_width || + oldh != surface->current->buffer_height; } if ((pending->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) { - pixman_region32_union(&surface->current.surface_damage, - &surface->current.surface_damage, + pixman_region32_union(&surface->current->surface_damage, + &surface->current->surface_damage, &pending->surface_damage); - pixman_region32_intersect_rect(&surface->current.surface_damage, - &surface->current.surface_damage, 0, 0, surface->current.width, - surface->current.height); + pixman_region32_intersect_rect(&surface->current->surface_damage, + &surface->current->surface_damage, 0, 0, surface->current->width, + surface->current->height); pixman_region32_clear(&pending->surface_damage); update_damage = true; } if ((pending->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) { - pixman_region32_union(&surface->current.buffer_damage, - &surface->current.buffer_damage, + pixman_region32_union(&surface->current->buffer_damage, + &surface->current->buffer_damage, &pending->buffer_damage); pixman_region32_clear(&pending->buffer_damage); @@ -249,15 +337,16 @@ static void wlr_surface_commit_state(struct wlr_surface *surface, 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(surface->current->scale, + surface->current->transform, &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); 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(&surface->current->buffer_damage, + &surface->current->buffer_damage, 0, 0, + surface->current->buffer_width, surface->current->buffer_height); } if ((pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { // TODO: process buffer @@ -267,31 +356,114 @@ static void wlr_surface_commit_state(struct wlr_surface *surface, // TODO: process buffer pixman_region32_clear(&pending->input); } + if ((pending->invalid & WLR_SURFACE_INVALID_SUBSURFACE_POSITION)) { + surface->current->subsurface_position.x = pending->subsurface_position.x; + surface->current->subsurface_position.y = pending->subsurface_position.y; + } + if ((pending->invalid & WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST)) { + wl_list_insert_list(&surface->current->frame_callback_list, &pending->frame_callback_list); + wl_list_init(&pending->frame_callback_list); + } pending->invalid = 0; // 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_flush_damage(surface); + wlr_surface_commit_state(surface, surface->pending); + 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_state(surface, surface->pending); + wlr_surface_flush_damage(surface); + subsurface->has_cache = false; + + } else { + wlr_surface_commit_state(surface, surface->pending); + } + + 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; - wlr_surface_commit_state(surface, &surface->pending); + if (subsurface) { + wlr_subsurface_commit(subsurface); + return; + } + + wlr_surface_commit_state(surface, surface->pending); + + 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); + surface->pending->buffer)) { + wlr_texture_upload_drm(surface->texture, surface->pending->buffer); goto release; } else { wlr_log(L_INFO, "Unknown buffer handle attached"); @@ -303,7 +475,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; } @@ -322,26 +494,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, @@ -352,9 +524,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); } @@ -371,31 +543,58 @@ const struct wl_surface_interface surface_interface = { .damage_buffer = surface_damage_buffer }; -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); - } - 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); - - free(surface); -} - -void wlr_surface_state_init(struct wlr_surface_state *state) { +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 *current) { + struct wlr_frame_callback *cb, *tmp; + wl_list_for_each_safe(cb, tmp, ¤t->frame_callback_list, link) { + wl_resource_destroy(cb->resource); + } + + pixman_region32_fini(¤t->surface_damage); + pixman_region32_fini(¤t->buffer_damage); + pixman_region32_fini(¤t->opaque); + pixman_region32_fini(¤t->input); + + free(current); +} + +void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { + wlr_surface_state_destroy(subsurface->cached); + wl_list_remove(&subsurface->parent_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); + + if (surface->subsurface) { + wlr_subsurface_destroy(surface->subsurface); + } + + wlr_texture_destroy(surface->texture); + wlr_surface_state_destroy(surface->pending); + wlr_surface_state_destroy(surface->current); + + free(surface); } struct wlr_surface *wlr_surface_create(struct wl_resource *res, @@ -410,12 +609,12 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res, surface->texture = wlr_render_texture_create(renderer); surface->resource = res; - wlr_surface_state_init(&surface->current); - wlr_surface_state_init(&surface->pending); + 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_resource_set_implementation(res, &surface_interface, surface, destroy_surface); return surface; @@ -425,8 +624,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) { @@ -458,26 +657,6 @@ int wlr_surface_set_role(struct wlr_surface *surface, const char *role, return -1; } -void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { - wlr_log(L_DEBUG, "TODO: wlr subsurface destroy"); -} - -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; -} - static void subsurface_resource_destroy(struct wl_resource *resource) { struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource); @@ -494,9 +673,12 @@ static void subsurface_destroy(struct wl_client *client, 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); - subsurface->pending_position.set = true; - subsurface->pending_position.x = x; - subsurface->pending_position.y = y; + 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 void subsurface_place_above(struct wl_client *client, @@ -527,6 +709,7 @@ static void subsurface_set_desync(struct wl_client *client, if (!wlr_subsurface_is_synchronized(subsurface)) { // TODO: do a synchronized commit to flush the cache + wlr_subsurface_parent_commit(subsurface, true); } } } @@ -549,9 +732,12 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface, if (!subsurface) { return; } + subsurface->cached = wlr_surface_state_create(); subsurface->surface = surface; subsurface->parent = parent; + subsurface->synchronized = true; + wl_list_insert(&parent->subsurface_list, &subsurface->parent_link); struct wl_client *client = wl_resource_get_client(surface->resource); 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"); -- cgit v1.2.3 From 93f79378f7801d3d7fce0125bf0b43b89252e2b8 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Fri, 29 Sep 2017 08:40:37 -0400 Subject: subsurface stacking requests --- include/wlr/types/wlr_surface.h | 4 ++ types/wlr_surface.c | 96 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 96 insertions(+), 4 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index c9abf042..b6d5f79f 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -48,8 +48,10 @@ struct wlr_subsurface { bool has_cache; bool synchronized; + bool reordered; struct wl_list parent_link; + struct wl_list parent_pending_link; }; struct wlr_surface { @@ -76,6 +78,8 @@ struct wlr_surface { 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; }; diff --git a/types/wlr_surface.c b/types/wlr_surface.c index fa4b4d5a..6f6df226 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -290,12 +290,44 @@ static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surfa 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; @@ -546,6 +578,7 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res, wl_signal_init(&surface->signals.commit); wl_signal_init(&surface->signals.destroy); 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; @@ -612,14 +645,69 @@ static void subsurface_set_position(struct wl_client *client, 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) { - wlr_log(L_DEBUG, "TODO: subsurface place above"); + 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) { - wlr_log(L_DEBUG, "TODO: subsurface place below"); + 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, -- cgit v1.2.3 From 19e30aab9bd7a0d572e065374d52a4cb0b160d5f Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Fri, 29 Sep 2017 08:58:17 -0400 Subject: subcompositor protocol errors --- include/wlr/types/wlr_surface.h | 5 +++++ types/wlr_compositor.c | 29 +++++++++++++++++++++++++---- types/wlr_surface.c | 11 +++++++++++ 3 files changed, 41 insertions(+), 4 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index b6d5f79f..38d6b453 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -114,4 +114,9 @@ int wlr_surface_set_role(struct wlr_surface *surface, const char *role, 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/types/wlr_compositor.c b/types/wlr_compositor.c index a142ddd4..12903cda 100644 --- a/types/wlr_compositor.c +++ b/types/wlr_compositor.c @@ -84,10 +84,31 @@ static void subcompositor_get_subsurface(struct wl_client *client, struct wlr_surface *surface = wl_resource_get_user_data(surface_resource); struct wlr_surface *parent = wl_resource_get_user_data(parent_resource); - // TODO: errors - // * cannot be its own parent - // * cannot already a subsurface - // * cannot be an ancestor of parent + 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) { diff --git a/types/wlr_surface.c b/types/wlr_surface.c index 6f6df226..8c084ceb 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -769,3 +769,14 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface, 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; +} -- cgit v1.2.3 From 4c1bd9bde8e56814ca9c73b138bd8c9dc0469062 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sat, 30 Sep 2017 12:33:39 -0400 Subject: input events for subsurfaces --- include/rootston/desktop.h | 3 ++- rootston/cursor.c | 17 ++++++++-------- rootston/desktop.c | 50 ++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 59 insertions(+), 11 deletions(-) (limited to 'include') 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/rootston/cursor.c b/rootston/cursor.c index 2742e7cd..8839e9d7 100644 --- a/rootston/cursor.c +++ b/rootston/cursor.c @@ -32,15 +32,14 @@ void view_begin_move(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); @@ -109,8 +108,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; @@ -128,7 +129,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 4d1cb199..3233f25a 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -41,14 +41,60 @@ void view_activate(struct roots_view *view, bool activate) { } } -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; } } -- cgit v1.2.3 From 8b7ae61ad4e8c991982cb15d46687ffbe6168530 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sat, 30 Sep 2017 13:24:59 -0400 Subject: subsurface handle parent destroy --- include/wlr/types/wlr_surface.h | 2 ++ types/wlr_surface.c | 29 ++++++++++++++++++++++++++--- 2 files changed, 28 insertions(+), 3 deletions(-) (limited to 'include') diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 38d6b453..ae278815 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -52,6 +52,8 @@ struct wlr_subsurface { struct wl_list parent_link; struct wl_list parent_pending_link; + + struct wl_listener parent_destroy_listener; }; struct wlr_surface { diff --git a/types/wlr_surface.c b/types/wlr_surface.c index 8c084ceb..e44ea9fc 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -537,7 +537,13 @@ static void wlr_surface_state_destroy(struct wlr_surface_state *state) { void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { wlr_surface_state_destroy(subsurface->cached); - wl_list_remove(&subsurface->parent_link); + + 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; @@ -742,6 +748,16 @@ static const struct wl_subsurface_interface subsurface_implementation = { .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); @@ -752,11 +768,18 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface, return; } subsurface->cached = wlr_surface_state_create(); - + subsurface->synchronized = true; subsurface->surface = surface; + + // link parent subsurface->parent = parent; - subsurface->synchronized = true; + 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); -- cgit v1.2.3