2008-12-02 23:15:01 +03:00
|
|
|
/*
|
|
|
|
* Copyright © 2008 Kristian Høgsberg
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
|
|
* that the name of the copyright holders not be used in advertising or
|
|
|
|
* publicity pertaining to distribution of the software without specific,
|
|
|
|
* written prior permission. The copyright holders make no representations
|
|
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
|
|
* is" without express or implied warranty.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
|
|
* OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdio.h>
|
2008-11-29 03:12:45 +03:00
|
|
|
#include <stdarg.h>
|
2008-09-30 17:46:10 +04:00
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/un.h>
|
2008-11-06 18:38:17 +03:00
|
|
|
#include <dlfcn.h>
|
2008-11-29 03:12:45 +03:00
|
|
|
#include <assert.h>
|
2008-09-30 17:46:10 +04:00
|
|
|
#include <ffi.h>
|
2008-10-08 20:48:46 +04:00
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
#include "wayland.h"
|
2008-10-08 20:48:46 +04:00
|
|
|
#include "connection.h"
|
2008-09-30 17:46:10 +04:00
|
|
|
|
|
|
|
struct wl_client {
|
2008-10-08 20:48:46 +04:00
|
|
|
struct wl_connection *connection;
|
2008-09-30 17:46:10 +04:00
|
|
|
struct wl_event_source *source;
|
|
|
|
struct wl_display *display;
|
2008-10-12 05:37:55 +04:00
|
|
|
struct wl_list object_list;
|
2008-11-02 18:12:29 +03:00
|
|
|
struct wl_list link;
|
2008-11-29 01:06:06 +03:00
|
|
|
uint32_t pending_frame;
|
2008-09-30 17:46:10 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct wl_display {
|
|
|
|
struct wl_object base;
|
|
|
|
struct wl_event_loop *loop;
|
|
|
|
struct wl_hash objects;
|
2008-10-07 18:10:36 +04:00
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
struct wl_object *pointer;
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
struct wl_compositor *compositor;
|
|
|
|
struct wl_compositor_interface *compositor_interface;
|
2008-10-12 02:40:23 +04:00
|
|
|
|
|
|
|
struct wl_list surface_list;
|
2008-11-02 18:12:29 +03:00
|
|
|
struct wl_list client_list;
|
2008-10-12 02:40:23 +04:00
|
|
|
uint32_t client_id_range;
|
2008-11-24 07:41:08 +03:00
|
|
|
uint32_t id;
|
2008-11-02 18:12:29 +03:00
|
|
|
|
2008-11-24 03:10:23 +03:00
|
|
|
struct wl_list global_list;
|
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
int32_t pointer_x;
|
|
|
|
int32_t pointer_y;
|
2008-09-30 17:46:10 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct wl_surface {
|
|
|
|
struct wl_object base;
|
|
|
|
|
|
|
|
/* provided by client */
|
|
|
|
int width, height;
|
|
|
|
int buffer;
|
|
|
|
int stride;
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
struct wl_map map;
|
2008-10-12 02:40:23 +04:00
|
|
|
struct wl_list link;
|
2008-09-30 17:46:10 +04:00
|
|
|
|
|
|
|
/* how to convert buffer contents to pixels in screen format;
|
|
|
|
* yuv->rgb, indexed->rgb, svg->rgb, but mostly just rgb->rgb. */
|
|
|
|
|
|
|
|
/* how to transform/render rectangular contents to polygons. */
|
2008-10-07 18:10:36 +04:00
|
|
|
|
|
|
|
void *compositor_data;
|
2008-09-30 17:46:10 +04:00
|
|
|
};
|
|
|
|
|
2008-10-12 05:37:55 +04:00
|
|
|
struct wl_object_ref {
|
|
|
|
struct wl_object *object;
|
|
|
|
struct wl_list link;
|
|
|
|
};
|
2008-10-07 18:10:36 +04:00
|
|
|
|
|
|
|
static void
|
|
|
|
wl_surface_destroy(struct wl_client *client,
|
|
|
|
struct wl_surface *surface)
|
|
|
|
{
|
2008-11-06 18:38:17 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-10-07 18:10:36 +04:00
|
|
|
|
|
|
|
interface = client->display->compositor->interface;
|
2008-10-12 02:40:23 +04:00
|
|
|
interface->notify_surface_destroy(client->display->compositor,
|
|
|
|
surface);
|
|
|
|
wl_list_remove(&surface->link);
|
2008-10-07 18:10:36 +04:00
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
static void
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_surface_attach(struct wl_client *client,
|
|
|
|
struct wl_surface *surface, uint32_t name,
|
|
|
|
uint32_t width, uint32_t height, uint32_t stride)
|
2008-09-30 17:46:10 +04:00
|
|
|
{
|
2008-11-06 18:38:17 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-09-30 17:46:10 +04:00
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
interface = client->display->compositor->interface;
|
|
|
|
interface->notify_surface_attach(client->display->compositor,
|
|
|
|
surface, name, width, height, stride);
|
2008-09-30 17:46:10 +04:00
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static void
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_surface_map(struct wl_client *client, struct wl_surface *surface,
|
|
|
|
int32_t x, int32_t y, int32_t width, int32_t height)
|
2008-09-30 17:46:10 +04:00
|
|
|
{
|
2008-11-06 18:38:17 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-10-07 18:10:36 +04:00
|
|
|
|
|
|
|
/* FIXME: This needs to take a tri-mesh argument... - count
|
|
|
|
* and a list of tris. 0 tris means unmap. */
|
|
|
|
|
|
|
|
surface->map.x = x;
|
|
|
|
surface->map.y = y;
|
|
|
|
surface->map.width = width;
|
|
|
|
surface->map.height = height;
|
|
|
|
|
|
|
|
interface = client->display->compositor->interface;
|
|
|
|
interface->notify_surface_map(client->display->compositor,
|
|
|
|
surface, &surface->map);
|
2008-09-30 17:46:10 +04:00
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static void
|
2008-11-07 16:39:37 +03:00
|
|
|
wl_surface_copy(struct wl_client *client, struct wl_surface *surface,
|
|
|
|
int32_t dst_x, int32_t dst_y, uint32_t name, uint32_t stride,
|
|
|
|
int32_t x, int32_t y, int32_t width, int32_t height)
|
|
|
|
{
|
|
|
|
const struct wl_compositor_interface *interface;
|
|
|
|
|
|
|
|
interface = client->display->compositor->interface;
|
|
|
|
interface->notify_surface_copy(client->display->compositor,
|
|
|
|
surface, dst_x, dst_y,
|
|
|
|
name, stride, x, y, width, height);
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static void
|
2008-11-07 16:39:37 +03:00
|
|
|
wl_surface_damage(struct wl_client *client, struct wl_surface *surface,
|
|
|
|
int32_t x, int32_t y, int32_t width, int32_t height)
|
|
|
|
{
|
|
|
|
const struct wl_compositor_interface *interface;
|
|
|
|
|
|
|
|
interface = client->display->compositor->interface;
|
|
|
|
interface->notify_surface_damage(client->display->compositor,
|
|
|
|
surface, x, y, width, height);
|
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
static const struct wl_method surface_methods[] = {
|
2008-12-05 18:38:42 +03:00
|
|
|
{ "destroy", wl_surface_destroy, "" },
|
|
|
|
{ "attach", wl_surface_attach, "uuuu" },
|
|
|
|
{ "map", wl_surface_map, "iiii" },
|
|
|
|
{ "copy", wl_surface_copy, "iiuuiiii" },
|
|
|
|
{ "damage", wl_surface_damage, "iiii" }
|
2008-09-30 17:46:10 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct wl_interface surface_interface = {
|
|
|
|
"surface", 1,
|
|
|
|
ARRAY_LENGTH(surface_methods),
|
|
|
|
surface_methods,
|
|
|
|
};
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static struct wl_surface *
|
2008-09-30 17:46:10 +04:00
|
|
|
wl_surface_create(struct wl_display *display, uint32_t id)
|
|
|
|
{
|
|
|
|
struct wl_surface *surface;
|
2008-11-06 18:38:17 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-09-30 17:46:10 +04:00
|
|
|
|
|
|
|
surface = malloc(sizeof *surface);
|
|
|
|
if (surface == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
surface->base.id = id;
|
|
|
|
surface->base.interface = &surface_interface;
|
|
|
|
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_list_insert(display->surface_list.prev, &surface->link);
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
interface = display->compositor->interface;
|
|
|
|
interface->notify_surface_create(display->compositor, surface);
|
2008-09-30 17:46:10 +04:00
|
|
|
|
|
|
|
return surface;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT void
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_surface_set_data(struct wl_surface *surface, void *data)
|
|
|
|
{
|
|
|
|
surface->compositor_data = data;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT void *
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_surface_get_data(struct wl_surface *surface)
|
|
|
|
{
|
|
|
|
return surface->compositor_data;
|
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
void
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_client_destroy(struct wl_client *client);
|
2008-10-08 18:47:59 +04:00
|
|
|
|
2008-11-29 03:12:45 +03:00
|
|
|
static void
|
|
|
|
wl_client_marshal(struct wl_client *client, struct wl_object *sender,
|
|
|
|
uint32_t opcode, ...)
|
|
|
|
{
|
|
|
|
const struct wl_event *event;
|
|
|
|
struct wl_object *object;
|
2008-12-05 18:38:42 +03:00
|
|
|
uint32_t args[10], size;
|
2008-11-29 03:12:45 +03:00
|
|
|
va_list ap;
|
2008-12-05 18:38:42 +03:00
|
|
|
int i, count;
|
2008-11-29 03:12:45 +03:00
|
|
|
|
|
|
|
event = &sender->interface->events[opcode];
|
2008-12-05 18:38:42 +03:00
|
|
|
count = strlen(event->signature) + 2;
|
|
|
|
assert(count <= ARRAY_LENGTH(args));
|
|
|
|
|
2008-11-29 03:12:45 +03:00
|
|
|
size = 0;
|
|
|
|
va_start(ap, opcode);
|
2008-12-05 18:38:42 +03:00
|
|
|
for (i = 2; i < count; i++) {
|
|
|
|
switch (event->signature[i - 2]) {
|
|
|
|
case 'u':
|
|
|
|
case 'i':
|
|
|
|
args[i] = va_arg(ap, uint32_t);
|
|
|
|
size += sizeof args[i];
|
2008-11-29 03:12:45 +03:00
|
|
|
break;
|
2008-12-05 18:38:42 +03:00
|
|
|
case 's':
|
2008-11-29 03:12:45 +03:00
|
|
|
/* FIXME */
|
2008-12-05 18:38:42 +03:00
|
|
|
args[i] = 0;
|
|
|
|
size += sizeof args[i];
|
2008-11-29 03:12:45 +03:00
|
|
|
break;
|
2008-12-05 18:38:42 +03:00
|
|
|
case 'o':
|
2008-11-29 03:12:45 +03:00
|
|
|
object = va_arg(ap, struct wl_object *);
|
2008-12-05 18:38:42 +03:00
|
|
|
args[i] = object->id;
|
|
|
|
size += sizeof args[i];
|
2008-11-29 03:12:45 +03:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
size += 2 * sizeof args[0];
|
|
|
|
args[0] = sender->id;
|
|
|
|
args[1] = opcode | (size << 16);
|
|
|
|
wl_connection_write(client->connection, args, size);
|
|
|
|
}
|
|
|
|
|
2008-10-08 18:47:59 +04:00
|
|
|
static void
|
|
|
|
wl_client_demarshal(struct wl_client *client, struct wl_object *target,
|
|
|
|
const struct wl_method *method, size_t size)
|
2008-09-30 17:46:10 +04:00
|
|
|
{
|
2008-11-07 16:39:37 +03:00
|
|
|
ffi_type *types[20];
|
2008-09-30 17:46:10 +04:00
|
|
|
ffi_cif cif;
|
|
|
|
uint32_t *p, result;
|
2008-12-05 18:38:42 +03:00
|
|
|
int i, j, count;
|
2008-09-30 17:46:10 +04:00
|
|
|
union {
|
|
|
|
uint32_t uint32;
|
|
|
|
const char *string;
|
|
|
|
void *object;
|
|
|
|
uint32_t new_id;
|
2008-11-07 16:39:37 +03:00
|
|
|
} values[20];
|
|
|
|
void *args[20];
|
2008-09-30 17:46:10 +04:00
|
|
|
struct wl_object *object;
|
2008-10-08 18:47:59 +04:00
|
|
|
uint32_t data[64];
|
2008-09-30 17:46:10 +04:00
|
|
|
|
2008-12-05 18:38:42 +03:00
|
|
|
count = strlen(method->signature) + 2;
|
|
|
|
if (count > ARRAY_LENGTH(types)) {
|
|
|
|
printf("too many args (%d)\n", count);
|
2008-09-30 17:46:10 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-08 18:47:59 +04:00
|
|
|
if (sizeof data < size) {
|
|
|
|
printf("request too big, should malloc tmp buffer here\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
types[0] = &ffi_type_pointer;
|
|
|
|
values[0].object = client;
|
|
|
|
args[0] = &values[0];
|
|
|
|
|
|
|
|
types[1] = &ffi_type_pointer;
|
|
|
|
values[1].object = target;
|
|
|
|
args[1] = &values[1];
|
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_copy(client->connection, data, size);
|
2008-10-08 18:47:59 +04:00
|
|
|
p = &data[2];
|
2008-12-05 18:38:42 +03:00
|
|
|
j = 0;
|
|
|
|
for (i = 2; i < count; i++) {
|
|
|
|
switch (method->signature[i - 2]) {
|
|
|
|
case 'u':
|
|
|
|
case 'i':
|
|
|
|
types[i] = &ffi_type_uint32;
|
|
|
|
values[i].uint32 = *p;
|
2008-09-30 17:46:10 +04:00
|
|
|
p++;
|
|
|
|
break;
|
2008-12-05 18:38:42 +03:00
|
|
|
case 's':
|
|
|
|
types[i] = &ffi_type_pointer;
|
2008-09-30 17:46:10 +04:00
|
|
|
/* FIXME */
|
2008-12-05 18:38:42 +03:00
|
|
|
values[i].uint32 = *p++;
|
2008-09-30 17:46:10 +04:00
|
|
|
break;
|
2008-12-05 18:38:42 +03:00
|
|
|
case 'o':
|
|
|
|
types[i] = &ffi_type_pointer;
|
2008-09-30 17:46:10 +04:00
|
|
|
object = wl_hash_lookup(&client->display->objects, *p);
|
|
|
|
if (object == NULL)
|
|
|
|
printf("unknown object (%d)\n", *p);
|
2008-12-05 18:38:42 +03:00
|
|
|
if (object->interface != method->types[j])
|
2008-09-30 17:46:10 +04:00
|
|
|
printf("wrong object type\n");
|
2008-12-05 18:38:42 +03:00
|
|
|
values[i].object = object;
|
2008-09-30 17:46:10 +04:00
|
|
|
p++;
|
2008-12-05 18:38:42 +03:00
|
|
|
j++;
|
2008-09-30 17:46:10 +04:00
|
|
|
break;
|
2008-12-05 18:38:42 +03:00
|
|
|
case 'n':
|
|
|
|
types[i] = &ffi_type_uint32;
|
|
|
|
values[i].new_id = *p;
|
2008-09-30 17:46:10 +04:00
|
|
|
object = wl_hash_lookup(&client->display->objects, *p);
|
|
|
|
if (object != NULL)
|
|
|
|
printf("object already exists (%d)\n", *p);
|
|
|
|
p++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("unknown type\n");
|
|
|
|
break;
|
|
|
|
}
|
2008-12-05 18:38:42 +03:00
|
|
|
args[i] = &values[i];
|
2008-09-30 17:46:10 +04:00
|
|
|
}
|
|
|
|
|
2008-12-05 18:38:42 +03:00
|
|
|
ffi_prep_cif(&cif, FFI_DEFAULT_ABI, count, &ffi_type_uint32, types);
|
2008-09-30 17:46:10 +04:00
|
|
|
ffi_call(&cif, FFI_FN(method->func), &result, args);
|
|
|
|
}
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
#define WL_DISPLAY_INVALID_OBJECT 0
|
|
|
|
#define WL_DISPLAY_INVALID_METHOD 1
|
2008-10-12 05:37:55 +04:00
|
|
|
#define WL_DISPLAY_NO_MEMORY 2
|
2008-11-26 06:40:39 +03:00
|
|
|
#define WL_DISPLAY_ACKNOWLEDGE 3
|
2008-11-29 01:06:06 +03:00
|
|
|
#define WL_DISPLAY_FRAME 4
|
2008-10-07 18:10:36 +04:00
|
|
|
|
|
|
|
static void
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_client_connection_data(int fd, uint32_t mask, void *data)
|
2008-10-07 18:10:36 +04:00
|
|
|
{
|
2008-10-08 20:48:46 +04:00
|
|
|
struct wl_client *client = data;
|
|
|
|
struct wl_connection *connection = client->connection;
|
2008-10-07 18:10:36 +04:00
|
|
|
const struct wl_method *method;
|
|
|
|
struct wl_object *object;
|
2008-10-08 20:48:46 +04:00
|
|
|
uint32_t p[2], opcode, size;
|
|
|
|
uint32_t cmask = 0;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (mask & WL_EVENT_READABLE)
|
|
|
|
cmask |= WL_CONNECTION_READABLE;
|
|
|
|
if (mask & WL_EVENT_WRITEABLE)
|
|
|
|
cmask |= WL_CONNECTION_WRITABLE;
|
|
|
|
|
|
|
|
len = wl_connection_data(connection, cmask);
|
|
|
|
if (len < 0) {
|
|
|
|
wl_client_destroy(client);
|
|
|
|
return;
|
|
|
|
}
|
2008-10-08 18:47:59 +04:00
|
|
|
|
2008-11-24 07:41:08 +03:00
|
|
|
while (len >= sizeof p) {
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_copy(connection, p, sizeof p);
|
2008-10-07 18:10:36 +04:00
|
|
|
opcode = p[1] & 0xffff;
|
|
|
|
size = p[1] >> 16;
|
2008-10-08 20:48:46 +04:00
|
|
|
if (len < size)
|
2008-10-07 18:10:36 +04:00
|
|
|
break;
|
|
|
|
|
2008-11-29 03:12:45 +03:00
|
|
|
object = wl_hash_lookup(&client->display->objects, p[0]);
|
2008-10-07 18:10:36 +04:00
|
|
|
if (object == NULL) {
|
2008-11-29 03:12:45 +03:00
|
|
|
wl_client_marshal(client, &client->display->base,
|
|
|
|
WL_DISPLAY_INVALID_OBJECT, p[0]);
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_consume(connection, size);
|
|
|
|
len -= size;
|
2008-10-07 18:10:36 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opcode >= object->interface->method_count) {
|
2008-11-29 03:12:45 +03:00
|
|
|
wl_client_marshal(client, &client->display->base,
|
|
|
|
WL_DISPLAY_INVALID_METHOD, p[0], opcode);
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_consume(connection, size);
|
|
|
|
len -= size;
|
2008-10-07 18:10:36 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
method = &object->interface->methods[opcode];
|
2008-10-08 18:47:59 +04:00
|
|
|
wl_client_demarshal(client, object, method, size);
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_consume(connection, size);
|
|
|
|
len -= size;
|
2008-10-07 18:10:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
static int
|
|
|
|
wl_client_connection_update(struct wl_connection *connection,
|
|
|
|
uint32_t mask, void *data)
|
2008-09-30 17:46:10 +04:00
|
|
|
{
|
|
|
|
struct wl_client *client = data;
|
2008-10-08 20:48:46 +04:00
|
|
|
uint32_t emask = 0;
|
2008-10-08 18:47:59 +04:00
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
if (mask & WL_CONNECTION_READABLE)
|
|
|
|
emask |= WL_EVENT_READABLE;
|
|
|
|
if (mask & WL_CONNECTION_WRITABLE)
|
|
|
|
emask |= WL_EVENT_WRITEABLE;
|
2008-09-30 17:46:10 +04:00
|
|
|
|
2008-11-29 02:35:25 +03:00
|
|
|
return wl_event_source_fd_update(client->source, mask);
|
2008-10-08 20:48:46 +04:00
|
|
|
}
|
2008-10-08 18:47:59 +04:00
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
static void
|
|
|
|
advertise_object(struct wl_client *client, struct wl_object *object)
|
|
|
|
{
|
|
|
|
const struct wl_interface *interface;
|
|
|
|
static const char pad[4];
|
|
|
|
uint32_t length, p[2];
|
2008-10-07 18:10:36 +04:00
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
interface = object->interface;
|
|
|
|
length = strlen(interface->name);
|
|
|
|
p[0] = object->id;
|
|
|
|
p[1] = length;
|
|
|
|
wl_connection_write(client->connection, p, sizeof p);
|
|
|
|
wl_connection_write(client->connection, interface->name, length);
|
|
|
|
wl_connection_write(client->connection, pad, -length & 3);
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static struct wl_client *
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_client_create(struct wl_display *display, int fd)
|
|
|
|
{
|
|
|
|
struct wl_client *client;
|
2008-11-24 03:10:23 +03:00
|
|
|
struct wl_object_ref *ref;
|
2008-11-24 07:41:08 +03:00
|
|
|
uint32_t count;
|
2008-10-08 20:48:46 +04:00
|
|
|
|
|
|
|
client = malloc(sizeof *client);
|
|
|
|
if (client == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
memset(client, 0, sizeof *client);
|
|
|
|
client->display = display;
|
|
|
|
client->source = wl_event_loop_add_fd(display->loop, fd,
|
|
|
|
WL_EVENT_READABLE,
|
|
|
|
wl_client_connection_data, client);
|
|
|
|
client->connection = wl_connection_create(fd,
|
|
|
|
wl_client_connection_update,
|
|
|
|
client);
|
2008-10-12 05:37:55 +04:00
|
|
|
wl_list_init(&client->object_list);
|
2008-10-08 20:48:46 +04:00
|
|
|
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_connection_write(client->connection,
|
|
|
|
&display->client_id_range,
|
|
|
|
sizeof display->client_id_range);
|
|
|
|
display->client_id_range += 256;
|
|
|
|
|
2008-11-24 07:41:08 +03:00
|
|
|
/* Write list of global objects to client. */
|
|
|
|
count = wl_list_length(&display->global_list);
|
|
|
|
wl_connection_write(client->connection, &count, sizeof count);
|
|
|
|
|
2008-11-24 03:10:23 +03:00
|
|
|
ref = container_of(display->global_list.next,
|
|
|
|
struct wl_object_ref, link);
|
|
|
|
while (&ref->link != &display->global_list) {
|
|
|
|
advertise_object(client, ref->object);
|
|
|
|
|
|
|
|
ref = container_of(ref->link.next,
|
|
|
|
struct wl_object_ref, link);
|
|
|
|
}
|
2008-10-08 20:48:46 +04:00
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_list_insert(display->client_list.prev, &client->link);
|
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
return client;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
wl_client_destroy(struct wl_client *client)
|
|
|
|
{
|
2008-10-12 05:37:55 +04:00
|
|
|
struct wl_object_ref *ref;
|
|
|
|
|
2008-10-08 20:48:46 +04:00
|
|
|
printf("disconnect from client %p\n", client);
|
2008-10-12 05:37:55 +04:00
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_list_remove(&client->link);
|
|
|
|
|
2008-10-12 05:37:55 +04:00
|
|
|
while (client->object_list.next != &client->object_list) {
|
|
|
|
ref = container_of(client->object_list.next,
|
|
|
|
struct wl_object_ref, link);
|
|
|
|
wl_list_remove(&ref->link);
|
|
|
|
wl_surface_destroy(client, (struct wl_surface *) ref->object);
|
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
|
2008-11-29 02:35:25 +03:00
|
|
|
wl_event_source_remove(client->source);
|
2008-10-08 20:48:46 +04:00
|
|
|
wl_connection_destroy(client->connection);
|
|
|
|
free(client);
|
2008-09-30 17:46:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
wl_display_create_surface(struct wl_client *client,
|
|
|
|
struct wl_display *display, uint32_t id)
|
|
|
|
{
|
|
|
|
struct wl_surface *surface;
|
2008-10-12 05:37:55 +04:00
|
|
|
struct wl_object_ref *ref;
|
2008-09-30 17:46:10 +04:00
|
|
|
|
|
|
|
surface = wl_surface_create(display, id);
|
|
|
|
|
2008-10-12 05:37:55 +04:00
|
|
|
ref = malloc(sizeof *ref);
|
|
|
|
if (ref == NULL) {
|
2008-11-29 03:12:45 +03:00
|
|
|
wl_client_marshal(client, &display->base,
|
|
|
|
WL_DISPLAY_NO_MEMORY);
|
2008-10-12 05:37:55 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ref->object = &surface->base;
|
|
|
|
wl_hash_insert(&display->objects, &surface->base);
|
|
|
|
wl_list_insert(client->object_list.prev, &ref->link);
|
2008-10-07 18:10:36 +04:00
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-26 06:40:39 +03:00
|
|
|
static int
|
|
|
|
wl_display_commit(struct wl_client *client,
|
|
|
|
struct wl_display *display, uint32_t key)
|
|
|
|
{
|
2008-11-29 01:06:06 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-11-29 03:12:45 +03:00
|
|
|
uint32_t frame;
|
2008-11-29 01:06:06 +03:00
|
|
|
|
|
|
|
client->pending_frame = 1;
|
|
|
|
|
|
|
|
interface = display->compositor->interface;
|
|
|
|
frame = interface->notify_commit(display->compositor);
|
2008-11-29 03:12:45 +03:00
|
|
|
wl_client_marshal(client, &display->base,
|
|
|
|
WL_DISPLAY_ACKNOWLEDGE, key, frame);
|
2008-11-26 06:40:39 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
static const struct wl_method display_methods[] = {
|
2008-12-05 18:38:42 +03:00
|
|
|
{ "create_surface", wl_display_create_surface, "n" },
|
|
|
|
{ "commit", wl_display_commit, "u" }
|
2008-11-29 03:12:45 +03:00
|
|
|
};
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
static const struct wl_event display_events[] = {
|
2008-12-05 18:38:42 +03:00
|
|
|
{ "invalid_object", "u" },
|
|
|
|
{ "invalid_method", "uu" },
|
|
|
|
{ "no_memory", "" },
|
|
|
|
{ "acknowledge", "uu" },
|
|
|
|
{ "frame", "uu" }
|
2008-10-07 18:10:36 +04:00
|
|
|
};
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
static const struct wl_interface display_interface = {
|
2008-10-07 18:10:36 +04:00
|
|
|
"display", 1,
|
|
|
|
ARRAY_LENGTH(display_methods), display_methods,
|
|
|
|
ARRAY_LENGTH(display_events), display_events,
|
2008-09-30 17:46:10 +04:00
|
|
|
};
|
|
|
|
|
2008-12-05 19:13:50 +03:00
|
|
|
WL_EXPORT struct wl_display *
|
2008-09-30 17:46:10 +04:00
|
|
|
wl_display_create(void)
|
|
|
|
{
|
|
|
|
struct wl_display *display;
|
|
|
|
|
|
|
|
display = malloc(sizeof *display);
|
|
|
|
if (display == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
display->loop = wl_event_loop_create();
|
|
|
|
if (display->loop == NULL) {
|
|
|
|
free(display);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_list_init(&display->surface_list);
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_list_init(&display->client_list);
|
2008-11-24 03:10:23 +03:00
|
|
|
wl_list_init(&display->global_list);
|
2008-11-02 18:12:29 +03:00
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
display->pointer_x = 100;
|
|
|
|
display->pointer_y = 100;
|
2008-10-12 02:40:23 +04:00
|
|
|
|
|
|
|
display->client_id_range = 256; /* Gah, arbitrary... */
|
2008-09-30 17:46:10 +04:00
|
|
|
|
2008-11-24 07:41:08 +03:00
|
|
|
display->id = 1;
|
|
|
|
display->base.interface = &display_interface;
|
|
|
|
wl_display_add_object(display, &display->base);
|
2008-11-24 03:10:23 +03:00
|
|
|
if (wl_display_add_global(display, &display->base)) {
|
|
|
|
wl_event_loop_destroy(display->loop);
|
|
|
|
free(display);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-30 17:46:10 +04:00
|
|
|
return display;
|
|
|
|
}
|
|
|
|
|
2008-11-24 07:41:08 +03:00
|
|
|
WL_EXPORT void
|
|
|
|
wl_display_add_object(struct wl_display *display, struct wl_object *object)
|
|
|
|
{
|
|
|
|
object->id = display->id++;
|
|
|
|
wl_hash_insert(&display->objects, object);
|
|
|
|
}
|
|
|
|
|
2008-11-24 03:10:23 +03:00
|
|
|
WL_EXPORT int
|
|
|
|
wl_display_add_global(struct wl_display *display, struct wl_object *object)
|
|
|
|
{
|
|
|
|
struct wl_object_ref *ref;
|
|
|
|
|
|
|
|
ref = malloc(sizeof *ref);
|
|
|
|
if (ref == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ref->object = object;
|
|
|
|
wl_list_insert(display->global_list.prev, &ref->link);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
static void
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_display_send_event(struct wl_display *display, uint32_t *data, size_t size)
|
|
|
|
{
|
|
|
|
struct wl_client *client;
|
|
|
|
|
|
|
|
client = container_of(display->client_list.next,
|
|
|
|
struct wl_client, link);
|
|
|
|
while (&client->link != &display->client_list) {
|
|
|
|
wl_connection_write(client->connection, data, size);
|
|
|
|
|
|
|
|
client = container_of(client->link.next,
|
|
|
|
struct wl_client, link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
#define WL_INPUT_MOTION 0
|
|
|
|
#define WL_INPUT_BUTTON 1
|
|
|
|
#define WL_INPUT_KEY 2
|
2008-11-02 18:12:29 +03:00
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
WL_EXPORT void
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_display_post_relative_event(struct wl_display *display,
|
|
|
|
struct wl_object *source, int dx, int dy)
|
|
|
|
{
|
2008-11-22 03:25:44 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-11-02 18:12:29 +03:00
|
|
|
uint32_t p[4];
|
|
|
|
|
|
|
|
display->pointer_x += dx;
|
|
|
|
display->pointer_y += dy;
|
|
|
|
|
2008-11-22 03:25:44 +03:00
|
|
|
interface = display->compositor->interface;
|
|
|
|
interface->notify_pointer_motion(display->compositor, source,
|
|
|
|
display->pointer_x, display->pointer_y);
|
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
p[0] = source->id;
|
2008-11-24 08:31:49 +03:00
|
|
|
p[1] = (sizeof p << 16) | WL_INPUT_MOTION;
|
2008-11-02 18:12:29 +03:00
|
|
|
p[2] = display->pointer_x;
|
|
|
|
p[3] = display->pointer_y;
|
|
|
|
|
|
|
|
wl_display_send_event(display, p, sizeof p);
|
|
|
|
}
|
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
WL_EXPORT void
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_display_post_absolute_event(struct wl_display *display,
|
|
|
|
struct wl_object *source, int x, int y)
|
|
|
|
{
|
2008-11-22 03:25:44 +03:00
|
|
|
const struct wl_compositor_interface *interface;
|
2008-11-02 18:12:29 +03:00
|
|
|
uint32_t p[4];
|
|
|
|
|
|
|
|
display->pointer_x = x;
|
|
|
|
display->pointer_y = y;
|
|
|
|
|
2008-11-22 03:25:44 +03:00
|
|
|
interface = display->compositor->interface;
|
|
|
|
interface->notify_pointer_motion(display->compositor, source,
|
|
|
|
display->pointer_x, display->pointer_y);
|
|
|
|
|
2008-11-02 18:12:29 +03:00
|
|
|
p[0] = source->id;
|
2008-11-24 08:31:49 +03:00
|
|
|
p[1] = (sizeof p << 16) | WL_INPUT_MOTION;
|
2008-11-02 18:12:29 +03:00
|
|
|
p[2] = display->pointer_x;
|
|
|
|
p[3] = display->pointer_y;
|
|
|
|
|
|
|
|
wl_display_send_event(display, p, sizeof p);
|
|
|
|
}
|
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
WL_EXPORT void
|
2008-11-02 18:12:29 +03:00
|
|
|
wl_display_post_button_event(struct wl_display *display,
|
|
|
|
struct wl_object *source, int button, int state)
|
|
|
|
{
|
|
|
|
uint32_t p[4];
|
|
|
|
|
|
|
|
p[0] = source->id;
|
2008-11-24 08:31:49 +03:00
|
|
|
p[1] = (sizeof p << 16) | WL_INPUT_BUTTON;
|
2008-11-02 18:12:29 +03:00
|
|
|
p[2] = button;
|
|
|
|
p[3] = state;
|
|
|
|
|
|
|
|
wl_display_send_event(display, p, sizeof p);
|
|
|
|
}
|
|
|
|
|
2008-11-24 08:31:49 +03:00
|
|
|
WL_EXPORT void
|
|
|
|
wl_display_post_key_event(struct wl_display *display,
|
|
|
|
struct wl_object *source, int key, int state)
|
|
|
|
{
|
|
|
|
const struct wl_compositor_interface *interface;
|
|
|
|
uint32_t p[4];
|
|
|
|
|
|
|
|
interface = display->compositor->interface;
|
|
|
|
interface->notify_key(display->compositor, source, key, state);
|
|
|
|
|
|
|
|
p[0] = source->id;
|
|
|
|
p[1] = (sizeof p << 16) | WL_INPUT_KEY;
|
|
|
|
p[2] = key;
|
|
|
|
p[3] = state;
|
|
|
|
|
|
|
|
wl_display_send_event(display, p, sizeof p);
|
|
|
|
}
|
|
|
|
|
2008-11-26 20:57:31 +03:00
|
|
|
WL_EXPORT void
|
2008-11-29 01:06:06 +03:00
|
|
|
wl_display_post_frame(struct wl_display *display,
|
|
|
|
uint32_t frame, uint32_t msecs)
|
2008-11-26 20:57:31 +03:00
|
|
|
{
|
|
|
|
struct wl_client *client;
|
|
|
|
|
|
|
|
client = container_of(display->client_list.next,
|
|
|
|
struct wl_client, link);
|
|
|
|
|
|
|
|
while (&client->link != &display->client_list) {
|
2008-11-29 01:06:06 +03:00
|
|
|
if (client->pending_frame) {
|
2008-11-29 03:12:45 +03:00
|
|
|
wl_client_marshal(client, &display->base,
|
|
|
|
WL_DISPLAY_FRAME, frame, msecs);
|
2008-11-29 01:06:06 +03:00
|
|
|
client->pending_frame = 0;
|
2008-11-26 20:57:31 +03:00
|
|
|
}
|
|
|
|
client = container_of(client->link.next,
|
|
|
|
struct wl_client, link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-05 19:13:50 +03:00
|
|
|
WL_EXPORT void
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_display_set_compositor(struct wl_display *display,
|
|
|
|
struct wl_compositor *compositor)
|
|
|
|
{
|
|
|
|
display->compositor = compositor;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT struct wl_event_loop *
|
2008-10-12 03:21:35 +04:00
|
|
|
wl_display_get_event_loop(struct wl_display *display)
|
|
|
|
{
|
|
|
|
return display->loop;
|
|
|
|
}
|
|
|
|
|
2008-12-05 19:13:50 +03:00
|
|
|
WL_EXPORT void
|
2008-09-30 17:46:10 +04:00
|
|
|
wl_display_run(struct wl_display *display)
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
wl_event_loop_wait(display->loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
socket_data(int fd, uint32_t mask, void *data)
|
|
|
|
{
|
|
|
|
struct wl_display *display = data;
|
|
|
|
struct sockaddr_un name;
|
|
|
|
socklen_t length;
|
|
|
|
int client_fd;
|
|
|
|
|
|
|
|
length = sizeof name;
|
|
|
|
client_fd = accept (fd, (struct sockaddr *) &name, &length);
|
|
|
|
if (client_fd < 0)
|
|
|
|
fprintf(stderr, "failed to accept\n");
|
|
|
|
|
|
|
|
wl_client_create(display, client_fd);
|
|
|
|
}
|
|
|
|
|
2008-12-05 19:13:50 +03:00
|
|
|
WL_EXPORT int
|
|
|
|
wl_display_add_socket(struct wl_display *display, const char *socket_name)
|
2008-09-30 17:46:10 +04:00
|
|
|
{
|
|
|
|
struct sockaddr_un name;
|
|
|
|
int sock;
|
|
|
|
socklen_t size;
|
|
|
|
|
|
|
|
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
|
|
|
|
if (sock < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
name.sun_family = AF_LOCAL;
|
|
|
|
memcpy(name.sun_path, socket_name, sizeof socket_name);
|
|
|
|
|
|
|
|
size = offsetof (struct sockaddr_un, sun_path) + sizeof socket_name;
|
|
|
|
if (bind(sock, (struct sockaddr *) &name, size) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (listen(sock, 1) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2008-10-07 18:10:36 +04:00
|
|
|
wl_event_loop_add_fd(display->loop, sock,
|
|
|
|
WL_EVENT_READABLE,
|
2008-09-30 17:46:10 +04:00
|
|
|
socket_data, display);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-10-12 02:40:23 +04:00
|
|
|
struct wl_surface_iterator {
|
|
|
|
struct wl_list *head;
|
|
|
|
struct wl_surface *surface;
|
|
|
|
uint32_t mask;
|
|
|
|
};
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT struct wl_surface_iterator *
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_surface_iterator_create(struct wl_display *display, uint32_t mask)
|
|
|
|
{
|
|
|
|
struct wl_surface_iterator *iterator;
|
|
|
|
|
|
|
|
iterator = malloc(sizeof *iterator);
|
|
|
|
if (iterator == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
iterator->head = &display->surface_list;
|
|
|
|
iterator->surface = container_of(display->surface_list.next,
|
|
|
|
struct wl_surface, link);
|
|
|
|
iterator->mask = mask;
|
|
|
|
|
|
|
|
return iterator;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT int
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_surface_iterator_next(struct wl_surface_iterator *iterator,
|
|
|
|
struct wl_surface **surface)
|
|
|
|
{
|
|
|
|
if (&iterator->surface->link == iterator->head)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
*surface = iterator->surface;
|
|
|
|
iterator->surface = container_of(iterator->surface->link.next,
|
|
|
|
struct wl_surface, link);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-11-08 23:39:41 +03:00
|
|
|
WL_EXPORT void
|
2008-10-12 02:40:23 +04:00
|
|
|
wl_surface_iterator_destroy(struct wl_surface_iterator *iterator)
|
|
|
|
{
|
|
|
|
free(iterator);
|
|
|
|
}
|