hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-12-24 02:49:48 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #160 from acrisci/feature/subcompositor

Browse source 
Subcompositor
This commit is contained in:
Drew DeVault 2017-09-30 14:31:57 -04:00 committed by GitHub
commit bfb6914cdf
8 changed files with 706 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
include/rootston/desktop.h
View file

@ -52,7 +52,8 @@ struct roots_desktop *desktop_create(struct roots_server *server,
void desktop_destroy(struct roots_desktop *desktop); void desktop_destroy(struct roots_desktop *desktop);
void view_destroy(struct roots_view *view); 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 view_activate(struct roots_view *view, bool activate);
void output_add_notify(struct wl_listener *listener, void *data); void output_add_notify(struct wl_listener *listener, void *data);

49
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_INPUT_REGION 16
#define WLR_SURFACE_INVALID_TRANSFORM 32 #define WLR_SURFACE_INVALID_TRANSFORM 32
#define WLR_SURFACE_INVALID_SCALE 64 #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 { struct wlr_surface_state {
uint32_t invalid; uint32_t invalid;
@ -29,13 +31,36 @@ struct wlr_surface_state {
int32_t scale; int32_t scale;
int width, height; int width, height;
int buffer_width, buffer_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 wlr_surface {
struct wl_resource *resource; struct wl_resource *resource;
struct wlr_renderer *renderer; struct wlr_renderer *renderer;
struct wlr_texture *texture; 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 const char *role; // the lifetime-bound role or null
float buffer_to_surface_matrix[16]; float buffer_to_surface_matrix[16];
@ -47,11 +72,16 @@ struct wlr_surface {
struct wl_signal destroy; struct wl_signal destroy;
} signals; } signals;
struct wl_list frame_callback_list; // wl_surface.frame // destroy listener used by compositor
struct wl_listener compositor_listener;
struct wl_listener compositor_listener; // destroy listener used by compositor
void *compositor_data; 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; 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, int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
struct wl_resource *error_resource, uint32_t error_code); 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 #endif

17
rootston/cursor.c
View file

@ -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) { void cursor_update_position(struct roots_input *input, uint32_t time) {
struct roots_desktop *desktop = input->server->desktop; struct roots_desktop *desktop = input->server->desktop;
struct roots_view *view; struct roots_view *view;
struct wlr_surface *surface;
double sx, sy;
switch (input->mode) { switch (input->mode) {
case ROOTS_CURSOR_PASSTHROUGH: 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) { if (view) {
struct wlr_box box; wlr_seat_pointer_enter(input->wl_seat, surface, sx, sy);
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_send_motion(input->wl_seat, time, sx, sy); wlr_seat_pointer_send_motion(input->wl_seat, time, sx, sy);
} else { } else {
wlr_seat_pointer_clear_focus(input->wl_seat); 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, struct wlr_cursor *cursor, struct wlr_input_device *device,
uint32_t time, uint32_t button, uint32_t state) { uint32_t time, uint32_t button, uint32_t state) {
struct roots_desktop *desktop = input->server->desktop; struct roots_desktop *desktop = input->server->desktop;
struct wlr_surface *surface;
double sx, sy;
struct roots_view *view = view_at(desktop, 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( uint32_t serial = wlr_seat_pointer_send_button(
input->wl_seat, time, button, state); input->wl_seat, time, button, state);
int i; 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])); % (sizeof(input->input_events) / sizeof(input->input_events[0]));
set_view_focus(input, desktop, view); set_view_focus(input, desktop, view);
if (view) { if (view) {
wlr_seat_keyboard_enter(input->wl_seat, view->wlr_surface); wlr_seat_keyboard_enter(input->wl_seat, surface);
} }
break; break;
} }

58
rootston/desktop.c
View file

@ -31,8 +31,8 @@ void view_get_size(struct roots_view *view, struct wlr_box *box) {
return; return;
} }
box->x = box->y = 0; box->x = box->y = 0;
box->width = view->wlr_surface->current.width; box->width = view->wlr_surface->current->width;
box->height = view->wlr_surface->current.height; box->height = view->wlr_surface->current->height;
} }
void view_get_input_bounds(struct roots_view *view, struct wlr_box *box) { 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; return;
} }
box->x = box->y = 0; box->x = box->y = 0;
box->width = view->wlr_surface->current.width; box->width = view->wlr_surface->current->width;
box->height = view->wlr_surface->current.height; box->height = view->wlr_surface->current->height;
} }
void view_activate(struct roots_view *view, bool activate) { 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) { for (size_t i = 0; i < desktop->views->length; ++i) {
struct roots_view *view = desktop->views->items[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; struct wlr_box box;
view_get_input_bounds(view, &box); view_get_input_bounds(view, &box);
box.x += view->x; box.x += view->x;
box.y += view->y; 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; return view;
} }
} }

46
rootston/output.c
View file

@ -16,14 +16,20 @@ static inline int64_t timespec_to_msec(const struct timespec *a) {
return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000; return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000;
} }
static void render_view(struct roots_desktop *desktop, static void render_surface(struct wlr_surface *surface,
struct wlr_output *wlr_output, struct timespec *when, struct roots_desktop *desktop, struct wlr_output *wlr_output,
struct roots_view *view, double ox, double oy) { struct timespec *when, double lx, double ly) {
struct wlr_surface *surface = view->wlr_surface;
float matrix[16];
float transform[16];
wlr_surface_flush_damage(surface); wlr_surface_flush_damage(surface);
if (surface->texture->valid) { if (surface->texture->valid) {
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);
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_matrix_translate(&transform, ox, oy, 0);
wlr_surface_get_matrix(surface, &matrix, wlr_surface_get_matrix(surface, &matrix,
&wlr_output->transform_matrix, &transform); &wlr_output->transform_matrix, &transform);
@ -31,11 +37,26 @@ static void render_view(struct roots_desktop *desktop,
surface->texture, &matrix); surface->texture, &matrix);
struct wlr_frame_callback *cb, *cnext; struct wlr_frame_callback *cb, *cnext;
wl_list_for_each_safe(cb, cnext, &surface->frame_callback_list, link) { wl_list_for_each_safe(cb, cnext,
&surface->current->frame_callback_list, link) {
wl_callback_send_done(cb->resource, timespec_to_msec(when)); wl_callback_send_done(cb->resource, timespec_to_msec(when));
wl_resource_destroy(cb->resource); 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) { static void output_frame_notify(struct wl_listener *listener, void *data) {
@ -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) { for (size_t i = 0; i < desktop->views->length; ++i) {
struct roots_view *view = desktop->views->items[i]; struct roots_view *view = desktop->views->items[i];
int width = view->wlr_surface->current.buffer_width; render_view(view, desktop, wlr_output, &now);
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);
}
} }
wlr_renderer_end(server->renderer); wlr_renderer_end(server->renderer);

99
types/wlr_compositor.c
View file

@ -19,9 +19,11 @@ static void wl_compositor_create_surface(struct wl_client *client,
compositor->renderer); compositor->renderer);
surface->compositor_data = compositor; surface->compositor_data = compositor;
surface->compositor_listener.notify = &destroy_surface_listener; 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); 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; struct wlr_compositor *compositor = _compositor;
assert(wl_client && compositor); assert(wl_client && compositor);
if (version > 4) { 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); wl_client_destroy(wl_client);
return; return;
} }
struct wl_resource *wl_resource = wl_resource_create( struct wl_resource *wl_resource =
wl_client, &wl_compositor_interface, version, id); wl_resource_create(wl_client, &wl_compositor_interface, version, id);
wl_resource_set_implementation(wl_resource, &wl_compositor_impl, wl_resource_set_implementation(wl_resource, &wl_compositor_impl,
compositor, wl_compositor_destroy); compositor, wl_compositor_destroy);
wl_list_insert(&compositor->wl_resources, wl_resource_get_link(wl_resource)); wl_list_insert(&compositor->wl_resources,
wl_resource_get_link(wl_resource));
} }
void wlr_compositor_destroy(struct wlr_compositor *compositor) { void wlr_compositor_destroy(struct wlr_compositor *compositor) {
@ -68,19 +72,96 @@ void wlr_compositor_destroy(struct wlr_compositor *compositor) {
free(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_compositor *wlr_compositor_create(struct wl_display *display,
struct wlr_renderer *renderer) { 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) { if (!compositor) {
wlr_log_errno(L_ERROR, "Could not allocate wlr compositor"); wlr_log_errno(L_ERROR, "Could not allocate wlr compositor");
return NULL; 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); &wl_compositor_interface, 4, compositor, wl_compositor_bind);
compositor->wl_global = wl_global;
compositor->wl_global = compositor_global;
compositor->renderer = renderer; compositor->renderer = renderer;
wl_global_create(display, &wl_subcompositor_interface, 1, compositor,
subcompositor_bind);
wl_list_init(&compositor->wl_resources); wl_list_init(&compositor->wl_resources);
wl_list_init(&compositor->surfaces); wl_list_init(&compositor->surfaces);
wl_signal_init(&compositor->events.create_surface); wl_signal_init(&compositor->events.create_surface);
return compositor; return compositor;
} }

572
types/wlr_surface.c
View file

@ -7,7 +7,8 @@
#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_surface.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
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); wl_resource_destroy(resource);
} }
@ -15,8 +16,9 @@ static void surface_attach(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *resource,
struct wl_resource *buffer, int32_t sx, int32_t sy) { struct wl_resource *buffer, int32_t sx, int32_t sy) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); 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, 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) { if (width < 0 || height < 0) {
return; return;
} }
surface->pending.invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE; surface->pending->invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE;
pixman_region32_union_rect(&surface->pending.surface_damage, pixman_region32_union_rect(&surface->pending->surface_damage,
&surface->pending.surface_damage, &surface->pending->surface_damage,
x, y, width, height); x, y, width, height);
} }
@ -60,22 +62,24 @@ static void surface_frame(struct wl_client *client,
wl_resource_set_implementation(cb->resource, wl_resource_set_implementation(cb->resource,
NULL, cb, destroy_frame_callback); 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, static void surface_set_opaque_region(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *resource,
struct wl_resource *region_resource) { struct wl_resource *region_resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); struct wlr_surface *surface = wl_resource_get_user_data(resource);
if ((surface->pending.invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) { if ((surface->pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
pixman_region32_clear(&surface->pending.opaque); 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) { if (region_resource) {
pixman_region32_t *region = wl_resource_get_user_data(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 { } 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 *resource,
struct wl_resource *region_resource) { struct wl_resource *region_resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); struct wlr_surface *surface = wl_resource_get_user_data(resource);
if ((surface->pending.invalid & WLR_SURFACE_INVALID_INPUT_REGION)) { if ((surface->pending->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) {
pixman_region32_clear(&surface->pending.input); 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) { if (region_resource) {
pixman_region32_t *region = wl_resource_get_user_data(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 { } else {
pixman_region32_init_rect(&surface->pending.input, pixman_region32_init_rect(&surface->pending->input,
INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX); INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
} }
} }
static void wlr_surface_update_size(struct wlr_surface *surface) { static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surface_state *state) {
int scale = surface->current.scale; int scale = state->scale;
enum wl_output_transform transform = surface->current.transform; enum wl_output_transform transform = state->transform;
wlr_texture_get_buffer_size(surface->texture, surface->current.buffer, wlr_texture_get_buffer_size(surface->texture, state->buffer,
&surface->current.buffer_width, &surface->current.buffer_height); &state->buffer_width, &state->buffer_height);
int _width = surface->current.buffer_width / scale; int _width = state->buffer_width / scale;
int _height = surface->current.buffer_height / scale; int _height = state->buffer_height / scale;
if (transform == WL_OUTPUT_TRANSFORM_90 || if (transform == WL_OUTPUT_TRANSFORM_90 ||
transform == WL_OUTPUT_TRANSFORM_270 || transform == WL_OUTPUT_TRANSFORM_270 ||
@ -115,17 +119,18 @@ static void wlr_surface_update_size(struct wlr_surface *surface) {
_height = tmp; _height = tmp;
} }
surface->current.width = _width; wl_list_init(&state->frame_callback_list);
surface->current.height = _height;
state->width = _width;
state->height = _height;
} }
static void wlr_surface_to_buffer_region(struct wlr_surface *surface, static void wlr_surface_to_buffer_region(int scale,
pixman_region32_t *surface_region, pixman_region32_t *buffer_region, enum wl_output_transform transform, pixman_region32_t *surface_region,
pixman_region32_t *buffer_region,
int width, int height) { int width, int height) {
pixman_box32_t *src_rects, *dest_rects; pixman_box32_t *src_rects, *dest_rects;
int nrects, i; int nrects, i;
int scale = surface->current.scale;
enum wl_output_transform transform = surface->current.transform;
src_rects = pixman_region32_rectangles(surface_region, &nrects); src_rects = pixman_region32_rectangles(surface_region, &nrects);
dest_rects = malloc(nrects * sizeof(*dest_rects)); 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); free(dest_rects);
} }
static void surface_commit(struct wl_client *client, /**
struct wl_resource *resource) { * Append pending state to current state and clear pending state.
struct wlr_surface *surface = wl_resource_get_user_data(resource); */
bool update_size = false; 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_damage = false;
bool update_size = false;
if ((surface->pending.invalid & WLR_SURFACE_INVALID_SCALE)) { if ((next->invalid & WLR_SURFACE_INVALID_SCALE)) {
surface->current.scale = surface->pending.scale; state->scale = next->scale;
update_size = true; update_size = true;
} }
if ((surface->pending.invalid & WLR_SURFACE_INVALID_TRANSFORM)) { if ((next->invalid & WLR_SURFACE_INVALID_TRANSFORM)) {
surface->current.transform = surface->pending.transform; state->transform = next->transform;
update_size = true; update_size = true;
} }
if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER)) { if ((next->invalid & WLR_SURFACE_INVALID_BUFFER)) {
surface->current.buffer = surface->pending.buffer; if (state->buffer) {
wl_resource_post_event(state->buffer, WL_BUFFER_RELEASE);
}
state->buffer = next->buffer;
next->buffer = NULL;
update_size = true; update_size = true;
} }
if (update_size) { if (update_size) {
int32_t oldw = surface->current.buffer_width; wlr_surface_update_size(surface, state);
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;
} }
if ((surface->pending.invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) { if ((next->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) {
pixman_region32_union(&surface->current.surface_damage, pixman_region32_union(&state->surface_damage,
&surface->current.surface_damage, &state->surface_damage,
&surface->pending.surface_damage); &next->surface_damage);
pixman_region32_intersect_rect(&surface->current.surface_damage, pixman_region32_intersect_rect(&state->surface_damage,
&surface->current.surface_damage, 0, 0, surface->current.width, &state->surface_damage, 0, 0, state->width,
surface->current.height); state->height);
pixman_region32_clear(&surface->pending.surface_damage); pixman_region32_clear(&next->surface_damage);
update_damage = true; update_damage = true;
} }
if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) { if ((next->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) {
pixman_region32_union(&surface->current.buffer_damage, pixman_region32_union(&state->buffer_damage,
&surface->current.buffer_damage, &state->buffer_damage,
&surface->pending.buffer_damage); &next->buffer_damage);
pixman_region32_clear(&surface->pending.buffer_damage); pixman_region32_clear(&next->buffer_damage);
update_damage = true; update_damage = true;
} }
if (update_damage) { if (update_damage) {
pixman_region32_t buffer_damage; pixman_region32_t buffer_damage;
pixman_region32_init(&buffer_damage); pixman_region32_init(&buffer_damage);
wlr_surface_to_buffer_region(surface, &surface->current.surface_damage, wlr_surface_to_buffer_region(state->scale, state->transform,
&buffer_damage, surface->current.width, surface->current.height); &state->surface_damage, &buffer_damage, state->width,
pixman_region32_union(&surface->current.buffer_damage, state->height);
&surface->current.buffer_damage, &buffer_damage); pixman_region32_union(&state->buffer_damage,
&state->buffer_damage, &buffer_damage);
pixman_region32_fini(&buffer_damage); pixman_region32_fini(&buffer_damage);
pixman_region32_intersect_rect(&surface->current.buffer_damage, pixman_region32_intersect_rect(&state->buffer_damage,
&surface->current.buffer_damage, 0, 0, &state->buffer_damage, 0, 0,
surface->current.buffer_width, surface->current.buffer_height); 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 // 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 // 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 // TODO: add the invalid bitfield to this callback
wl_signal_emit(&surface->signals.commit, surface); 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) { void wlr_surface_flush_damage(struct wlr_surface *surface) {
if (!surface->current.buffer) { if (!surface->current->buffer) {
if (surface->texture->valid) { if (surface->texture->valid) {
// TODO: Detach buffers // TODO: Detach buffers
} }
return; 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 (!buffer) {
if (wlr_renderer_buffer_is_drm(surface->renderer, surface->pending.buffer)) { if (wlr_renderer_buffer_is_drm(surface->renderer,
wlr_texture_upload_drm(surface->texture, surface->pending.buffer); surface->current->buffer)) {
wlr_texture_upload_drm(surface->texture, surface->current->buffer);
goto release; goto release;
} else { } else {
wlr_log(L_INFO, "Unknown buffer handle attached"); 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) { if (surface->reupload_buffer) {
wlr_texture_upload_shm(surface->texture, format, buffer); wlr_texture_upload_shm(surface->texture, format, buffer);
} else { } else {
pixman_region32_t damage = surface->current.buffer_damage; pixman_region32_t damage = surface->current->buffer_damage;
if (!pixman_region32_not_empty(&damage)) { if (!pixman_region32_not_empty(&damage)) {
goto release; goto release;
} }
@ -314,26 +457,26 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) {
} }
release: release:
pixman_region32_clear(&surface->current.surface_damage); pixman_region32_clear(&surface->current->surface_damage);
pixman_region32_clear(&surface->current.buffer_damage); pixman_region32_clear(&surface->current->buffer_damage);
wl_resource_post_event(surface->current.buffer, WL_BUFFER_RELEASE); wl_resource_post_event(surface->current->buffer, WL_BUFFER_RELEASE);
surface->current.buffer = NULL; surface->current->buffer = NULL;
} }
static void surface_set_buffer_transform(struct wl_client *client, static void surface_set_buffer_transform(struct wl_client *client,
struct wl_resource *resource, int transform) { struct wl_resource *resource, int transform) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); struct wlr_surface *surface = wl_resource_get_user_data(resource);
surface->pending.invalid |= WLR_SURFACE_INVALID_TRANSFORM; surface->pending->invalid |= WLR_SURFACE_INVALID_TRANSFORM;
surface->pending.transform = transform; surface->pending->transform = transform;
} }
static void surface_set_buffer_scale(struct wl_client *client, static void surface_set_buffer_scale(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *resource,
int32_t scale) { int32_t scale) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); struct wlr_surface *surface = wl_resource_get_user_data(resource);
surface->pending.invalid |= WLR_SURFACE_INVALID_SCALE; surface->pending->invalid |= WLR_SURFACE_INVALID_SCALE;
surface->pending.scale = scale; surface->pending->scale = scale;
} }
static void surface_damage_buffer(struct wl_client *client, 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) { if (width < 0 || height < 0) {
return; return;
} }
surface->pending.invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE; surface->pending->invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE;
pixman_region32_union_rect(&surface->pending.buffer_damage, pixman_region32_union_rect(&surface->pending->buffer_damage,
&surface->pending.buffer_damage, &surface->pending->buffer_damage,
x, y, width, height); x, y, width, height);
} }
@ -363,19 +506,62 @@ const struct wl_surface_interface surface_interface = {
.damage_buffer = surface_damage_buffer .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) { static void destroy_surface(struct wl_resource *resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource); struct wlr_surface *surface = wl_resource_get_user_data(resource);
wl_signal_emit(&surface->signals.destroy, surface); wl_signal_emit(&surface->signals.destroy, surface);
wlr_texture_destroy(surface->texture); if (surface->subsurface) {
struct wlr_frame_callback *cb, *next; wlr_subsurface_destroy(surface->subsurface);
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); wlr_texture_destroy(surface->texture);
pixman_region32_fini(&surface->pending.opaque); wlr_surface_state_destroy(surface->pending);
pixman_region32_fini(&surface->pending.input); wlr_surface_state_destroy(surface->current);
free(surface); free(surface);
} }
@ -391,17 +577,14 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
surface->renderer = renderer; surface->renderer = renderer;
surface->texture = wlr_render_texture_create(renderer); surface->texture = wlr_render_texture_create(renderer);
surface->resource = res; surface->resource = res;
surface->current.scale = 1;
surface->pending.scale = 1; surface->current = wlr_surface_state_create();
surface->current.transform = WL_OUTPUT_TRANSFORM_NORMAL; surface->pending = wlr_surface_state_create();
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);
wl_signal_init(&surface->signals.commit); wl_signal_init(&surface->signals.commit);
wl_signal_init(&surface->signals.destroy); 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, wl_resource_set_implementation(res, &surface_interface,
surface, destroy_surface); surface, destroy_surface);
return surface; return surface;
@ -411,8 +594,8 @@ void wlr_surface_get_matrix(struct wlr_surface *surface,
float (*matrix)[16], float (*matrix)[16],
const float (*projection)[16], const float (*projection)[16],
const float (*transform)[16]) { const float (*transform)[16]) {
int width = surface->texture->width / surface->current.scale; int width = surface->texture->width / surface->current->scale;
int height = surface->texture->height / surface->current.scale; int height = surface->texture->height / surface->current->scale;
float scale[16]; float scale[16];
wlr_matrix_identity(matrix); wlr_matrix_identity(matrix);
if (transform) { if (transform) {
@ -443,3 +626,180 @@ int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
return -1; 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;
}

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) { struct wlr_xdg_surface_v6 *surface) {
assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); 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 // on the first commit, send a configure request to tell the client it
// is added // is added
wlr_xdg_surface_v6_schedule_configure(surface, true); wlr_xdg_surface_v6_schedule_configure(surface, true);
@ -504,7 +504,7 @@ static void wlr_xdg_surface_v6_toplevel_committed(
return; return;
} }
if (!surface->surface->current.buffer) { if (!surface->surface->current->buffer) {
return; return;
} }
@ -516,7 +516,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener,
struct wlr_xdg_surface_v6 *surface = struct wlr_xdg_surface_v6 *surface =
wl_container_of(listener, surface, surface_commit_listener); 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, wl_resource_post_error(surface->resource,
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER, ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
"xdg_surface has never been configured"); "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), &zxdg_surface_v6_interface, wl_resource_get_version(client_resource),
id); id);
if (surface->surface->current.buffer != NULL) { if (surface->surface->current->buffer != NULL) {
wl_resource_post_error(surface->resource, wl_resource_post_error(surface->resource,
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER, ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
"xdg_surface must not have a buffer at creation"); "xdg_surface must not have a buffer at creation");