You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
weston/wayland-client.c

377 lines
9.0 KiB

/*
* 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.
*/
#include <stdlib.h>
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <ctype.h>
#include <sys/poll.h>
#include "connection.h"
#include "wayland-util.h"
#include "wayland-client.h"
static const char socket_name[] = "\0wayland";
struct wl_global {
uint32_t id;
char *interface;
struct wl_list link;
};
struct wl_proxy {
struct wl_display *display;
uint32_t id;
};
struct wl_display {
struct wl_proxy proxy;
struct wl_connection *connection;
int fd;
uint32_t id;
uint32_t mask;
struct wl_list global_list;
wl_display_update_func_t update;
void *update_data;
wl_display_event_func_t event_handler;
void *event_handler_data;
};
struct wl_surface {
struct wl_proxy proxy;
};
static int
connection_update(struct wl_connection *connection,
uint32_t mask, void *data)
{
struct wl_display *display = data;
display->mask = mask;
if (display->update)
return display->update(display->mask,
display->update_data);
return 0;
}
WL_EXPORT struct wl_display *
wl_display_create(const char *name, size_t name_size)
{
struct wl_display *display;
struct wl_global *global;
struct sockaddr_un addr;
socklen_t size;
char buffer[256];
uint32_t id, length, count, i;
display = malloc(sizeof *display);
if (display == NULL)
return NULL;
memset(display, 0, sizeof *display);
display->fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (display->fd < 0) {
free(display);
return NULL;
}
addr.sun_family = AF_LOCAL;
memcpy(addr.sun_path, name, name_size);
size = offsetof (struct sockaddr_un, sun_path) + name_size;
if (connect(display->fd, (struct sockaddr *) &addr, size) < 0) {
close(display->fd);
free(display);
return NULL;
}
/* FIXME: We'll need a protocol for getting a new range, I
* guess... */
read(display->fd, &display->id, sizeof display->id);
read(display->fd, &count, sizeof count);
wl_list_init(&display->global_list);
for (i = 0; i < count; i++) {
/* FIXME: actually discover advertised objects here. */
read(display->fd, &id, sizeof id);
read(display->fd, &length, sizeof length);
read(display->fd, buffer, (length + 3) & ~3);
global = malloc(sizeof *global);
if (global == NULL)
return NULL;
global->id = id;
global->interface = malloc(length + 1);
memcpy(global->interface, buffer, length);
global->interface[length] = '\0';
wl_list_insert(display->global_list.prev, &global->link);
}
display->proxy.display = display;
display->proxy.id = wl_display_get_object_id(display, "display");
display->connection = wl_connection_create(display->fd,
connection_update,
display);
return display;
}
WL_EXPORT void
wl_display_destroy(struct wl_display *display)
{
wl_connection_destroy(display->connection);
close(display->fd);
free(display);
}
WL_EXPORT uint32_t
wl_display_get_object_id(struct wl_display *display, const char *interface)
{
struct wl_global *global;
global = container_of(display->global_list.next,
struct wl_global, link);
while (&global->link != &display->global_list) {
if (strcmp(global->interface, interface) == 0)
return global->id;
global = container_of(global->link.next,
struct wl_global, link);
}
return 0;
}
WL_EXPORT int
wl_display_get_fd(struct wl_display *display,
wl_display_update_func_t update, void *data)
{
display->update = update;
display->update_data = data;
display->update(display->mask, display->update_data);
return display->fd;
}
static void
handle_event(struct wl_display *display,
uint32_t object, uint32_t opcode, uint32_t size)
{
uint32_t p[10];
wl_connection_copy(display->connection, p, size);
if (display->event_handler != NULL)
display->event_handler(display, object, opcode, size, p + 2,
display->event_handler_data);
wl_connection_consume(display->connection, size);
}
WL_EXPORT void
wl_display_iterate(struct wl_display *display, uint32_t mask)
{
uint32_t p[2], object, opcode, size;
int len;
len = wl_connection_data(display->connection, mask);
while (len > 0) {
if (len < sizeof p)
break;
wl_connection_copy(display->connection, p, sizeof p);
object = p[0];
opcode = p[1] & 0xffff;
size = p[1] >> 16;
if (len < size)
break;
handle_event(display, object, opcode, size);
len -= size;
}
if (len < 0) {
fprintf(stderr, "read error: %m\n");
exit(EXIT_FAILURE);
}
}
WL_EXPORT void
wl_display_set_event_handler(struct wl_display *display,
wl_display_event_func_t handler,
void *data)
{
/* FIXME: This needs something more generic... */
display->event_handler = handler;
display->event_handler_data = data;
}
WL_EXPORT uint32_t
wl_display_allocate_id(struct wl_display *display)
{
return display->id++;
}
WL_EXPORT void
wl_display_write(struct wl_display *display, const void *data, size_t count)
{
wl_connection_write(display->connection, data, count);
}
#define WL_DISPLAY_CREATE_SURFACE 0
#define WL_DISPLAY_COMMIT 1
WL_EXPORT struct wl_surface *
wl_display_create_surface(struct wl_display *display)
{
struct wl_surface *surface;
uint32_t request[3];
surface = malloc(sizeof *surface);
if (surface == NULL)
return NULL;
surface->proxy.id = wl_display_allocate_id(display);
surface->proxy.display = display;
request[0] = display->proxy.id;
request[1] = WL_DISPLAY_CREATE_SURFACE | ((sizeof request) << 16);
request[2] = surface->proxy.id;
wl_connection_write(display->connection, request, sizeof request);
return surface;
}
WL_EXPORT void
wl_display_commit(struct wl_display *display, uint32_t key)
{
uint32_t request[3];
request[0] = display->proxy.id;
request[1] = WL_DISPLAY_COMMIT | ((sizeof request) << 16);
request[2] = key;
wl_connection_write(display->connection, request, sizeof request);
}
#define WL_SURFACE_DESTROY 0
#define WL_SURFACE_ATTACH 1
#define WL_SURFACE_MAP 2
#define WL_SURFACE_COPY 3
#define WL_SURFACE_DAMAGE 4
WL_EXPORT void
wl_surface_destroy(struct wl_surface *surface)
{
uint32_t request[2];
request[0] = surface->proxy.id;
request[1] = WL_SURFACE_DESTROY | ((sizeof request) << 16);
wl_connection_write(surface->proxy.display->connection,
request, sizeof request);
}
WL_EXPORT void
wl_surface_attach(struct wl_surface *surface, uint32_t name,
int32_t width, int32_t height, uint32_t stride)
{
uint32_t request[6];
request[0] = surface->proxy.id;
request[1] = WL_SURFACE_ATTACH | ((sizeof request) << 16);
request[2] = name;
request[3] = width;
request[4] = height;
request[5] = stride;
wl_connection_write(surface->proxy.display->connection,
request, sizeof request);
}
WL_EXPORT void
wl_surface_map(struct wl_surface *surface,
int32_t x, int32_t y, int32_t width, int32_t height)
{
uint32_t request[6];
request[0] = surface->proxy.id;
request[1] = WL_SURFACE_MAP | ((sizeof request) << 16);
request[2] = x;
request[3] = y;
request[4] = width;
request[5] = height;
wl_connection_write(surface->proxy.display->connection,
request, sizeof request);
}
WL_EXPORT void
wl_surface_copy(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)
{
uint32_t request[10];
request[0] = surface->proxy.id;
request[1] = WL_SURFACE_COPY | ((sizeof request) << 16);
request[2] = dst_x;
request[3] = dst_y;
request[4] = name;
request[5] = stride;
request[6] = x;
request[7] = y;
request[8] = width;
request[9] = height;
wl_connection_write(surface->proxy.display->connection,
request, sizeof request);
}
WL_EXPORT void
wl_surface_damage(struct wl_surface *surface,
int32_t x, int32_t y, int32_t width, int32_t height)
{
uint32_t request[6];
request[0] = surface->proxy.id;
request[1] = WL_SURFACE_DAMAGE | ((sizeof request) << 16);
request[2] = x;
request[3] = y;
request[4] = width;
request[5] = height;
wl_connection_write(surface->proxy.display->connection,
request, sizeof request);
}