itycodes
/
wlseeds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into feature/multiseat

Browse Source
master
Tony Crisci 7 years ago
parent 704f0f158a 74a45ee776
commit b74c4cf974
17 changed files with 296 additions and 112 deletions
Show Stats Download Patch File Download Diff File

2
backend/wayland/wl_seat.c
Unescape View File

@ -90,7 +90,7 @@ static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
struct wlr_event_pointer_axis wlr_event; struct wlr_event_pointer_axis wlr_event;
wlr_event.device = dev; wlr_event.device = dev;
wlr_event.delta = value; wlr_event.delta = wl_fixed_to_double(value);
wlr_event.orientation = axis; wlr_event.orientation = axis;
wlr_event.time_msec = time; wlr_event.time_msec = time;
wlr_event.source = wlr_wl_pointer->axis_source; wlr_event.source = wlr_wl_pointer->axis_source;

8
include/rootston/view.h
Unescape View File

@ -73,15 +73,19 @@ struct roots_view {
// elsewhere // elsewhere
void (*get_size)(struct roots_view *view, struct wlr_box *box); void (*get_size)(struct roots_view *view, struct wlr_box *box);
void (*activate)(struct roots_view *view, bool active); void (*activate)(struct roots_view *view, bool active);
void (*move)(struct roots_view *view, double x, double y);
void (*resize)(struct roots_view *view, uint32_t width, uint32_t height); void (*resize)(struct roots_view *view, uint32_t width, uint32_t height);
void (*set_position)(struct roots_view *view, double x, double y); void (*move_resize)(struct roots_view *view, double x, double y,
uint32_t width, uint32_t height);
void (*close)(struct roots_view *view); void (*close)(struct roots_view *view);
}; };
void view_get_size(struct roots_view *view, struct wlr_box *box); void view_get_size(struct roots_view *view, struct wlr_box *box);
void view_activate(struct roots_view *view, bool active); void view_activate(struct roots_view *view, bool active);
void view_move(struct roots_view *view, double x, double y);
void view_resize(struct roots_view *view, uint32_t width, uint32_t height); void view_resize(struct roots_view *view, uint32_t width, uint32_t height);
void view_set_position(struct roots_view *view, double x, double y); void view_move_resize(struct roots_view *view, double x, double y,
uint32_t width, uint32_t height);
void view_close(struct roots_view *view); void view_close(struct roots_view *view);
bool view_center(struct roots_view *view); bool view_center(struct roots_view *view);
void view_setup(struct roots_view *view); void view_setup(struct roots_view *view);

23
rootston/cursor.c
Unescape View File

@ -119,8 +119,8 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
if (input->active_view) { if (input->active_view) {
double dx = input->cursor->x - input->offs_x; double dx = input->cursor->x - input->offs_x;
double dy = input->cursor->y - input->offs_y; double dy = input->cursor->y - input->offs_y;
view_set_position(input->active_view, view_move(input->active_view, input->view_x + dx,
input->view_x + dx, input->view_y + dy); input->view_y + dy);
} }
break; break;
case ROOTS_CURSOR_RESIZE: case ROOTS_CURSOR_RESIZE:
@ -134,15 +134,19 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) { if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) {
active_y = input->view_y + dy; active_y = input->view_y + dy;
height -= dy; height -= dy;
} if (height < 0) {
if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) { active_y += height;
}
} else if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
height += dy; height += dy;
} }
if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) { if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
active_x = input->view_x + dx; active_x = input->view_x + dx;
width -= dx; width -= dx;
} if (width < 0) {
if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) { active_x += width;
}
} else if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
width += dx; width += dx;
} }
@ -153,12 +157,13 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
height = 0; height = 0;
} }
// TODO we might need one configure event for this
if (active_x != input->active_view->x || if (active_x != input->active_view->x ||
active_y != input->active_view->y) { active_y != input->active_view->y) {
view_set_position(input->active_view, active_x, active_y); view_move_resize(input->active_view, active_x, active_y,
width, height);
} else {
view_resize(input->active_view, width, height);
} }
view_resize(input->active_view, width, height);
} }
break; break;
case ROOTS_CURSOR_ROTATE: case ROOTS_CURSOR_ROTATE:

31
rootston/desktop.c
Unescape View File

@ -45,9 +45,15 @@ void view_get_size(struct roots_view *view, struct wlr_box *box) {
box->height = view->wlr_surface->current->height; box->height = view->wlr_surface->current->height;
} }
void view_set_position(struct roots_view *view, double x, double y) { void view_activate(struct roots_view *view, bool activate) {
if (view->set_position) { if (view->activate) {
view->set_position(view, x, y); view->activate(view, activate);
}
}
void view_move(struct roots_view *view, double x, double y) {
if (view->move) {
view->move(view, x, y);
return; return;
} }
@ -55,18 +61,23 @@ void view_set_position(struct roots_view *view, double x, double y) {
view->y = y; view->y = y;
} }
void view_activate(struct roots_view *view, bool activate) {
if (view->activate) {
view->activate(view, activate);
}
}
void view_resize(struct roots_view *view, uint32_t width, uint32_t height) { void view_resize(struct roots_view *view, uint32_t width, uint32_t height) {
if (view->resize) { if (view->resize) {
view->resize(view, width, height); view->resize(view, width, height);
} }
} }
void view_move_resize(struct roots_view *view, double x, double y,
uint32_t width, uint32_t height) {
if (view->move_resize) {
view->move_resize(view, x, y, width, height);
return;
}
view_move(view, x, y);
view_resize(view, width, height);
}
void view_close(struct roots_view *view) { void view_close(struct roots_view *view) {
if (view->close) { if (view->close) {
view->close(view); view->close(view);
@ -101,7 +112,7 @@ bool view_center(struct roots_view *view) {
double view_x = (double)(width - size.width) / 2 + l_output->x; double view_x = (double)(width - size.width) / 2 + l_output->x;
double view_y = (double)(height - size.height) / 2 + l_output->y; double view_y = (double)(height - size.height) / 2 + l_output->y;
view_set_position(view, view_x, view_y); view_move(view, view_x, view_y);
return true; return true;
} }

2
rootston/wl_shell.c
Unescape View File

@ -120,7 +120,7 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
surface->parent); surface->parent);
if (i != -1) { if (i != -1) {
struct roots_view *parent = desktop->views->items[i]; struct roots_view *parent = desktop->views->items[i];
view_set_position(view, view_move(view,
parent->x + surface->transient_state->x, parent->x + surface->transient_state->x,
parent->y + surface->transient_state->y); parent->y + surface->transient_state->y);
} }

75
rootston/xdg_shell_v6.c
Unescape View File

@ -25,27 +25,63 @@ static void activate(struct roots_view *view, bool active) {
} }
} }
static void apply_size_constraints(struct wlr_xdg_surface_v6 *surf,
uint32_t width, uint32_t height, uint32_t *dest_width,
uint32_t *dest_height) {
*dest_width = width;
*dest_height = height;
struct wlr_xdg_toplevel_v6_state *state =
&surf->toplevel_state->current;
if (width < state->min_width) {
*dest_width = state->min_width;
} else if (state->max_width > 0 &&
width > state->max_width) {
*dest_width = state->max_width;
}
if (height < state->min_height) {
*dest_height = state->min_height;
} else if (state->max_height > 0 &&
height > state->max_height) {
*dest_height = state->max_height;
}
}
static void resize(struct roots_view *view, uint32_t width, uint32_t height) { static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
assert(view->type == ROOTS_XDG_SHELL_V6_VIEW); assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6; struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
if (surf->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) { if (surf->role != WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
struct wlr_xdg_toplevel_v6_state *state = return;
&surf->toplevel_state->current; }
if (width < state->min_width) {
width = state->min_width; uint32_t contrained_width, contrained_height;
} else if (state->max_width > 0 && apply_size_constraints(surf, width, height, &contrained_width,
width > state->max_width) { &contrained_height);
width = state->max_width;
} wlr_xdg_toplevel_v6_set_size(surf, contrained_width, contrained_height);
if (height < state->min_height) { }
height = state->min_height;
} else if (state->max_height > 0 && static void move_resize(struct roots_view *view, double x, double y,
height > state->max_height) { uint32_t width, uint32_t height) {
height = state->max_height; assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
} struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
if (surf->role != WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
wlr_xdg_toplevel_v6_set_size(surf, width, height); return;
} }
uint32_t contrained_width, contrained_height;
apply_size_constraints(surf, width, height, &contrained_width,
&contrained_height);
x = x + width - contrained_width;
y = y + height - contrained_height;
// TODO: we should wait for an ack_configure event before updating the
// position
view->x = x;
view->y = y;
wlr_xdg_toplevel_v6_set_size(surf, contrained_width, contrained_height);
} }
static void close(struct roots_view *view) { static void close(struct roots_view *view) {
@ -130,6 +166,10 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
&roots_surface->request_resize); &roots_surface->request_resize);
struct roots_view *view = calloc(1, sizeof(struct roots_view)); struct roots_view *view = calloc(1, sizeof(struct roots_view));
if (!view) {
free(roots_surface);
return;
}
view->type = ROOTS_XDG_SHELL_V6_VIEW; view->type = ROOTS_XDG_SHELL_V6_VIEW;
view->xdg_surface_v6 = surface; view->xdg_surface_v6 = surface;
view->roots_xdg_surface_v6 = roots_surface; view->roots_xdg_surface_v6 = roots_surface;
@ -137,6 +177,7 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
view->get_size = get_size; view->get_size = get_size;
view->activate = activate; view->activate = activate;
view->resize = resize; view->resize = resize;
view->move_resize = move_resize;
view->close = close; view->close = close;
view->desktop = desktop; view->desktop = desktop;
roots_surface->view = view; roots_surface->view = view;

50
rootston/xwayland.c
Unescape View File

@ -15,38 +15,69 @@ static void activate(struct roots_view *view, bool active) {
wlr_xwayland_surface_activate(xwayland, view->xwayland_surface, active); wlr_xwayland_surface_activate(xwayland, view->xwayland_surface, active);
} }
static void resize(struct roots_view *view, uint32_t width, uint32_t height) { static void move(struct roots_view *view, double x, double y) {
assert(view->type == ROOTS_XWAYLAND_VIEW); assert(view->type == ROOTS_XWAYLAND_VIEW);
struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface; struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
view->x = x;
view->y = y;
wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
x, y, xwayland_surface->width, xwayland_surface->height);
}
static void apply_size_constraints(
struct wlr_xwayland_surface *xwayland_surface, uint32_t width,
uint32_t height, uint32_t *dest_width, uint32_t *dest_height) {
*dest_width = width;
*dest_height = height;
struct wlr_xwayland_surface_size_hints *size_hints = struct wlr_xwayland_surface_size_hints *size_hints =
xwayland_surface->size_hints; xwayland_surface->size_hints;
if (size_hints != NULL) { if (size_hints != NULL) {
if (width < (uint32_t)size_hints->min_width) { if (width < (uint32_t)size_hints->min_width) {
width = size_hints->min_width; *dest_width = size_hints->min_width;
} else if (size_hints->max_width > 0 && } else if (size_hints->max_width > 0 &&
width > (uint32_t)size_hints->max_width) { width > (uint32_t)size_hints->max_width) {
width = size_hints->max_width; *dest_width = size_hints->max_width;
} }
if (height < (uint32_t)size_hints->min_height) { if (height < (uint32_t)size_hints->min_height) {
height = size_hints->min_height; *dest_height = size_hints->min_height;
} else if (size_hints->max_height > 0 && } else if (size_hints->max_height > 0 &&
height > (uint32_t)size_hints->max_height) { height > (uint32_t)size_hints->max_height) {
height = size_hints->max_height; *dest_height = size_hints->max_height;
} }
} }
}
static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
assert(view->type == ROOTS_XWAYLAND_VIEW);
struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
uint32_t contrained_width, contrained_height;
apply_size_constraints(xwayland_surface, width, height, &contrained_width,
&contrained_height);
wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface, wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
xwayland_surface->x, xwayland_surface->y, width, height); xwayland_surface->x, xwayland_surface->y, contrained_width,
contrained_height);
} }
static void set_position(struct roots_view *view, double x, double y) { static void move_resize(struct roots_view *view, double x, double y,
uint32_t width, uint32_t height) {
assert(view->type == ROOTS_XWAYLAND_VIEW); assert(view->type == ROOTS_XWAYLAND_VIEW);
struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface; struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
uint32_t contrained_width, contrained_height;
apply_size_constraints(xwayland_surface, width, height, &contrained_width,
&contrained_height);
x = x + width - contrained_width;
y = y + height - contrained_height;
view->x = x; view->x = x;
view->y = y; view->y = y;
wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface, wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
x, y, xwayland_surface->width, xwayland_surface->height); x, y, contrained_width, contrained_height);
} }
static void close(struct roots_view *view) { static void close(struct roots_view *view) {
@ -204,7 +235,8 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
view->desktop = desktop; view->desktop = desktop;
view->activate = activate; view->activate = activate;
view->resize = resize; view->resize = resize;
view->set_position = set_position; view->move = move;
view->move_resize = move_resize;
view->close = close; view->close = close;
roots_surface->view = view; roots_surface->view = view;
wlr_list_add(desktop->views, view); wlr_list_add(desktop->views, view);

23
types/wlr_compositor.c
Unescape View File

@ -13,10 +13,21 @@ static void destroy_surface_listener(struct wl_listener *listener, void *data) {
static void wl_compositor_create_surface(struct wl_client *client, static void wl_compositor_create_surface(struct wl_client *client,
struct wl_resource *resource, uint32_t id) { struct wl_resource *resource, uint32_t id) {
struct wlr_compositor *compositor = wl_resource_get_user_data(resource); struct wlr_compositor *compositor = wl_resource_get_user_data(resource);
struct wl_resource *surface_resource = wl_resource_create(client, struct wl_resource *surface_resource = wl_resource_create(client,
&wl_surface_interface, wl_resource_get_version(resource), id); &wl_surface_interface, wl_resource_get_version(resource), id);
if (surface_resource == NULL) {
wl_resource_post_no_memory(resource);
return;
}
struct wlr_surface *surface = wlr_surface_create(surface_resource, struct wlr_surface *surface = wlr_surface_create(surface_resource,
compositor->renderer); compositor->renderer);
if (surface == NULL) {
wl_resource_destroy(surface_resource);
wl_resource_post_no_memory(resource);
return;
}
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, wl_resource_add_destroy_listener(surface_resource,
@ -49,13 +60,17 @@ static void wl_compositor_destroy(struct wl_resource *resource) {
} }
} }
static void wl_compositor_bind(struct wl_client *wl_client, void *_compositor, static void wl_compositor_bind(struct wl_client *wl_client, void *data,
uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_compositor *compositor = _compositor; struct wlr_compositor *compositor = data;
assert(wl_client && compositor); assert(wl_client && compositor);
struct wl_resource *wl_resource = struct wl_resource *wl_resource =
wl_resource_create(wl_client, &wl_compositor_interface, version, id); wl_resource_create(wl_client, &wl_compositor_interface, version, id);
if (wl_resource == NULL) {
wl_client_post_no_memory(wl_client);
return;
}
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_list_insert(&compositor->wl_resources,

16
types/wlr_data_device.c
Unescape View File

@ -233,6 +233,9 @@ static struct wlr_data_offer *wlr_data_source_send_offer(
struct wlr_data_source *source, struct wlr_data_source *source,
struct wl_resource *target) { struct wl_resource *target) {
struct wlr_data_offer *offer = calloc(1, sizeof(struct wlr_data_offer)); struct wlr_data_offer *offer = calloc(1, sizeof(struct wlr_data_offer));
if (offer == NULL) {
return NULL;
}
offer->resource = offer->resource =
wl_resource_create(wl_resource_get_client(target), wl_resource_create(wl_resource_get_client(target),
@ -781,18 +784,16 @@ data_device_manager_impl = {
static void data_device_manager_bind(struct wl_client *client, static void data_device_manager_bind(struct wl_client *client,
void *data, uint32_t version, uint32_t id) { void *data, uint32_t version, uint32_t id) {
struct wl_resource *resource; struct wl_resource *resource = wl_resource_create(client,
&wl_data_device_manager_interface,
resource = wl_resource_create(client, version, id);
&wl_data_device_manager_interface,
version, id);
if (resource == NULL) { if (resource == NULL) {
wl_client_post_no_memory(client); wl_client_post_no_memory(client);
return; return;
} }
wl_resource_set_implementation(resource, wl_resource_set_implementation(resource, &data_device_manager_impl,
&data_device_manager_impl, NULL, NULL); NULL, NULL);
} }
struct wlr_data_device_manager *wlr_data_device_manager_create( struct wlr_data_device_manager *wlr_data_device_manager_create(
@ -807,7 +808,6 @@ struct wlr_data_device_manager *wlr_data_device_manager_create(
manager->global = manager->global =
wl_global_create(display, &wl_data_device_manager_interface, wl_global_create(display, &wl_data_device_manager_interface,
3, NULL, data_device_manager_bind); 3, NULL, data_device_manager_bind);
if (!manager->global) { if (!manager->global) {
wlr_log(L_ERROR, "could not create data device manager wl global"); wlr_log(L_ERROR, "could not create data device manager wl global");
free(manager); free(manager);

9
types/wlr_gamma_control.c
Unescape View File

@ -83,8 +83,8 @@ static void gamma_control_manager_get_gamma_control(struct wl_client *client,
gamma_control->resource = wl_resource_create(client, gamma_control->resource = wl_resource_create(client,
&gamma_control_interface, version, id); &gamma_control_interface, version, id);
if (gamma_control->resource == NULL) { if (gamma_control->resource == NULL) {
wl_client_post_no_memory(client);
free(gamma_control); free(gamma_control);
wl_client_post_no_memory(client);
return; return;
} }
wlr_log(L_DEBUG, "new gamma_control %p (res %p)", gamma_control, wlr_log(L_DEBUG, "new gamma_control %p (res %p)", gamma_control,
@ -109,10 +109,9 @@ static struct gamma_control_manager_interface gamma_control_manager_impl = {
.get_gamma_control = gamma_control_manager_get_gamma_control, .get_gamma_control = gamma_control_manager_get_gamma_control,
}; };
static void gamma_control_manager_bind(struct wl_client *client, static void gamma_control_manager_bind(struct wl_client *client, void *data,
void *_gamma_control_manager, uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_gamma_control_manager *gamma_control_manager = struct wlr_gamma_control_manager *gamma_control_manager = data;
_gamma_control_manager;
assert(client && gamma_control_manager); assert(client && gamma_control_manager);
struct wl_resource *resource = wl_resource_create(client, struct wl_resource *resource = wl_resource_create(client,

8
types/wlr_output.c
Unescape View File

@ -91,13 +91,17 @@ static struct wl_output_interface wl_output_impl = {
.release = wl_output_release .release = wl_output_release
}; };
static void wl_output_bind(struct wl_client *wl_client, void *_wlr_output, static void wl_output_bind(struct wl_client *wl_client, void *data,
uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_output *wlr_output = _wlr_output; struct wlr_output *wlr_output = data;
assert(wl_client && wlr_output); assert(wl_client && wlr_output);
struct wl_resource *wl_resource = wl_resource_create(wl_client, struct wl_resource *wl_resource = wl_resource_create(wl_client,
&wl_output_interface, version, id); &wl_output_interface, version, id);
if (wl_resource == NULL) {
wl_client_post_no_memory(wl_client);
return;
}
wl_resource_set_implementation(wl_resource, &wl_output_impl, wlr_output, wl_resource_set_implementation(wl_resource, &wl_output_impl, wlr_output,
wl_output_destroy); wl_output_destroy);
wl_list_insert(&wlr_output->wl_resources, wl_list_insert(&wlr_output->wl_resources,

50
types/wlr_screenshooter.c
Unescape View File

@ -51,16 +51,17 @@ static void output_frame_notify(struct wl_listener *listener, void *_data) {
} }
static void screenshooter_shoot(struct wl_client *client, static void screenshooter_shoot(struct wl_client *client,
struct wl_resource *_screenshooter, uint32_t id, struct wl_resource *screenshooter_resource, uint32_t id,
struct wl_resource *_output, struct wl_resource *_buffer) { struct wl_resource *output_resource,
struct wl_resource *buffer_resource) {
struct wlr_screenshooter *screenshooter = struct wlr_screenshooter *screenshooter =
wl_resource_get_user_data(_screenshooter); wl_resource_get_user_data(screenshooter_resource);
struct wlr_output *output = wl_resource_get_user_data(_output); struct wlr_output *output = wl_resource_get_user_data(output_resource);
if (!wl_shm_buffer_get(_buffer)) { if (!wl_shm_buffer_get(buffer_resource)) {
wlr_log(L_ERROR, "Invalid buffer: not a shared memory buffer"); wlr_log(L_ERROR, "Invalid buffer: not a shared memory buffer");
return; return;
} }
struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(_buffer); struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(buffer_resource);
int32_t width = wl_shm_buffer_get_width(shm_buffer); int32_t width = wl_shm_buffer_get_width(shm_buffer);
int32_t height = wl_shm_buffer_get_height(shm_buffer); int32_t height = wl_shm_buffer_get_height(shm_buffer);
int32_t stride = wl_shm_buffer_get_stride(shm_buffer); int32_t stride = wl_shm_buffer_get_stride(shm_buffer);
@ -84,23 +85,31 @@ static void screenshooter_shoot(struct wl_client *client,
struct wlr_screenshot *screenshot = struct wlr_screenshot *screenshot =
calloc(1, sizeof(struct wlr_screenshot)); calloc(1, sizeof(struct wlr_screenshot));
if (!screenshot) { if (!screenshot) {
wl_client_post_no_memory(client); wl_resource_post_no_memory(screenshooter_resource);
return; return;
} }
screenshot->output_resource = _output; screenshot->output_resource = output_resource;
screenshot->output = output; screenshot->output = output;
screenshot->screenshooter = screenshooter; screenshot->screenshooter = screenshooter;
screenshot->resource = wl_resource_create(client, screenshot->resource = wl_resource_create(client,
&orbital_screenshot_interface, wl_resource_get_version(_screenshooter), &orbital_screenshot_interface,
id); wl_resource_get_version(screenshooter_resource), id);
wlr_log(L_DEBUG, "new screenshot %p (res %p)", screenshot, if (screenshot->resource == NULL) {
screenshot->resource); free(screenshot);
wl_resource_post_no_memory(screenshooter_resource);
return;
}
wl_resource_set_implementation(screenshot->resource, NULL, screenshot, wl_resource_set_implementation(screenshot->resource, NULL, screenshot,
NULL); NULL);
wlr_log(L_DEBUG, "new screenshot %p (res %p)", screenshot,
screenshot->resource);
struct screenshot_state *state = calloc(1, sizeof(struct screenshot_state)); struct screenshot_state *state = calloc(1, sizeof(struct screenshot_state));
if (!state) { if (!state) {
wl_client_post_no_memory(client); wl_resource_destroy(screenshot->resource);
free(screenshot);
wl_resource_post_no_memory(screenshooter_resource);
return; return;
} }
state->width = width; state->width = width;
@ -117,13 +126,17 @@ static struct orbital_screenshooter_interface screenshooter_impl = {
.shoot = screenshooter_shoot, .shoot = screenshooter_shoot,
}; };
static void screenshooter_bind(struct wl_client *wl_client, static void screenshooter_bind(struct wl_client *wl_client, void *data,
void *_screenshooter, uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_screenshooter *screenshooter = _screenshooter; struct wlr_screenshooter *screenshooter = data;
assert(wl_client && screenshooter); assert(wl_client && screenshooter);
struct wl_resource *wl_resource = wl_resource_create(wl_client, struct wl_resource *wl_resource = wl_resource_create(wl_client,
&orbital_screenshooter_interface, version, id); &orbital_screenshooter_interface, version, id);
if (wl_resource == NULL) {
wl_client_post_no_memory(wl_client);
return;
}
wl_resource_set_implementation(wl_resource, &screenshooter_impl, wl_resource_set_implementation(wl_resource, &screenshooter_impl,
screenshooter, NULL); screenshooter, NULL);
} }
@ -137,13 +150,12 @@ struct wlr_screenshooter *wlr_screenshooter_create(struct wl_display *display,
} }
screenshooter->renderer = renderer; screenshooter->renderer = renderer;
struct wl_global *wl_global = wl_global_create(display, screenshooter->wl_global = wl_global_create(display,
&orbital_screenshooter_interface, 1, screenshooter, screenshooter_bind); &orbital_screenshooter_interface, 1, screenshooter, screenshooter_bind);
if (!wl_global) { if (screenshooter->wl_global == NULL) {
free(screenshooter); free(screenshooter);
return NULL; return NULL;
} }
screenshooter->wl_global = wl_global;
return screenshooter; return screenshooter;
} }

23
types/wlr_seat.c
Unescape View File

@ -65,9 +65,9 @@ static void wl_pointer_destroy(struct wl_resource *resource) {
} }
static void wl_seat_get_pointer(struct wl_client *client, static void wl_seat_get_pointer(struct wl_client *client,
struct wl_resource *pointer_resource, uint32_t id) { struct wl_resource *seat_resource, uint32_t id) {
struct wlr_seat_client *seat_client = struct wlr_seat_client *seat_client =
wl_resource_get_user_data(pointer_resource); wl_resource_get_user_data(seat_resource);
if (!(seat_client->seat->capabilities & WL_SEAT_CAPABILITY_POINTER)) { if (!(seat_client->seat->capabilities & WL_SEAT_CAPABILITY_POINTER)) {
return; return;
} }
@ -78,7 +78,11 @@ static void wl_seat_get_pointer(struct wl_client *client,
wl_resource_destroy(seat_client->pointer); wl_resource_destroy(seat_client->pointer);
} }
seat_client->pointer = wl_resource_create(client, &wl_pointer_interface, seat_client->pointer = wl_resource_create(client, &wl_pointer_interface,
wl_resource_get_version(pointer_resource), id); wl_resource_get_version(seat_resource), id);
if (seat_client->pointer == NULL) {
wl_resource_post_no_memory(seat_resource);
return;
}
wl_resource_set_implementation(seat_client->pointer, &wl_pointer_impl, wl_resource_set_implementation(seat_client->pointer, &wl_pointer_impl,
seat_client, &wl_pointer_destroy); seat_client, &wl_pointer_destroy);
} }
@ -126,6 +130,10 @@ static void wl_seat_get_keyboard(struct wl_client *client,
} }
seat_client->keyboard = wl_resource_create(client, &wl_keyboard_interface, seat_client->keyboard = wl_resource_create(client, &wl_keyboard_interface,
wl_resource_get_version(seat_resource), id); wl_resource_get_version(seat_resource), id);
if (seat_client->keyboard == NULL) {
wl_resource_post_no_memory(seat_resource);
return;
}
wl_resource_set_implementation(seat_client->keyboard, &wl_keyboard_impl, wl_resource_set_implementation(seat_client->keyboard, &wl_keyboard_impl,
seat_client, &wl_keyboard_destroy); seat_client, &wl_keyboard_destroy);
@ -162,6 +170,10 @@ static void wl_seat_get_touch(struct wl_client *client,
} }
seat_client->touch = wl_resource_create(client, &wl_touch_interface, seat_client->touch = wl_resource_create(client, &wl_touch_interface,
wl_resource_get_version(seat_resource), id); wl_resource_get_version(seat_resource), id);
if (seat_client->touch == NULL) {
wl_resource_post_no_memory(seat_resource);
return;
}
wl_resource_set_implementation(seat_client->touch, &wl_touch_impl, wl_resource_set_implementation(seat_client->touch, &wl_touch_impl,
seat_client, &wl_touch_destroy); seat_client, &wl_touch_destroy);
} }
@ -213,6 +225,11 @@ static void wl_seat_bind(struct wl_client *client, void *_wlr_seat,
} }
seat_client->wl_resource = seat_client->wl_resource =
wl_resource_create(client, &wl_seat_interface, version, id); wl_resource_create(client, &wl_seat_interface, version, id);
if (seat_client->wl_resource == NULL) {
free(seat_client);
wl_client_post_no_memory(client);
return;
}
seat_client->client = client; seat_client->client = client;
seat_client->seat = wlr_seat; seat_client->seat = wlr_seat;
wl_resource_set_implementation(seat_client->wl_resource, &wl_seat_impl, wl_resource_set_implementation(seat_client->wl_resource, &wl_seat_impl,

8
types/wlr_server_decoration.c
Unescape View File

@ -73,8 +73,8 @@ static void server_decoration_manager_handle_create(struct wl_client *client,
decoration->resource = wl_resource_create(client, decoration->resource = wl_resource_create(client,
&org_kde_kwin_server_decoration_interface, version, id); &org_kde_kwin_server_decoration_interface, version, id);
if (decoration->resource == NULL) { if (decoration->resource == NULL) {
wl_client_post_no_memory(client);
free(decoration); free(decoration);
wl_client_post_no_memory(client);
return; return;
} }
wl_resource_set_implementation(decoration->resource, wl_resource_set_implementation(decoration->resource,
@ -120,9 +120,9 @@ void server_decoration_manager_destroy_resource(struct wl_resource *resource) {
wl_list_remove(wl_resource_get_link(resource)); wl_list_remove(wl_resource_get_link(resource));
} }
static void server_decoration_manager_bind(struct wl_client *client, static void server_decoration_manager_bind(struct wl_client *client, void *data,
void *_manager, uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_server_decoration_manager *manager = _manager; struct wlr_server_decoration_manager *manager = data;
assert(client && manager); assert(client && manager);
struct wl_resource *resource = wl_resource_create(client, struct wl_resource *resource = wl_resource_create(client,

15
types/wlr_surface.c
Unescape View File

@ -819,14 +819,21 @@ static void subsurface_handle_parent_destroy(struct wl_listener *listener,
void wlr_surface_make_subsurface(struct wlr_surface *surface, void wlr_surface_make_subsurface(struct wlr_surface *surface,
struct wlr_surface *parent, uint32_t id) { struct wlr_surface *parent, uint32_t id) {
struct wl_client *client = wl_resource_get_client(surface->resource);
assert(surface->subsurface == NULL); assert(surface->subsurface == NULL);
struct wlr_subsurface *subsurface = struct wlr_subsurface *subsurface =
calloc(1, sizeof(struct wlr_subsurface)); calloc(1, sizeof(struct wlr_subsurface));
if (!subsurface) { if (!subsurface) {
wl_client_post_no_memory(client);
return; return;
} }
subsurface->cached = wlr_surface_state_create(); subsurface->cached = wlr_surface_state_create();
if (subsurface->cached == NULL) {
free(subsurface);
wl_client_post_no_memory(client);
return;
}
subsurface->synchronized = true; subsurface->synchronized = true;
subsurface->surface = surface; subsurface->surface = surface;
@ -840,10 +847,14 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
wl_list_insert(&parent->subsurface_pending_list, wl_list_insert(&parent->subsurface_pending_list,
&subsurface->parent_pending_link); &subsurface->parent_pending_link);
struct wl_client *client = wl_resource_get_client(surface->resource);
subsurface->resource = subsurface->resource =
wl_resource_create(client, &wl_subsurface_interface, 1, id); wl_resource_create(client, &wl_subsurface_interface, 1, id);
if (subsurface->resource == NULL) {
wlr_surface_state_destroy(subsurface->cached);
free(subsurface);
wl_client_post_no_memory(client);
return;
}
wl_resource_set_implementation(subsurface->resource, wl_resource_set_implementation(subsurface->resource,
&subsurface_implementation, subsurface, &subsurface_implementation, subsurface,

29
types/wlr_wl_shell.c
Unescape View File

@ -506,19 +506,19 @@ static int shell_surface_ping_timeout(void *user_data) {
} }
static void shell_protocol_get_shell_surface(struct wl_client *client, static void shell_protocol_get_shell_surface(struct wl_client *client,
struct wl_resource *resource, uint32_t id, struct wl_resource *shell_resource, uint32_t id,
struct wl_resource *surface_resource) { struct wl_resource *surface_resource) {
struct wlr_surface *surface = wl_resource_get_user_data(surface_resource); struct wlr_surface *surface = wl_resource_get_user_data(surface_resource);
if (wlr_surface_set_role(surface, wlr_wl_shell_surface_role, if (wlr_surface_set_role(surface, wlr_wl_shell_surface_role,
resource, WL_SHELL_ERROR_ROLE)) { shell_resource, WL_SHELL_ERROR_ROLE)) {
return; return;
} }
struct wlr_wl_shell *wl_shell = wl_resource_get_user_data(resource); struct wlr_wl_shell *wl_shell = wl_resource_get_user_data(shell_resource);
struct wlr_wl_shell_surface *wl_surface = struct wlr_wl_shell_surface *wl_surface =
calloc(1, sizeof(struct wlr_wl_shell_surface)); calloc(1, sizeof(struct wlr_wl_shell_surface));
if (wl_surface == NULL) { if (wl_surface == NULL) {
wl_client_post_no_memory(client); wl_resource_post_no_memory(shell_resource);
return; return;
} }
wl_list_init(&wl_surface->grab_link); wl_list_init(&wl_surface->grab_link);
@ -530,13 +530,20 @@ static void shell_protocol_get_shell_surface(struct wl_client *client,
wl_surface->surface = surface; wl_surface->surface = surface;
wl_surface->resource = wl_resource_create(client, wl_surface->resource = wl_resource_create(client,
&wl_shell_surface_interface, wl_resource_get_version(resource), id); &wl_shell_surface_interface, wl_resource_get_version(shell_resource),
wlr_log(L_DEBUG, "new wl_shell %p (res %p)", wl_surface, id);
wl_surface->resource); if (wl_surface->resource == NULL) {
free(wl_surface);
wl_resource_post_no_memory(shell_resource);
return;
}
wl_resource_set_implementation(wl_surface->resource, wl_resource_set_implementation(wl_surface->resource,
&shell_surface_impl, wl_surface, &shell_surface_impl, wl_surface,
shell_surface_resource_destroy); shell_surface_resource_destroy);
wlr_log(L_DEBUG, "new wl_shell %p (res %p)", wl_surface,
wl_surface->resource);
wl_signal_init(&wl_surface->events.destroy); wl_signal_init(&wl_surface->events.destroy);
wl_signal_init(&wl_surface->events.ping_timeout); wl_signal_init(&wl_surface->events.ping_timeout);
wl_signal_init(&wl_surface->events.request_move); wl_signal_init(&wl_surface->events.request_move);
@ -574,13 +581,17 @@ static void shell_destroy(struct wl_resource *resource) {
wl_list_remove(wl_resource_get_link(resource)); wl_list_remove(wl_resource_get_link(resource));
} }
static void shell_bind(struct wl_client *wl_client, void *_wl_shell, static void shell_bind(struct wl_client *wl_client, void *data,
uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_wl_shell *wl_shell = _wl_shell; struct wlr_wl_shell *wl_shell = data;
assert(wl_client && wl_shell); assert(wl_client && wl_shell);
struct wl_resource *wl_resource = wl_resource_create(wl_client, struct wl_resource *wl_resource = wl_resource_create(wl_client,
&wl_shell_interface, version, id); &wl_shell_interface, version, id);
if (wl_resource == NULL) {
wl_client_post_no_memory(wl_client);
return;
}
wl_resource_set_implementation(wl_resource, &shell_impl, wl_shell, wl_resource_set_implementation(wl_resource, &shell_impl, wl_shell,
shell_destroy); shell_destroy);
wl_list_insert(&wl_shell->wl_resources, wl_resource_get_link(wl_resource)); wl_list_insert(&wl_shell->wl_resources, wl_resource_get_link(wl_resource));

36
types/wlr_xdg_shell_v6.c
Unescape View File

@ -343,8 +343,8 @@ static void xdg_shell_create_positioner(struct wl_client *wl_client,
wl_resource_get_version(resource), wl_resource_get_version(resource),
id); id);
if (positioner->resource == NULL) { if (positioner->resource == NULL) {
wl_client_post_no_memory(wl_client);
free(positioner); free(positioner);
wl_client_post_no_memory(wl_client);
return; return;
} }
@ -480,13 +480,13 @@ static void xdg_surface_get_popup(struct wl_client *client,
} }
if (wlr_surface_set_role(surface->surface, wlr_desktop_xdg_popup_role, if (wlr_surface_set_role(surface->surface, wlr_desktop_xdg_popup_role,
resource, ZXDG_SHELL_V6_ERROR_ROLE)) { resource, ZXDG_SHELL_V6_ERROR_ROLE)) {
return; return;
} }
surface->popup_state = calloc(1, sizeof(struct wlr_xdg_popup_v6)); surface->popup_state = calloc(1, sizeof(struct wlr_xdg_popup_v6));
if (!surface->popup_state) { if (!surface->popup_state) {
wl_client_post_no_memory(client); wl_resource_post_no_memory(resource);
return; return;
} }
@ -495,6 +495,7 @@ static void xdg_surface_get_popup(struct wl_client *client,
wl_resource_get_version(resource), id); wl_resource_get_version(resource), id);
if (surface->popup_state->resource == NULL) { if (surface->popup_state->resource == NULL) {
free(surface->popup_state); free(surface->popup_state);
wl_resource_post_no_memory(resource);
return; return;
} }
@ -735,7 +736,7 @@ static void xdg_surface_get_toplevel(struct wl_client *client,
surface->toplevel_state = calloc(1, sizeof(struct wlr_xdg_toplevel_v6)); surface->toplevel_state = calloc(1, sizeof(struct wlr_xdg_toplevel_v6));
if (surface->toplevel_state == NULL) { if (surface->toplevel_state == NULL) {
wl_client_post_no_memory(client); wl_resource_post_no_memory(resource);
return; return;
} }
@ -744,6 +745,11 @@ static void xdg_surface_get_toplevel(struct wl_client *client,
struct wl_resource *toplevel_resource = wl_resource_create(client, struct wl_resource *toplevel_resource = wl_resource_create(client,
&zxdg_toplevel_v6_interface, wl_resource_get_version(resource), id); &zxdg_toplevel_v6_interface, wl_resource_get_version(resource), id);
if (toplevel_resource == NULL) {
free(surface->toplevel_state);
wl_resource_post_no_memory(resource);
return;
}
surface->toplevel_state->resource = toplevel_resource; surface->toplevel_state->resource = toplevel_resource;
@ -1118,9 +1124,20 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client,
surface->resource = wl_resource_create(wl_client, surface->resource = wl_resource_create(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->resource == NULL) {
free(surface->next_geometry);
free(surface->geometry);
free(surface);
wl_client_post_no_memory(wl_client);
return;
}
if (wlr_surface_has_buffer(surface->surface)) { if (wlr_surface_has_buffer(surface->surface)) {
wl_resource_post_error(surface->resource, wl_resource_destroy(surface->resource);
free(surface->next_geometry);
free(surface->geometry);
free(surface);
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");
return; return;
@ -1199,9 +1216,9 @@ static int wlr_xdg_client_v6_ping_timeout(void *user_data) {
return 1; return 1;
} }
static void xdg_shell_bind(struct wl_client *wl_client, void *_xdg_shell, static void xdg_shell_bind(struct wl_client *wl_client, void *data,
uint32_t version, uint32_t id) { uint32_t version, uint32_t id) {
struct wlr_xdg_shell_v6 *xdg_shell = _xdg_shell; struct wlr_xdg_shell_v6 *xdg_shell = data;
assert(wl_client && xdg_shell); assert(wl_client && xdg_shell);
struct wlr_xdg_client_v6 *client = struct wlr_xdg_client_v6 *client =
@ -1215,6 +1232,11 @@ static void xdg_shell_bind(struct wl_client *wl_client, void *_xdg_shell,
client->resource = client->resource =
wl_resource_create(wl_client, &zxdg_shell_v6_interface, version, id); wl_resource_create(wl_client, &zxdg_shell_v6_interface, version, id);
if (client->resource == NULL) {
free(client);
wl_client_post_no_memory(wl_client);
return;
}
client->client = wl_client; client->client = wl_client;
client->shell = xdg_shell; client->shell = xdg_shell;

Write Preview
Loading…
Cancel
Save