static void
wp_viewport_set_destination (struct wl_client *client,
struct wl_resource *resource,
int dst_width,
int dst_height)
{
MetaWaylandSurface *surface;
surface = wl_resource_get_user_data (resource);
if (!surface)
{
wl_resource_post_error (resource,
WP_VIEWPORT_ERROR_NO_SURFACE,
"wl_surface for this viewport no longer exists");
return;
}
if ((dst_width > 0 && dst_height > 0) ||
(dst_width == -1 && dst_height == -1))
{
surface->pending->viewport_dst_width = dst_width;
surface->pending->viewport_dst_height = dst_height;
surface->pending->has_new_viewport_dst_size = TRUE;
}
else
{
wl_resource_post_error (resource,
WP_VIEWPORT_ERROR_BAD_VALUE,
"all values must be either positive or -1");
}
}
static void
drm_create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, uint32_t name, int32_t width, int32_t height,
uint32_t stride, uint32_t format)
{
struct wl_drm *drm = resource->data;
struct wl_drm_buffer *buffer;
switch (format) {
case WL_DRM_FORMAT_ARGB8888:
case WL_DRM_FORMAT_XRGB8888:
break;
default:
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_FORMAT,
"invalid format");
return;
}
buffer = calloc(1, sizeof *buffer);
if (buffer == NULL) {
wl_resource_post_no_memory(resource);
return;
}
buffer->drm = drm;
buffer->buffer.width = width;
buffer->buffer.height = height;
buffer->format = format;
buffer->driver_buffer =
drm->callbacks->reference_buffer(drm->user_data, name,
width, height,
stride, format);
if (buffer->driver_buffer == NULL) {
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_NAME,
"invalid name");
return;
}
buffer->buffer.resource.object.id = id;
buffer->buffer.resource.object.interface = &wl_buffer_interface;
buffer->buffer.resource.object.implementation =
(void (**)(void)) &drm_buffer_interface;
buffer->buffer.resource.data = buffer;
buffer->buffer.resource.destroy = destroy_buffer;
buffer->buffer.resource.client = resource->client;
wl_client_add_resource(resource->client, &buffer->buffer.resource);
}
static void
shm_pool_create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, int32_t offset,
int32_t width, int32_t height,
int32_t stride, uint32_t format)
{
struct wl_shm_pool *pool = wl_resource_get_user_data(resource);
struct wl_shm_buffer *buffer;
if (!format_is_supported(client, format)) {
wl_resource_post_error(resource,
WL_SHM_ERROR_INVALID_FORMAT,
"invalid format 0x%x", format);
return;
}
if (offset < 0 || width <= 0 || height <= 0 || stride < width ||
INT32_MAX / stride <= height ||
offset > pool->size - stride * height) {
wl_resource_post_error(resource,
WL_SHM_ERROR_INVALID_STRIDE,
"invalid width, height or stride (%dx%d, %u)",
width, height, stride);
return;
}
buffer = malloc(sizeof *buffer);
if (buffer == NULL) {
wl_client_post_no_memory(client);
return;
}
buffer->width = width;
buffer->height = height;
buffer->format = format;
buffer->stride = stride;
buffer->offset = offset;
buffer->pool = pool;
pool->refcount++;
buffer->resource =
wl_resource_create(client, &wl_buffer_interface, 1, id);
if (buffer->resource == NULL) {
wl_client_post_no_memory(client);
shm_pool_unref(pool);
free(buffer);
return;
}
wl_resource_set_implementation(buffer->resource,
&shm_buffer_interface,
buffer, destroy_buffer);
}
static void
shm_create_pool(struct wl_client *client, struct wl_resource *resource,
uint32_t id, int fd, int32_t size)
{
struct wl_shm_pool *pool;
pool = malloc(sizeof *pool);
if (pool == NULL) {
wl_client_post_no_memory(client);
goto err_close;
}
if (size <= 0) {
wl_resource_post_error(resource,
WL_SHM_ERROR_INVALID_STRIDE,
"invalid size (%d)", size);
goto err_free;
}
pool->refcount = 1;
pool->size = size;
pool->data = mmap(NULL, size,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (pool->data == MAP_FAILED) {
wl_resource_post_error(resource,
WL_SHM_ERROR_INVALID_FD,
"failed mmap fd %d", fd);
goto err_free;
}
close(fd);
pool->resource =
wl_resource_create(client, &wl_shm_pool_interface, 1, id);
if (!pool->resource) {
wl_client_post_no_memory(client);
munmap(pool->data, pool->size);
free(pool);
return;
}
wl_resource_set_implementation(pool->resource,
&shm_pool_interface,
pool, destroy_pool);
return;
err_close:
close(fd);
err_free:
free(pool);
}
static void
wp_viewport_set_source (struct wl_client *client,
struct wl_resource *resource,
wl_fixed_t src_x,
wl_fixed_t src_y,
wl_fixed_t src_width,
wl_fixed_t src_height)
{
MetaWaylandSurface *surface;
float new_x;
float new_y;
float new_width;
float new_height;
surface = wl_resource_get_user_data (resource);
if (!surface)
{
wl_resource_post_error (resource,
WP_VIEWPORT_ERROR_NO_SURFACE,
"wl_surface for this viewport no longer exists");
return;
}
new_x = wl_fixed_to_double (src_x);
new_y = wl_fixed_to_double (src_y);
new_width = wl_fixed_to_double (src_width);
new_height = wl_fixed_to_double (src_height);
if ((new_x >= 0 && new_y >= 0 &&
new_width > 0 && new_height > 0) ||
(new_x == -1 && new_y == -1 &&
new_width == -1 && new_height == -1))
{
surface->pending->viewport_src_rect.origin.x = new_x;
surface->pending->viewport_src_rect.origin.y = new_y;
surface->pending->viewport_src_rect.size.width = new_width;
surface->pending->viewport_src_rect.size.height = new_height;
surface->pending->has_new_viewport_src_rect = TRUE;
}
else
{
wl_resource_post_error (resource,
WP_VIEWPORT_ERROR_BAD_VALUE,
"x and y values must be zero or positive and "
"width and height valuest must be positive or "
"all values must be -1 to unset the viewport");
}
}
static void
params_add(struct wl_client *client,
struct wl_resource *params_resource,
int32_t name_fd,
uint32_t plane_idx,
uint32_t offset,
uint32_t stride,
uint32_t modifier_hi,
uint32_t modifier_lo)
{
struct linux_dmabuf_buffer *buffer;
buffer = wl_resource_get_user_data(params_resource);
if (!buffer) {
wl_resource_post_error(params_resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ALREADY_USED,
"params was already used to create a wl_buffer");
close(name_fd);
return;
}
assert(buffer->params_resource == params_resource);
assert(!buffer->buffer_resource);
if (plane_idx >= MAX_DMABUF_PLANES) {
wl_resource_post_error(params_resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX,
"plane index %u is too high", plane_idx);
close(name_fd);
return;
}
if (buffer->attributes.fd[plane_idx] != -1) {
wl_resource_post_error(params_resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET,
"a dmabuf has already been added for plane %u",
plane_idx);
close(name_fd);
return;
}
buffer->attributes.fd[plane_idx] = name_fd;
buffer->attributes.offset[plane_idx] = offset;
buffer->attributes.stride[plane_idx] = stride;
buffer->attributes.modifier[plane_idx] = ((uint64_t)modifier_hi << 32) |
modifier_lo;
buffer->attributes.n_planes++;
}
static void
get_shell_surface (struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource)
{
CoglandSurface *surface = wl_resource_get_user_data (surface_resource);
CoglandShellSurface *shell_surface;
if (surface->has_shell_surface)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"wl_shell::get_shell_surface already requested");
return;
}
shell_surface = g_new0 (CoglandShellSurface, 1);
shell_surface->surface = surface;
shell_surface->surface_destroy_listener.notify =
shell_handle_surface_destroy;
wl_signal_add (&surface->destroy_signal,
&shell_surface->surface_destroy_listener);
surface->has_shell_surface = TRUE;
shell_surface->resource = wl_client_add_object (client,
&wl_shell_surface_interface,
&cogl_shell_surface_interface,
id,
shell_surface);
wl_resource_set_destructor (shell_surface->resource,
destroy_shell_surface_cb);
}
static void
get_shell_surface (struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource)
{
CoglandSurface *surface = surface_resource->data;
CoglandShellSurface *shell_surface = g_new0 (CoglandShellSurface, 1);
if (surface->has_shell_surface)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"wl_shell::get_shell_surface already requested");
return;
}
shell_surface->resource.destroy = destroy_shell_surface;
shell_surface->resource.object.id = id;
shell_surface->resource.object.interface = &wl_shell_surface_interface;
shell_surface->resource.object.implementation =
(void (**) (void)) &cogl_shell_surface_interface;
shell_surface->resource.data = shell_surface;
shell_surface->surface = surface;
shell_surface->surface_destroy_listener.func = shell_handle_surface_destroy;
wl_list_insert (surface->wayland_surface.resource.destroy_listener_list.prev,
&shell_surface->surface_destroy_listener.link);
surface->has_shell_surface = TRUE;
wl_client_add_resource (client, &shell_surface->resource);
}
static void
drm_create_planar_buffer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id, uint32_t name,
int32_t width, int32_t height, uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
switch (format) {
case WL_DRM_FORMAT_YUV410:
case WL_DRM_FORMAT_YUV411:
case WL_DRM_FORMAT_YUV420:
case WL_DRM_FORMAT_YUV422:
case WL_DRM_FORMAT_YUV444:
case WL_DRM_FORMAT_NV12:
case WL_DRM_FORMAT_NV16:
break;
default:
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_FORMAT,
"invalid format");
return;
}
create_buffer(client, resource, id, name, -1, width, height, format,
offset0, stride0, offset1, stride1, offset2, stride2);
}
static void
create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, uint32_t name)
{
struct wl_gdl_buffer *buffer;
buffer = malloc(sizeof (*buffer));
if (!buffer) {
wl_resource_post_no_memory(resource);
return;
}
if (gdl_get_surface_info(name, &buffer->surface_info) != GDL_SUCCESS) {
wl_resource_post_error(resource, WL_GDL_ERROR_INVALID_NAME,
"invalid surface id %u", name);
free(buffer);
return;
}
buffer->resource =
wl_resource_create(client, &wl_buffer_interface, 1, id);
if (buffer->resource == NULL) {
wl_resource_post_no_memory(resource);
free(buffer);
return;
}
wl_resource_set_implementation(buffer->resource,
&gdl_buffer_interface,
buffer, destroy_buffer);
}
static void
bind_runner(struct wl_client *client, void *data,
uint32_t version, uint32_t id)
{
struct test_launcher *launcher = data;
struct wl_resource *resource;
resource = wl_resource_create(client, &weston_test_runner_interface,
1, id);
if (!resource) {
wl_client_post_no_memory(client);
return;
}
wl_resource_set_implementation(resource, &runner_implementation,
launcher, destroy_runner);
if (static_context.runner_resource != NULL) {
weston_log("test FATAL: "
"attempting to run several tests in parallel.\n");
wl_resource_post_error(resource,
WESTON_TEST_RUNNER_ERROR_TEST_FAILED,
"attempt to run parallel tests");
}
}
void PointerConstraintsUnstableV1Interface::Private::createConstraint(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *surface, wl_resource *pointer, wl_resource *region, uint32_t lifetime)
{
auto s = SurfaceInterface::get(surface);
auto p = PointerInterface::get(pointer);
if (!s || !p) {
// send error?
return;
}
if (!s->lockedPointer().isNull() || !s->confinedPointer().isNull()) {
wl_resource_post_error(s->resource(), ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED, "Surface already constrained");
return;
}
auto constraint = new T(q, resource);
switch (lifetime) {
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT:
constraint->d_func()->lifeTime = T::LifeTime::Persistent;
break;
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT: // fall through
default:
constraint->d_func()->lifeTime = T::LifeTime::OneShot;
break;
}
auto r = RegionInterface::get(region);
constraint->d_func()->region = r ? r->region() : QRegion();
constraint->d_func()->create(display->getConnection(client), version, id);
s->d_func()->installPointerConstraint(constraint);
}
static void
runner_run_handler(struct wl_client *client, struct wl_resource *resource,
const char *test_name)
{
struct test_launcher *launcher;
const struct runner_test *t;
assert(static_context.runner_resource == NULL ||
static_context.runner_resource == resource);
launcher = wl_resource_get_user_data(resource);
static_context.layout_interface = launcher->layout_interface;
static_context.runner_resource = resource;
t = find_runner_test(test_name);
if (!t) {
weston_log("Error: runner test \"%s\" not found.\n",
test_name);
wl_resource_post_error(resource,
WESTON_TEST_RUNNER_ERROR_UNKNOWN_TEST,
"weston_test_runner: unknown: '%s'",
test_name);
return;
}
weston_log("weston_test_runner.run(\"%s\")\n", test_name);
t->run(&static_context);
weston_test_runner_send_finished(resource);
}
static void
wp_viewporter_get_viewport (struct wl_client *client,
struct wl_resource *resource,
uint32_t viewport_id,
struct wl_resource *surface_resource)
{
MetaWaylandSurface *surface;
struct wl_resource *viewport_resource;
surface = wl_resource_get_user_data (surface_resource);
if (surface->viewport.resource)
{
wl_resource_post_error (resource,
WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS,
"viewport already exists on surface");
return;
}
viewport_resource = wl_resource_create (client,
&wp_viewport_interface,
wl_resource_get_version (resource),
viewport_id);
wl_resource_set_implementation (viewport_resource,
&meta_wayland_viewport_interface,
surface,
wp_viewport_destructor);
surface->viewport.resource = viewport_resource;
surface->viewport.destroy_handler_id =
g_signal_connect (surface,
"destroy",
G_CALLBACK (on_surface_destroyed),
NULL);
}
static void
xdg_shell_use_unstable_version (struct wl_client *client,
struct wl_resource *resource,
int32_t version)
{
if (version != XDG_SHELL_VERSION_CURRENT)
wl_resource_post_error (resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
"bad xdg-shell version: %d\n", version);
}
static void create_buffer(struct wl_client * client,
struct wl_resource * resource, uint32_t id,
uint32_t name, int32_t width, int32_t height,
uint32_t stride, uint32_t format)
{
wl_resource_post_error(resource, WL_DRM_ERROR_INVALID_NAME,
"GEM names are not supported, "
"use a PRIME fd instead");
}
void InputMethod::input_method_bind_resource(Resource *resource)
{
if (m_resource) {
wl_resource_post_error(resource->handle, WL_DISPLAY_ERROR_INVALID_OBJECT, "interface object already bound");
wl_resource_destroy(resource->handle);
return;
}
m_resource = resource;
}
static void
server_wlegl_create_buffer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
int32_t width,
int32_t height,
int32_t stride,
int32_t format,
int32_t usage,
struct wl_resource *hnd)
{
server_wlegl *wlegl = server_wlegl_from(resource);
server_wlegl_handle *handle = server_wlegl_handle_from(hnd);
server_wlegl_buffer *buffer;
buffer_handle_t native;
if (width < 1 || height < 1) {
wl_resource_post_error(resource,
ANDROID_WLEGL_ERROR_BAD_VALUE,
"bad width (%d) or height (%d)",
width, height);
return;
}
native = server_wlegl_handle_to_native(handle);
if (!native) {
wl_resource_post_error(resource,
ANDROID_WLEGL_ERROR_BAD_HANDLE,
"fd count mismatch");
return;
}
buffer = server_wlegl_buffer_create(client, id, width, height, stride,
format, usage, native, wlegl);
if (!buffer) {
native_handle_close((native_handle_t *)native);
native_handle_delete((native_handle_t *)native);
wl_resource_post_error(resource,
ANDROID_WLEGL_ERROR_BAD_HANDLE,
"invalid native handle");
return;
}
}
void PlasmaShellSurfaceInterface::Private::panelAutoHideShowCallback(wl_client *client, wl_resource *resource)
{
auto s = cast<Private>(resource);
Q_ASSERT(client == *s->client);
if (s->m_role != Role::Panel || s->m_panelBehavior != PanelBehavior::AutoHide) {
wl_resource_post_error(s->resource, ORG_KDE_PLASMA_SURFACE_ERROR_PANEL_NOT_AUTO_HIDE, "Not an auto hide panel");
return;
}
emit s->q_func()->panelAutoHideShowRequested();
}
static void
xdg_shell_get_xdg_surface (struct wl_client *client,
struct wl_resource *resource,
guint32 id,
struct wl_resource *surface_resource)
{
MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
MetaWaylandXdgSurface *xdg_surface;
MetaWindow *window;
if (META_IS_WAYLAND_XDG_SURFACE (surface->role) &&
META_WAYLAND_XDG_SURFACE (surface->role)->resource)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"xdg_shell::get_xdg_surface already requested");
return;
}
if (!meta_wayland_surface_assign_role (surface, META_TYPE_WAYLAND_XDG_SURFACE))
{
wl_resource_post_error (resource, XDG_SHELL_ERROR_ROLE,
"wl_surface@%d already has a different role",
wl_resource_get_id (surface->resource));
return;
}
xdg_surface = META_WAYLAND_XDG_SURFACE (surface->role);
xdg_surface->resource = wl_resource_create (client,
&xdg_surface_interface,
wl_resource_get_version (resource),
id);
wl_resource_set_implementation (xdg_surface->resource,
&meta_wayland_xdg_surface_interface,
xdg_surface,
xdg_surface_destructor);
xdg_surface->xdg_shell_resource = resource;
window = meta_window_wayland_new (meta_get_display (), surface);
meta_wayland_surface_set_window (surface, window);
}
static void create_planar_buffer(struct wl_client * client,
struct wl_resource * resource, uint32_t id,
uint32_t name, int32_t width, int32_t height,
uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
wl_resource_post_error(resource, WL_DRM_ERROR_INVALID_FORMAT,
"planar buffers are not supported\n");
}
static void
wl_shell_get_shell_surface (struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource)
{
MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
MetaWaylandWlShellSurface *wl_shell_surface;
if (META_IS_WAYLAND_WL_SHELL_SURFACE (surface->role) &&
META_WAYLAND_WL_SHELL_SURFACE (surface->role)->resource)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"wl_shell::get_shell_surface already requested");
return;
}
if (!meta_wayland_surface_assign_role (surface,
META_TYPE_WAYLAND_WL_SHELL_SURFACE,
NULL))
{
wl_resource_post_error (resource, WL_SHELL_ERROR_ROLE,
"wl_surface@%d already has a different role",
wl_resource_get_id (surface->resource));
return;
}
wl_shell_surface = META_WAYLAND_WL_SHELL_SURFACE (surface->role);
wl_shell_surface->resource =
wl_resource_create (client,
&wl_shell_surface_interface,
wl_resource_get_version (resource),
id);
wl_resource_set_implementation (wl_shell_surface->resource,
&meta_wayland_wl_shell_surface_interface,
wl_shell_surface,
wl_shell_surface_destructor);
create_wl_shell_surface_window (surface);
}
void setGamma(wl_client *c, wl_resource *res, wl_array *red, wl_array *green, wl_array *blue)
{
if (red->size != green->size || red->size != blue->size) {
wl_resource_post_error(res, GAMMA_CONTROL_ERROR_INVALID_GAMMA, "The gamma ramps don't have the same size");
return;
}
uint16_t *r = (uint16_t *)red->data;
uint16_t *g = (uint16_t *)green->data;
uint16_t *b = (uint16_t *)blue->data;
output->setGamma(red->size / sizeof(uint16_t), r, g, b);
}
static int
unversioned_dispatch(const void *implementation, void *target,
uint32_t opcode, const struct wl_message *message, union wl_argument *arguments)
{
struct wl_resource *resource = target;
if (opcode != 1) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
"use_unstable_version must be called first");
return 0;
}
if (arguments[0].i != XDG_SHELL_VERSION) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
"incompatible xdg_shell versions, server: %d, client: %d",
XDG_SHELL_VERSION, arguments[0].i);
return 0;
}
wl_resource_set_implementation(resource, &shell_implementation, NULL, NULL);
return 1;
}
static void
drm_authenticate(struct wl_client *client,
struct wl_resource *resource, uint32_t id)
{
struct wl_drm *drm = resource->data;
if (drm->callbacks->authenticate(drm->user_data, id) < 0)
wl_resource_post_error(resource,
WL_DRM_ERROR_AUTHENTICATE_FAIL,
"authenicate failed");
else
wl_resource_post_event(resource, WL_DRM_AUTHENTICATED);
}
static void
runner_assert_fail(const char *cond, const char *file, int line,
const char *func, struct test_context *ctx)
{
weston_log("Assert failure in %s:%d, %s: '%s'\n",
file, line, func, cond);
assert(ctx->runner_resource);
wl_resource_post_error(ctx->runner_resource,
WESTON_TEST_RUNNER_ERROR_TEST_FAILED,
"Assert failure in %s:%d, %s: '%s'\n",
file, line, func, cond);
}
static void
create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, uint32_t name, int fd,
int32_t width, int32_t height,
uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
struct wl_drm *drm = resource->data;
struct wl_drm_buffer *buffer;
buffer = calloc(1, sizeof *buffer);
if (buffer == NULL) {
wl_resource_post_no_memory(resource);
return;
}
buffer->drm = drm;
buffer->width = width;
buffer->height = height;
buffer->format = format;
buffer->offset[0] = offset0;
buffer->stride[0] = stride0;
buffer->offset[1] = offset1;
buffer->stride[1] = stride1;
buffer->offset[2] = offset2;
buffer->stride[2] = stride2;
drm->callbacks->reference_buffer(drm->user_data, name, fd, buffer);
if (buffer->driver_buffer == NULL) {
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_NAME,
"invalid name");
return;
}
buffer->resource =
wl_resource_create(client, &wl_buffer_interface, 1, id);
if (!buffer->resource) {
wl_resource_post_no_memory(resource);
free(buffer);
return;
}
wl_resource_set_implementation(buffer->resource,
(void (**)(void)) &drm_buffer_interface,
buffer, destroy_buffer);
}
static void create_buffer(struct wl_client * client,
struct wl_resource * resource, uint32_t id,
int32_t offset, int32_t width, int32_t height,
int32_t stride, uint32_t format)
{
struct pool * pool = wl_resource_get_user_data(resource);
struct pool_reference * reference;
struct wld_buffer * buffer;
struct wl_resource * buffer_resource;
union wld_object object;
if (offset > pool->size || offset < 0)
{
wl_resource_post_error(resource, WL_SHM_ERROR_INVALID_STRIDE,
"offset is too big or negative");
return;
}
object.ptr = (void *)((uintptr_t) pool->data + offset);
buffer = wld_import_buffer(swc.shm->context, WLD_OBJECT_DATA, object,
width, height, format_shm_to_wld(format),
stride);
if (!buffer)
goto error0;
buffer_resource = wayland_buffer_create_resource
(client, wl_resource_get_version(resource), id, buffer);
if (!buffer_resource)
goto error1;
if (!(reference = malloc(sizeof *reference)))
goto error2;
reference->pool = pool;
reference->destructor.destroy = &handle_buffer_destroy;
wld_buffer_add_destructor(buffer, &reference->destructor);
++pool->references;
return;
error2:
wl_resource_destroy(buffer_resource);
error1:
wld_buffer_unreference(buffer);
error0:
wl_resource_post_no_memory(resource);
}
static void
create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, uint32_t name, int fd,
int32_t width, int32_t height,
uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
struct wl_drm *drm = resource->data;
struct wl_drm_buffer *buffer;
buffer = calloc(1, sizeof *buffer);
if (buffer == NULL) {
wl_resource_post_no_memory(resource);
return;
}
buffer->drm = drm;
buffer->buffer.width = width;
buffer->buffer.height = height;
buffer->format = format;
buffer->offset[0] = offset0;
buffer->stride[0] = stride0;
buffer->offset[1] = offset1;
buffer->stride[1] = stride1;
buffer->offset[2] = offset2;
buffer->stride[2] = stride2;
drm->callbacks->reference_buffer(drm->user_data, name, fd, buffer);
if (buffer->driver_buffer == NULL) {
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_NAME,
"invalid name");
return;
}
buffer->buffer.resource.object.id = id;
buffer->buffer.resource.object.interface = &wl_buffer_interface;
buffer->buffer.resource.object.implementation =
(void (**)(void)) &drm_buffer_interface;
buffer->buffer.resource.data = buffer;
buffer->buffer.resource.destroy = destroy_buffer;
buffer->buffer.resource.client = resource->client;
wl_client_add_resource(resource->client, &buffer->buffer.resource);
}
ShellSurface *WlShell::getShellSurface(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *surface_resource)
{
weston_surface *surface = static_cast<weston_surface *>(wl_resource_get_user_data(surface_resource));
if (surface->configure) {
wl_resource_post_error(surface_resource, WL_DISPLAY_ERROR_INVALID_OBJECT, "The surface has a role already");
return nullptr;
}
ShellSurface *shsurf = m_shell->createShellSurface(surface);
WlShellSurface *wlss = new WlShellSurface(this, shsurf, client, id);
shsurf->addInterface(wlss);
// wlss->responsivenessChangedSignal.connect(this, &WlShell::surfaceResponsiveness);
//
return shsurf;
}
