blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

subsurface commit and render

This commit is contained in:
Tony Crisci 2017-09-24 18:24:48 -04:00
parent 5cbb4f5ca0
commit 86bc4840a0
3 changed files with 322 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/wlr/types/wlr_surface.h
View File

@ -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;
};

422
types/wlr_surface.c
View File

@ -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,
&current->buffer_width, &current->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(&current->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,48 @@ static void wlr_surface_to_buffer_region(struct wlr_surface *surface,
free(dest_rects);
}
static void wlr_surface_commit_state(struct wlr_surface *surface,
struct wlr_surface_state *pending) {
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 *pending,
struct wlr_surface_state *current) {
bool update_damage = false;
bool update_size = false;
if ((pending->invalid & WLR_SURFACE_INVALID_SCALE)) {
surface->current.scale = pending->scale;
current->scale = pending->scale;
update_size = true;
}
if ((pending->invalid & WLR_SURFACE_INVALID_TRANSFORM)) {
surface->current.transform = pending->transform;
current->transform = pending->transform;
update_size = true;
}
if ((pending->invalid & WLR_SURFACE_INVALID_BUFFER)) {
surface->current.buffer = pending->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) {
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, current);
}
if ((pending->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) {
pixman_region32_union(&surface->current.surface_damage,
&surface->current.surface_damage,
pixman_region32_union(&current->surface_damage,
&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(&current->surface_damage,
&current->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(&surface->current.buffer_damage,
&surface->current.buffer_damage,
pixman_region32_union(&current->buffer_damage,
&current->buffer_damage,
&pending->buffer_damage);
pixman_region32_clear(&pending->buffer_damage);
@ -249,15 +256,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(current->scale, current->transform,
&current->surface_damage, &buffer_damage, current->width,
current->height);
pixman_region32_union(&current->buffer_damage,
&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(&current->buffer_damage,
&current->buffer_damage, 0, 0,
current->buffer_width, current->buffer_height);
}
if ((pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
// TODO: process buffer
@ -267,31 +275,195 @@ 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)) {
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(&current->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;
update_size = true;
}
if ((pending->invalid & WLR_SURFACE_INVALID_TRANSFORM)) {
surface->current->transform = pending->transform;
update_size = true;
}
if ((pending->invalid & WLR_SURFACE_INVALID_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, surface->current);
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,
&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_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,
&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(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);
}
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)) {
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, &current->frame_callback_list, link) {
wl_resource_destroy(cb->resource);
}
pixman_region32_fini(&current->surface_damage);
pixman_region32_fini(&current->buffer_damage);
pixman_region32_fini(&current->opaque);
pixman_region32_fini(&current->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);

8
types/wlr_xdg_shell_v6.c
View File

@ -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");