hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-22 12:55:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

surface: make pending and current embedded structs

Browse source
This commit is contained in:
emersion 2018-06-21 22:39:26 +01:00
parent 64836ddfe7
commit 3c0d672ebd
No known key found for this signature in database
GPG key ID: 0FDE7BE0E88F5E48
11 changed files with 127 additions and 134 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
include/wlr/types/wlr_surface.h
View file

@ -23,7 +23,6 @@ struct wlr_surface_state {
uint32_t committed; // enum wlr_surface_state_field uint32_t committed; // enum wlr_surface_state_field
struct wl_resource *buffer; struct wl_resource *buffer;
struct wl_listener buffer_destroy_listener;
int32_t sx, sy; int32_t sx, sy;
pixman_region32_t surface_damage, buffer_damage; pixman_region32_t surface_damage, buffer_damage;
pixman_region32_t opaque, input; pixman_region32_t opaque, input;
@ -33,6 +32,8 @@ struct wlr_surface_state {
int width, height; // in surface-local coordinates int width, height; // in surface-local coordinates
int buffer_width, buffer_height; int buffer_width, buffer_height;
struct wl_listener buffer_destroy_listener;
}; };
struct wlr_surface { struct wlr_surface {
@ -45,7 +46,12 @@ struct wlr_surface {
* or something went wrong with uploading the buffer. * or something went wrong with uploading the buffer.
*/ */
struct wlr_buffer *buffer; struct wlr_buffer *buffer;
struct wlr_surface_state *current, *pending; /**
* `current` contains the current, committed surface state. `pending`
* accumulates state changes from the client between commits and shouldn't
* be accessed by the compositor directly.
*/
struct wlr_surface_state current, pending;
const char *role; // the lifetime-bound role or null const char *role; // the lifetime-bound role or null
struct { struct {
@ -79,7 +85,7 @@ struct wlr_subsurface {
struct wlr_subsurface_state current, pending; struct wlr_subsurface_state current, pending;
struct wlr_surface_state *cached; struct wlr_surface_state cached;
bool has_cache; bool has_cache;
bool synchronized; bool synchronized;

8
rootston/cursor.c
View file

@ -200,8 +200,8 @@ static void roots_cursor_update_position(
case ROOTS_CURSOR_ROTATE: case ROOTS_CURSOR_ROTATE:
view = roots_seat_get_focus(seat); view = roots_seat_get_focus(seat);
if (view != NULL) { if (view != NULL) {
int ox = view->x + view->wlr_surface->current->width/2, int ox = view->x + view->wlr_surface->current.width/2,
oy = view->y + view->wlr_surface->current->height/2; oy = view->y + view->wlr_surface->current.height/2;
int ux = cursor->offs_x - ox, int ux = cursor->offs_x - ox,
uy = cursor->offs_y - oy; uy = cursor->offs_y - oy;
int vx = cursor->cursor->x - ox, int vx = cursor->cursor->x - ox,
@ -239,12 +239,12 @@ static void roots_cursor_press_button(struct roots_cursor *cursor,
break; break;
case BTN_RIGHT: case BTN_RIGHT:
edges = 0; edges = 0;
if (sx < view->wlr_surface->current->width/2) { if (sx < view->wlr_surface->current.width/2) {
edges |= WLR_EDGE_LEFT; edges |= WLR_EDGE_LEFT;
} else { } else {
edges |= WLR_EDGE_RIGHT; edges |= WLR_EDGE_RIGHT;
} }
if (sy < view->wlr_surface->current->height/2) { if (sy < view->wlr_surface->current.height/2) {
edges |= WLR_EDGE_TOP; edges |= WLR_EDGE_TOP;
} else { } else {
edges |= WLR_EDGE_BOTTOM; edges |= WLR_EDGE_BOTTOM;

6
rootston/desktop.c
View file

@ -69,8 +69,8 @@ enum roots_deco_part view_get_deco_part(struct roots_view *view, double sx,
return ROOTS_DECO_PART_NONE; return ROOTS_DECO_PART_NONE;
} }
int sw = view->wlr_surface->current->width; int sw = view->wlr_surface->current.width;
int sh = view->wlr_surface->current->height; int sh = view->wlr_surface->current.height;
int bw = view->border_width; int bw = view->border_width;
int titlebar_h = view->titlebar_height; int titlebar_h = view->titlebar_height;
@ -558,7 +558,7 @@ static bool view_at(struct roots_view *view, double lx, double ly,
double view_sx = lx - view->x; double view_sx = lx - view->x;
double view_sy = ly - view->y; double view_sy = ly - view->y;
struct wlr_surface_state *state = view->wlr_surface->current; struct wlr_surface_state *state = &view->wlr_surface->current;
struct wlr_box box = { struct wlr_box box = {
.x = 0, .y = 0, .x = 0, .y = 0,
.width = state->width, .height = state->height, .width = state->width, .height = state->height,

30
rootston/output.c
View file

@ -44,8 +44,8 @@ struct layout_data {
static void get_layout_position(struct layout_data *data, double *lx, double *ly, static void get_layout_position(struct layout_data *data, double *lx, double *ly,
const struct wlr_surface *surface, int sx, int sy) { const struct wlr_surface *surface, int sx, int sy) {
double _sx = sx, _sy = sy; double _sx = sx, _sy = sy;
rotate_child_position(&_sx, &_sy, surface->current->width, rotate_child_position(&_sx, &_sy, surface->current.width,
surface->current->height, data->width, data->height, data->rotation); surface->current.height, data->width, data->height, data->rotation);
*lx = data->x + _sx; *lx = data->x + _sx;
*ly = data->y + _sy; *ly = data->y + _sy;
} }
@ -55,8 +55,8 @@ static void surface_for_each_surface(struct wlr_surface *surface,
wlr_surface_iterator_func_t iterator, void *user_data) { wlr_surface_iterator_func_t iterator, void *user_data) {
layout_data->x = lx; layout_data->x = lx;
layout_data->y = ly; layout_data->y = ly;
layout_data->width = surface->current->width; layout_data->width = surface->current.width;
layout_data->height = surface->current->height; layout_data->height = surface->current.height;
layout_data->rotation = rotation; layout_data->rotation = rotation;
wlr_surface_for_each_surface(surface, iterator, user_data); wlr_surface_for_each_surface(surface, iterator, user_data);
@ -67,8 +67,8 @@ static void view_for_each_surface(struct roots_view *view,
void *user_data) { void *user_data) {
layout_data->x = view->x; layout_data->x = view->x;
layout_data->y = view->y; layout_data->y = view->y;
layout_data->width = view->wlr_surface->current->width; layout_data->width = view->wlr_surface->current.width;
layout_data->height = view->wlr_surface->current->height; layout_data->height = view->wlr_surface->current.height;
layout_data->rotation = view->rotation; layout_data->rotation = view->rotation;
switch (view->type) { switch (view->type) {
@ -149,13 +149,13 @@ static bool surface_intersect_output(struct wlr_surface *surface,
if (box != NULL) { if (box != NULL) {
box->x = ox * wlr_output->scale; box->x = ox * wlr_output->scale;
box->y = oy * wlr_output->scale; box->y = oy * wlr_output->scale;
box->width = surface->current->width * wlr_output->scale; box->width = surface->current.width * wlr_output->scale;
box->height = surface->current->height * wlr_output->scale; box->height = surface->current.height * wlr_output->scale;
} }
struct wlr_box layout_box = { struct wlr_box layout_box = {
.x = lx, .y = ly, .x = lx, .y = ly,
.width = surface->current->width, .height = surface->current->height, .width = surface->current.width, .height = surface->current.height,
}; };
wlr_box_rotated_bounds(&layout_box, rotation, &layout_box); wlr_box_rotated_bounds(&layout_box, rotation, &layout_box);
return wlr_output_layout_intersects(output_layout, wlr_output, &layout_box); return wlr_output_layout_intersects(output_layout, wlr_output, &layout_box);
@ -223,7 +223,7 @@ static void render_surface(struct wlr_surface *surface, int sx, int sy,
float matrix[9]; float matrix[9];
enum wl_output_transform transform = enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform); wlr_output_transform_invert(surface->current.transform);
wlr_matrix_project_box(matrix, &box, transform, rotation, wlr_matrix_project_box(matrix, &box, transform, rotation,
output->wlr_output->transform_matrix); output->wlr_output->transform_matrix);
@ -247,8 +247,8 @@ static void get_decoration_box(struct roots_view *view,
double sx = deco_box.x - view->x; double sx = deco_box.x - view->x;
double sy = deco_box.y - view->y; double sy = deco_box.y - view->y;
rotate_child_position(&sx, &sy, deco_box.width, deco_box.height, rotate_child_position(&sx, &sy, deco_box.width, deco_box.height,
view->wlr_surface->current->width, view->wlr_surface->current.width,
view->wlr_surface->current->height, view->rotation); view->wlr_surface->current.height, view->rotation);
double x = sx + view->x; double x = sx + view->x;
double y = sy + view->y; double y = sy + view->y;
@ -694,13 +694,13 @@ static void damage_from_surface(struct wlr_surface *surface, int sx, int sy,
pixman_region32_t damage; pixman_region32_t damage;
pixman_region32_init(&damage); pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->surface_damage); pixman_region32_copy(&damage, &surface->current.surface_damage);
wlr_region_scale(&damage, &damage, wlr_output->scale); wlr_region_scale(&damage, &damage, wlr_output->scale);
if (ceil(wlr_output->scale) > surface->current->scale) { if (ceil(wlr_output->scale) > surface->current.scale) {
// When scaling up a surface, it'll become blurry so we need to // When scaling up a surface, it'll become blurry so we need to
// expand the damage region // expand the damage region
wlr_region_expand(&damage, &damage, wlr_region_expand(&damage, &damage,
ceil(wlr_output->scale) - surface->current->scale); ceil(wlr_output->scale) - surface->current.scale);
} }
pixman_region32_translate(&damage, box.x, box.y); pixman_region32_translate(&damage, box.x, box.y);
wlr_region_rotated_bounds(&damage, &damage, rotation, center_x, center_y); wlr_region_rotated_bounds(&damage, &damage, rotation, center_x, center_y);

8
rootston/wl_shell.c
View file

@ -158,8 +158,8 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
view_apply_damage(view); view_apply_damage(view);
int width = wlr_surface->current->width; int width = wlr_surface->current.width;
int height = wlr_surface->current->height; int height = wlr_surface->current.height;
view_update_size(view, width, height); view_update_size(view, width, height);
double x = view->x; double x = view->x;
@ -236,8 +236,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
return; return;
} }
view->type = ROOTS_WL_SHELL_VIEW; view->type = ROOTS_WL_SHELL_VIEW;
view->width = surface->surface->current->width; view->width = surface->surface->current.width;
view->height = surface->surface->current->height; view->height = surface->surface->current.height;
view->wl_shell_surface = surface; view->wl_shell_surface = surface;
view->roots_wl_shell_surface = roots_surface; view->roots_wl_shell_surface = roots_surface;

8
rootston/xwayland.c
View file

@ -206,8 +206,8 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
view_apply_damage(view); view_apply_damage(view);
int width = wlr_surface->current->width; int width = wlr_surface->current.width;
int height = wlr_surface->current->height; int height = wlr_surface->current.height;
view_update_size(view, width, height); view_update_size(view, width, height);
double x = view->x; double x = view->x;
@ -233,8 +233,8 @@ static void handle_map(struct wl_listener *listener, void *data) {
view->x = surface->x; view->x = surface->x;
view->y = surface->y; view->y = surface->y;
view->width = surface->surface->current->width; view->width = surface->surface->current.width;
view->height = surface->surface->current->height; view->height = surface->surface->current.height;
roots_surface->surface_commit.notify = handle_surface_commit; roots_surface->surface_commit.notify = handle_surface_commit;
wl_signal_add(&surface->surface->events.commit, wl_signal_add(&surface->surface->events.commit,

4
types/data_device/wlr_drag.c
View file

@ -341,8 +341,8 @@ static void drag_icon_handle_surface_destroy(struct wl_listener *listener,
static void drag_icon_handle_surface_commit(struct wlr_surface *surface, static void drag_icon_handle_surface_commit(struct wlr_surface *surface,
void *role_data) { void *role_data) {
struct wlr_drag_icon *icon = role_data; struct wlr_drag_icon *icon = role_data;
icon->sx += icon->surface->current->sx; icon->sx += icon->surface->current.sx;
icon->sy += icon->surface->current->sy; icon->sy += icon->surface->current.sy;
drag_icon_set_mapped(icon, wlr_surface_has_buffer(surface)); drag_icon_set_mapped(icon, wlr_surface_has_buffer(surface));
} }

32
types/wlr_output.c
View file

@ -352,13 +352,13 @@ static void output_fullscreen_surface_get_box(struct wlr_output *output,
int width, height; int width, height;
wlr_output_effective_resolution(output, &width, &height); wlr_output_effective_resolution(output, &width, &height);
int x = (width - surface->current->width) / 2; int x = (width - surface->current.width) / 2;
int y = (height - surface->current->height) / 2; int y = (height - surface->current.height) / 2;
box->x = x * output->scale; box->x = x * output->scale;
box->y = y * output->scale; box->y = y * output->scale;
box->width = surface->current->width * output->scale; box->width = surface->current.width * output->scale;
box->height = surface->current->height * output->scale; box->height = surface->current.height * output->scale;
} }
static void output_fullscreen_surface_render(struct wlr_output *output, static void output_fullscreen_surface_render(struct wlr_output *output,
@ -378,7 +378,7 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
float matrix[9]; float matrix[9];
enum wl_output_transform transform = enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform); wlr_output_transform_invert(surface->current.transform);
wlr_matrix_project_box(matrix, &box, transform, 0, wlr_matrix_project_box(matrix, &box, transform, 0,
output->transform_matrix); output->transform_matrix);
@ -405,8 +405,8 @@ static void output_cursor_get_box(struct wlr_output_cursor *cursor,
box->height = cursor->height; box->height = cursor->height;
if (cursor->surface != NULL) { if (cursor->surface != NULL) {
box->x += cursor->surface->current->sx * cursor->output->scale; box->x += cursor->surface->current.sx * cursor->output->scale;
box->y += cursor->surface->current->sy * cursor->output->scale; box->y += cursor->surface->current.sy * cursor->output->scale;
} }
} }
@ -602,10 +602,10 @@ static void output_fullscreen_surface_handle_commit(
fullscreen_surface_commit); fullscreen_surface_commit);
struct wlr_surface *surface = output->fullscreen_surface; struct wlr_surface *surface = output->fullscreen_surface;
if (output->fullscreen_width != surface->current->width || if (output->fullscreen_width != surface->current.width ||
output->fullscreen_height != surface->current->height) { output->fullscreen_height != surface->current.height) {
output->fullscreen_width = surface->current->width; output->fullscreen_width = surface->current.width;
output->fullscreen_height = surface->current->height; output->fullscreen_height = surface->current.height;
wlr_output_damage_whole(output); wlr_output_damage_whole(output);
return; return;
} }
@ -615,7 +615,7 @@ static void output_fullscreen_surface_handle_commit(
pixman_region32_t damage; pixman_region32_t damage;
pixman_region32_init(&damage); pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->surface_damage); pixman_region32_copy(&damage, &surface->current.surface_damage);
wlr_region_scale(&damage, &damage, output->scale); wlr_region_scale(&damage, &damage, output->scale);
pixman_region32_translate(&damage, box.x, box.y); pixman_region32_translate(&damage, box.x, box.y);
pixman_region32_union(&output->damage, &output->damage, &damage); pixman_region32_union(&output->damage, &output->damage, &damage);
@ -714,8 +714,8 @@ static bool output_cursor_attempt_hardware(struct wlr_output_cursor *cursor) {
struct wlr_texture *texture = cursor->texture; struct wlr_texture *texture = cursor->texture;
if (cursor->surface != NULL) { if (cursor->surface != NULL) {
texture = wlr_surface_get_texture(cursor->surface); texture = wlr_surface_get_texture(cursor->surface);
scale = cursor->surface->current->scale; scale = cursor->surface->current.scale;
transform = cursor->surface->current->transform; transform = cursor->surface->current.transform;
} }
struct wlr_output_cursor *hwcur = cursor->output->hardware_cursor; struct wlr_output_cursor *hwcur = cursor->output->hardware_cursor;
@ -778,8 +778,8 @@ static void output_cursor_commit(struct wlr_output_cursor *cursor) {
// Some clients commit a cursor surface with a NULL buffer to hide it. // Some clients commit a cursor surface with a NULL buffer to hide it.
cursor->enabled = wlr_surface_has_buffer(cursor->surface); cursor->enabled = wlr_surface_has_buffer(cursor->surface);
cursor->width = cursor->surface->current->width * cursor->output->scale; cursor->width = cursor->surface->current.width * cursor->output->scale;
cursor->height = cursor->surface->current->height * cursor->output->scale; cursor->height = cursor->surface->current.height * cursor->output->scale;
if (output_cursor_attempt_hardware(cursor)) { if (output_cursor_attempt_hardware(cursor)) {
struct timespec now; struct timespec now;

145
types/wlr_surface.c
View file

@ -67,10 +67,10 @@ static void surface_attach(struct wl_client *client,
struct wl_resource *buffer, int32_t sx, int32_t sy) { struct wl_resource *buffer, int32_t sx, int32_t sy) {
struct wlr_surface *surface = wlr_surface_from_resource(resource); struct wlr_surface *surface = wlr_surface_from_resource(resource);
surface->pending->committed |= WLR_SURFACE_STATE_BUFFER; surface->pending.committed |= WLR_SURFACE_STATE_BUFFER;
surface->pending->sx = sx; surface->pending.sx = sx;
surface->pending->sy = sy; surface->pending.sy = sy;
surface_state_set_buffer(surface->pending, buffer); surface_state_set_buffer(&surface->pending, buffer);
} }
static void surface_damage(struct wl_client *client, static void surface_damage(struct wl_client *client,
@ -80,9 +80,9 @@ static void surface_damage(struct wl_client *client,
if (width < 0 || height < 0) { if (width < 0 || height < 0) {
return; return;
} }
surface->pending->committed |= WLR_SURFACE_STATE_SURFACE_DAMAGE; surface->pending.committed |= WLR_SURFACE_STATE_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);
} }
@ -103,38 +103,38 @@ static void surface_frame(struct wl_client *client,
wl_resource_set_implementation(callback_resource, NULL, NULL, wl_resource_set_implementation(callback_resource, NULL, NULL,
callback_handle_resource_destroy); callback_handle_resource_destroy);
wl_list_insert(surface->pending->frame_callback_list.prev, wl_list_insert(surface->pending.frame_callback_list.prev,
wl_resource_get_link(callback_resource)); wl_resource_get_link(callback_resource));
surface->pending->committed |= WLR_SURFACE_STATE_FRAME_CALLBACK_LIST; surface->pending.committed |= WLR_SURFACE_STATE_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 = wlr_surface_from_resource(resource); struct wlr_surface *surface = wlr_surface_from_resource(resource);
if ((surface->pending->committed & WLR_SURFACE_STATE_OPAQUE_REGION)) { if ((surface->pending.committed & WLR_SURFACE_STATE_OPAQUE_REGION)) {
pixman_region32_clear(&surface->pending->opaque); pixman_region32_clear(&surface->pending.opaque);
} }
surface->pending->committed |= WLR_SURFACE_STATE_OPAQUE_REGION; surface->pending.committed |= WLR_SURFACE_STATE_OPAQUE_REGION;
if (region_resource) { if (region_resource) {
pixman_region32_t *region = wlr_region_from_resource(region_resource); pixman_region32_t *region = wlr_region_from_resource(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);
} }
} }
static void surface_set_input_region(struct wl_client *client, static void surface_set_input_region(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *region_resource) { struct wl_resource *resource, struct wl_resource *region_resource) {
struct wlr_surface *surface = wlr_surface_from_resource(resource); struct wlr_surface *surface = wlr_surface_from_resource(resource);
surface->pending->committed |= WLR_SURFACE_STATE_INPUT_REGION; surface->pending.committed |= WLR_SURFACE_STATE_INPUT_REGION;
if (region_resource) { if (region_resource) {
pixman_region32_t *region = wlr_region_from_resource(region_resource); pixman_region32_t *region = wlr_region_from_resource(region_resource);
pixman_region32_copy(&surface->pending->input, region); pixman_region32_copy(&surface->pending.input, region);
} else { } else {
pixman_region32_fini(&surface->pending->input); pixman_region32_fini(&surface->pending.input);
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);
} }
} }
@ -277,10 +277,10 @@ static void surface_damage_subsurfaces(struct wlr_subsurface *subsurface) {
// seems to work ok. See the comment on weston_surface_damage for more info // seems to work ok. See the comment on weston_surface_damage for more info
// about a better approach. // about a better approach.
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
pixman_region32_union_rect(&surface->current->surface_damage, pixman_region32_union_rect(&surface->current.surface_damage,
&surface->current->surface_damage, &surface->current.surface_damage,
0, 0, surface->current->width, 0, 0, surface->current.width,
surface->current->height); surface->current.height);
subsurface->reordered = false; subsurface->reordered = false;
@ -291,7 +291,7 @@ static void surface_damage_subsurfaces(struct wlr_subsurface *subsurface) {
} }
static void surface_apply_damage(struct wlr_surface *surface) { static void surface_apply_damage(struct wlr_surface *surface) {
struct wl_resource *resource = surface->current->buffer; struct wl_resource *resource = surface->current.buffer;
if (resource == NULL) { if (resource == NULL) {
// NULL commit // NULL commit
wlr_buffer_unref(surface->buffer); wlr_buffer_unref(surface->buffer);
@ -302,9 +302,9 @@ static void surface_apply_damage(struct wlr_surface *surface) {
if (surface->buffer != NULL && surface->buffer->released) { if (surface->buffer != NULL && surface->buffer->released) {
pixman_region32_t damage; pixman_region32_t damage;
pixman_region32_init(&damage); pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->buffer_damage); pixman_region32_copy(&damage, &surface->current.buffer_damage);
pixman_region32_intersect_rect(&damage, &damage, 0, 0, pixman_region32_intersect_rect(&damage, &damage, 0, 0,
surface->current->buffer_width, surface->current->buffer_height); surface->current.buffer_width, surface->current.buffer_height);
struct wlr_buffer *updated_buffer = struct wlr_buffer *updated_buffer =
wlr_buffer_apply_damage(surface->buffer, resource, &damage); wlr_buffer_apply_damage(surface->buffer, resource, &damage);
@ -330,9 +330,9 @@ static void surface_apply_damage(struct wlr_surface *surface) {
} }
static void surface_commit_pending(struct wlr_surface *surface) { static void surface_commit_pending(struct wlr_surface *surface) {
bool invalid_buffer = surface->pending->committed & WLR_SURFACE_STATE_BUFFER; bool invalid_buffer = surface->pending.committed & WLR_SURFACE_STATE_BUFFER;
surface_move_state(surface, surface->pending, surface->current); surface_move_state(surface, &surface->pending, &surface->current);
if (invalid_buffer) { if (invalid_buffer) {
surface_apply_damage(surface); surface_apply_damage(surface);
@ -357,8 +357,8 @@ static void surface_commit_pending(struct wlr_surface *surface) {
wlr_signal_emit_safe(&surface->events.commit, surface); wlr_signal_emit_safe(&surface->events.commit, surface);
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);
} }
static bool subsurface_is_synchronized(struct wlr_subsurface *subsurface) { static bool subsurface_is_synchronized(struct wlr_subsurface *subsurface) {
@ -388,10 +388,10 @@ static void subsurface_parent_commit(struct wlr_subsurface *subsurface,
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
if (synchronized || subsurface->synchronized) { if (synchronized || subsurface->synchronized) {
if (subsurface->has_cache) { if (subsurface->has_cache) {
surface_move_state(surface, subsurface->cached, surface->pending); surface_move_state(surface, &subsurface->cached, &surface->pending);
surface_commit_pending(surface); surface_commit_pending(surface);
subsurface->has_cache = false; subsurface->has_cache = false;
subsurface->cached->committed = 0; subsurface->cached.committed = 0;
} }
struct wlr_subsurface *subsurface; struct wlr_subsurface *subsurface;
@ -405,11 +405,11 @@ static void subsurface_commit(struct wlr_subsurface *subsurface) {
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
if (subsurface_is_synchronized(subsurface)) { if (subsurface_is_synchronized(subsurface)) {
surface_move_state(surface, surface->pending, subsurface->cached); surface_move_state(surface, &surface->pending, &subsurface->cached);
subsurface->has_cache = true; subsurface->has_cache = true;
} else { } else {
if (subsurface->has_cache) { if (subsurface->has_cache) {
surface_move_state(surface, subsurface->cached, surface->pending); surface_move_state(surface, &subsurface->cached, &surface->pending);
surface_commit_pending(surface); surface_commit_pending(surface);
subsurface->has_cache = false; subsurface->has_cache = false;
} else { } else {
@ -439,16 +439,16 @@ static void surface_commit(struct wl_client *client,
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 = wlr_surface_from_resource(resource); struct wlr_surface *surface = wlr_surface_from_resource(resource);
surface->pending->committed |= WLR_SURFACE_STATE_TRANSFORM; surface->pending.committed |= WLR_SURFACE_STATE_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 = wlr_surface_from_resource(resource); struct wlr_surface *surface = wlr_surface_from_resource(resource);
surface->pending->committed |= WLR_SURFACE_STATE_SCALE; surface->pending.committed |= WLR_SURFACE_STATE_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,
@ -459,9 +459,9 @@ static void surface_damage_buffer(struct wl_client *client,
if (width < 0 || height < 0) { if (width < 0 || height < 0) {
return; return;
} }
surface->pending->committed |= WLR_SURFACE_STATE_BUFFER_DAMAGE; surface->pending.committed |= WLR_SURFACE_STATE_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);
} }
@ -484,12 +484,7 @@ struct wlr_surface *wlr_surface_from_resource(struct wl_resource *resource) {
return wl_resource_get_user_data(resource); return wl_resource_get_user_data(resource);
} }
static struct wlr_surface_state *surface_state_create(void) { static void surface_state_init(struct wlr_surface_state *state) {
struct wlr_surface_state *state =
calloc(1, sizeof(struct wlr_surface_state));
if (state == NULL) {
return NULL;
}
state->scale = 1; state->scale = 1;
state->transform = WL_OUTPUT_TRANSFORM_NORMAL; state->transform = WL_OUTPUT_TRANSFORM_NORMAL;
@ -500,12 +495,11 @@ static struct wlr_surface_state *surface_state_create(void) {
pixman_region32_init(&state->opaque); pixman_region32_init(&state->opaque);
pixman_region32_init_rect(&state->input, pixman_region32_init_rect(&state->input,
INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX); INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
return state;
} }
static void surface_state_destroy(struct wlr_surface_state *state) { static void surface_state_finish(struct wlr_surface_state *state) {
surface_state_reset_buffer(state); surface_state_reset_buffer(state);
struct wl_resource *resource, *tmp; struct wl_resource *resource, *tmp;
wl_resource_for_each_safe(resource, tmp, &state->frame_callback_list) { wl_resource_for_each_safe(resource, tmp, &state->frame_callback_list) {
wl_resource_destroy(resource); wl_resource_destroy(resource);
@ -515,8 +509,6 @@ static void surface_state_destroy(struct wlr_surface_state *state) {
pixman_region32_fini(&state->buffer_damage); pixman_region32_fini(&state->buffer_damage);
pixman_region32_fini(&state->opaque); pixman_region32_fini(&state->opaque);
pixman_region32_fini(&state->input); pixman_region32_fini(&state->input);
free(state);
} }
static void subsurface_destroy(struct wlr_subsurface *subsurface) { static void subsurface_destroy(struct wlr_subsurface *subsurface) {
@ -527,7 +519,7 @@ static void subsurface_destroy(struct wlr_subsurface *subsurface) {
wlr_signal_emit_safe(&subsurface->events.destroy, subsurface); wlr_signal_emit_safe(&subsurface->events.destroy, subsurface);
wl_list_remove(&subsurface->surface_destroy.link); wl_list_remove(&subsurface->surface_destroy.link);
surface_state_destroy(subsurface->cached); surface_state_finish(&subsurface->cached);
if (subsurface->parent) { if (subsurface->parent) {
wl_list_remove(&subsurface->parent_link); wl_list_remove(&subsurface->parent_link);
@ -550,8 +542,8 @@ static void surface_handle_resource_destroy(struct wl_resource *resource) {
wl_list_remove(wl_resource_get_link(surface->resource)); wl_list_remove(wl_resource_get_link(surface->resource));
wl_list_remove(&surface->renderer_destroy.link); wl_list_remove(&surface->renderer_destroy.link);
surface_state_destroy(surface->pending); surface_state_finish(&surface->pending);
surface_state_destroy(surface->current); surface_state_finish(&surface->current);
wlr_buffer_unref(surface->buffer); wlr_buffer_unref(surface->buffer);
free(surface); free(surface);
} }
@ -587,8 +579,8 @@ struct wlr_surface *wlr_surface_create(struct wl_client *client,
surface->renderer = renderer; surface->renderer = renderer;
surface->current = surface_state_create(); surface_state_init(&surface->current);
surface->pending = surface_state_create(); surface_state_init(&surface->pending);
wl_signal_init(&surface->events.commit); wl_signal_init(&surface->events.commit);
wl_signal_init(&surface->events.destroy); wl_signal_init(&surface->events.destroy);
@ -790,15 +782,15 @@ static void subsurface_role_committed(struct wlr_surface *surface, void *data) {
// TODO: take the previous size // TODO: take the previous size
pixman_region32_union_rect( pixman_region32_union_rect(
&subsurface->surface->pending->surface_damage, &subsurface->surface->pending.surface_damage,
&subsurface->surface->pending->surface_damage, dx, dy, &subsurface->surface->pending.surface_damage, dx, dy,
subsurface->surface->current->width, subsurface->surface->current.width,
subsurface->surface->current->height); subsurface->surface->current.height);
pixman_region32_union_rect( pixman_region32_union_rect(
&subsurface->surface->pending->surface_damage, &subsurface->surface->pending.surface_damage,
&subsurface->surface->pending->surface_damage, 0, 0, &subsurface->surface->pending.surface_damage, 0, 0,
subsurface->surface->pending->width, subsurface->surface->pending.width,
subsurface->surface->pending->height); subsurface->surface->pending.height);
} }
} }
@ -832,18 +824,13 @@ struct wlr_subsurface *wlr_subsurface_create(struct wlr_surface *surface,
wl_client_post_no_memory(client); wl_client_post_no_memory(client);
return NULL; return NULL;
} }
subsurface->cached = surface_state_create(); surface_state_init(&subsurface->cached);
if (subsurface->cached == NULL) {
free(subsurface);
wl_client_post_no_memory(client);
return NULL;
}
subsurface->synchronized = true; subsurface->synchronized = true;
subsurface->surface = surface; subsurface->surface = surface;
subsurface->resource = subsurface->resource =
wl_resource_create(client, &wl_subsurface_interface, version, id); wl_resource_create(client, &wl_subsurface_interface, version, id);
if (subsurface->resource == NULL) { if (subsurface->resource == NULL) {
surface_state_destroy(subsurface->cached); surface_state_finish(&subsurface->cached);
free(subsurface); free(subsurface);
wl_client_post_no_memory(client); wl_client_post_no_memory(client);
return NULL; return NULL;
@ -892,9 +879,9 @@ struct wlr_surface *wlr_surface_get_root_surface(struct wlr_surface *surface) {
bool wlr_surface_point_accepts_input(struct wlr_surface *surface, bool wlr_surface_point_accepts_input(struct wlr_surface *surface,
double sx, double sy) { double sx, double sy) {
return sx >= 0 && sx < surface->current->width && return sx >= 0 && sx < surface->current.width &&
sy >= 0 && sy < surface->current->height && sy >= 0 && sy < surface->current.height &&
pixman_region32_contains_point(&surface->current->input, sx, sy, NULL); pixman_region32_contains_point(&surface->current.input, sx, sy, NULL);
} }
struct wlr_surface *wlr_surface_surface_at(struct wlr_surface *surface, struct wlr_surface *wlr_surface_surface_at(struct wlr_surface *surface,
@ -949,7 +936,7 @@ void wlr_surface_send_frame_done(struct wlr_surface *surface,
const struct timespec *when) { const struct timespec *when) {
struct wl_resource *resource, *tmp; struct wl_resource *resource, *tmp;
wl_resource_for_each_safe(resource, tmp, wl_resource_for_each_safe(resource, tmp,
&surface->current->frame_callback_list) { &surface->current.frame_callback_list) {
wl_callback_send_done(resource, timespec_to_msec(when)); wl_callback_send_done(resource, timespec_to_msec(when));
wl_resource_destroy(resource); wl_resource_destroy(resource);
} }
@ -994,16 +981,16 @@ static void handle_bounding_box_surface(struct wlr_surface *surface,
acc->min_x = min(x, acc->min_x); acc->min_x = min(x, acc->min_x);
acc->min_y = min(y, acc->min_y); acc->min_y = min(y, acc->min_y);
acc->max_x = max(x + surface->current->width, acc->max_x); acc->max_x = max(x + surface->current.width, acc->max_x);
acc->max_y = max(y + surface->current->height, acc->max_y); acc->max_y = max(y + surface->current.height, acc->max_y);
} }
void wlr_surface_get_extends(struct wlr_surface *surface, struct wlr_box *box) { void wlr_surface_get_extends(struct wlr_surface *surface, struct wlr_box *box) {
struct bound_acc acc = { struct bound_acc acc = {
.min_x = 0, .min_x = 0,
.min_y = 0, .min_y = 0,
.max_x = surface->current->width, .max_x = surface->current.width,
.max_y = surface->current->height, .max_y = surface->current.height,
}; };
wlr_surface_for_each_surface(surface, handle_bounding_box_surface, &acc); wlr_surface_for_each_surface(surface, handle_bounding_box_surface, &acc);

4
types/xdg_shell/wlr_xdg_toplevel.c
View file

@ -39,8 +39,8 @@ bool compare_xdg_surface_toplevel_state(struct wlr_xdg_toplevel *state) {
if (wl_list_empty(&state->base->configure_list)) { if (wl_list_empty(&state->base->configure_list)) {
// last configure is actually the current state, just use it // last configure is actually the current state, just use it
configured.state = state->current; configured.state = state->current;
configured.width = state->base->surface->current->width; configured.width = state->base->surface->current.width;
configured.height = state->base->surface->current->height; configured.height = state->base->surface->current.height;
} else { } else {
struct wlr_xdg_surface_configure *configure = struct wlr_xdg_surface_configure *configure =
wl_container_of(state->base->configure_list.prev, configure, link); wl_container_of(state->base->configure_list.prev, configure, link);

4
types/xdg_shell_v6/wlr_xdg_toplevel_v6.c
View file

@ -287,8 +287,8 @@ bool compare_xdg_surface_v6_toplevel_state(struct wlr_xdg_toplevel_v6 *state) {
if (wl_list_empty(&state->base->configure_list)) { if (wl_list_empty(&state->base->configure_list)) {
// last configure is actually the current state, just use it // last configure is actually the current state, just use it
configured.state = state->current; configured.state = state->current;
configured.width = state->base->surface->current->width; configured.width = state->base->surface->current.width;
configured.height = state->base->surface->current->height; configured.height = state->base->surface->current.height;
} else { } else {
struct wlr_xdg_surface_v6_configure *configure = struct wlr_xdg_surface_v6_configure *configure =
wl_container_of(state->base->configure_list.prev, configure, link); wl_container_of(state->base->configure_list.prev, configure, link);