From 4f3cad78285fca473b4a108aa5276fc08addee56 Mon Sep 17 00:00:00 2001 From: Emilio Pozuelo Monfort Date: Fri, 27 Jan 2017 17:30:29 +0100 Subject: [PATCH] compositor: damage pending subsurfaces when committing them When a client changes the subsurfaces state, we need to damage them so the result is visible. We do that by flagging the surfaces when the state changes and causing damage when committing the state. This prevents normal repaints from considering these changes until a commit has happened, and allows the client to atomically schedule several changes. This fixes the subsurface_z_order test, which is now marked as expected to succeed. Signed-off-by: Emilio Pozuelo Monfort Reviewed-by: Pekka Paalanen Reviewed-by: Micah Fedke --- libweston/compositor.c | 31 +++++++++++++++++++++++++++++++ libweston/compositor.h | 3 +++ tests/subsurface-shot-test.c | 2 +- 3 files changed, 35 insertions(+), 1 deletion(-) diff --git a/libweston/compositor.c b/libweston/compositor.c index 8d6175e1..9ded23f3 100644 --- a/libweston/compositor.c +++ b/libweston/compositor.c @@ -2179,6 +2179,12 @@ view_list_add_subsurface_view(struct weston_compositor *compositor, } } +/* This recursively adds the sub-surfaces for a view, relying on the + * sub-surface order. Thus, if a client restacks the sub-surfaces, that + * change first happens to the sub-surface list, and then automatically + * propagates here. See weston_surface_damage_subsurfaces() for how the + * sub-surfaces receive damage when the client changes the state. + */ static void view_list_add(struct weston_compositor *compositor, struct weston_view *view) @@ -2682,6 +2688,24 @@ surface_set_input_region(struct wl_client *client, } } +/* Cause damage to this sub-surface and all its children. + * + * This is useful when there are state changes that need an implicit + * damage, e.g. a z-order change. + */ +static void +weston_surface_damage_subsurfaces(struct weston_subsurface *sub) +{ + struct weston_subsurface *child; + + weston_surface_damage(sub->surface); + sub->reordered = false; + + wl_list_for_each(child, &sub->surface->subsurface_list, parent_link) + if (child != sub) + weston_surface_damage_subsurfaces(child); +} + static void weston_surface_commit_subsurface_order(struct weston_surface *surface) { @@ -2691,6 +2715,9 @@ weston_surface_commit_subsurface_order(struct weston_surface *surface) parent_link_pending) { wl_list_remove(&sub->parent_link); wl_list_insert(&surface->subsurface_list, &sub->parent_link); + + if (sub->reordered) + weston_surface_damage_subsurfaces(sub); } } @@ -3640,6 +3667,8 @@ subsurface_place_above(struct wl_client *client, wl_list_remove(&sub->parent_link_pending); wl_list_insert(sibling->parent_link_pending.prev, &sub->parent_link_pending); + + sub->reordered = true; } static void @@ -3662,6 +3691,8 @@ subsurface_place_below(struct wl_client *client, wl_list_remove(&sub->parent_link_pending); wl_list_insert(&sibling->parent_link_pending, &sub->parent_link_pending); + + sub->reordered = true; } static void diff --git a/libweston/compositor.h b/libweston/compositor.h index b049c980..08e728a9 100644 --- a/libweston/compositor.h +++ b/libweston/compositor.h @@ -1235,6 +1235,9 @@ struct weston_subsurface { struct weston_surface_state cached; struct weston_buffer_reference cached_buffer_ref; + /* Sub-surface has been reordered; need to apply damage. */ + bool reordered; + int synchronized; /* Used for constructing the view tree */ diff --git a/tests/subsurface-shot-test.c b/tests/subsurface-shot-test.c index 8e4f7c19..10415ec7 100644 --- a/tests/subsurface-shot-test.c +++ b/tests/subsurface-shot-test.c @@ -174,7 +174,7 @@ surface_commit_color(struct client *client, struct wl_surface *surface, return buf; } -FAIL_TEST(subsurface_z_order) +TEST(subsurface_z_order) { const char *test_name = get_test_name(); struct client *client;