[PATCH wayland] introduce new headers wayland-client/server-core.h
Marek Chalupa
mchqwerty at gmail.com
Sun Apr 26 23:48:03 PDT 2015
Hi,
On Sat, Apr 25, 2015 at 4:39 PM, Giulio Camuffo <giuliocamuffo at gmail.com>
wrote:
> wayland-client.h and wayland-server.h include the protocol headers
> generated
> at build time. This means that a libwayland user cannot generate and use
> protocol code created from a wayland.xml newer than the installed
> libwayand,
> because it is not possible to only include the API header.
> This commit adds wayland-client-core.h and wayland-server-core.h which do
> not
> include the protocol headers. Additionally wayland-scanner gains a new
> option
> '--include-core-headers' that makes the generated code include the core
> versions
> of the headers.
>
Is the --include-core-headers option necessary? Until now the scanner
included wayland-client/server.h
which included the %-protocol.h, but since there are inclusion guards, the
protocol header was not
included again - so including wayland-client/server.h is the same as
including wayland-client/server-core.h, isn't it?
So including the core headers should be good for all cases.
Anyway, if there's a reason to have this option, then
--include-core-headers should be mentioned in help message.
>
> The option handling code in scanner.c comes directly from weston's
> shared/option-parser.c.
> ---
> Makefile.am | 2 +
> src/scanner.c | 247 ++++++++++++++++++++-----
> src/wayland-client-core.h | 180 ++++++++++++++++++
> src/wayland-client.h | 147 +--------------
> src/wayland-egl.h | 2 +-
> src/wayland-server-core.h | 455
> ++++++++++++++++++++++++++++++++++++++++++++++
> src/wayland-server.h | 422 +-----------------------------------------
> 7 files changed, 837 insertions(+), 618 deletions(-)
> create mode 100644 src/wayland-client-core.h
> create mode 100644 src/wayland-server-core.h
>
> diff --git a/Makefile.am b/Makefile.am
> index 0fccf86..a8a0a56 100644
> --- a/Makefile.am
> +++ b/Makefile.am
> @@ -21,7 +21,9 @@ noinst_LTLIBRARIES = libwayland-util.la
> include_HEADERS = \
> src/wayland-util.h \
> src/wayland-server.h \
> + src/wayland-server-core.h \
> src/wayland-client.h \
> + src/wayland-client-core.h \
> src/wayland-egl.h \
> src/wayland-version.h
>
> diff --git a/src/scanner.c b/src/scanner.c
> index 1f1e59a..32e12cb 100644
> --- a/src/scanner.c
> +++ b/src/scanner.c
> @@ -67,6 +67,7 @@ struct protocol {
> int null_run_length;
> char *copyright;
> struct description *description;
> + int include_core_headers;
> };
>
> struct interface {
> @@ -980,10 +981,55 @@ format_copyright(const char *copyright)
> }
>
> static void
> +emit_types_forward_declarations(struct protocol *protocol,
> + struct wl_list *message_list,
> + struct wl_array *types)
> +{
> + struct message *m;
> + struct arg *a;
> + int length;
> + char **p;
> +
> + wl_list_for_each(m, message_list, link) {
> + length = 0;
> + m->all_null = 1;
> + wl_list_for_each(a, &m->arg_list, link) {
> + length++;
> + switch (a->type) {
> + case NEW_ID:
> + case OBJECT:
> + if (!a->interface_name)
> + continue;
> +
> + m->all_null = 0;
> + p = fail_on_null(wl_array_add(types,
> sizeof *p));
> + *p = a->interface_name;
> + break;
> + default:
> + break;
> + }
> + }
> +
> + if (m->all_null && length > protocol->null_run_length)
> + protocol->null_run_length = length;
> + }
> +}
> +
> +static int
> +cmp_names(const void *p1, const void *p2)
> +{
> + const char * const *s1 = p1, * const *s2 = p2;
> +
> + return strcmp(*s1, *s2);
> +}
> +
> +static void
> emit_header(struct protocol *protocol, enum side side)
> {
> struct interface *i;
> + struct wl_array types;
> const char *s = (side == SERVER) ? "SERVER" : "CLIENT";
> + char **p, *prev;
>
> if (protocol->copyright)
> format_copyright(protocol->copyright);
> @@ -1002,17 +1048,44 @@ emit_header(struct protocol *protocol, enum side
> side)
> "struct wl_resource;\n\n",
> protocol->uppercase_name, s,
> protocol->uppercase_name, s,
> - (side == SERVER) ? "wayland-server.h" : "wayland-client.h");
> + (side == SERVER) ? (protocol->include_core_headers ?
> + "wayland-server-core.h" :
> + "wayland-server.h") :
> + (protocol->include_core_headers ?
> + "wayland-client-core.h" :
> + "wayland-client.h"));
>
> - wl_list_for_each(i, &protocol->interface_list, link)
> - printf("struct %s;\n", i->name);
> - printf("\n");
> + wl_array_init(&types);
> + wl_list_for_each(i, &protocol->interface_list, link) {
> + emit_types_forward_declarations(protocol,
> &i->request_list, &types);
> + emit_types_forward_declarations(protocol, &i->event_list,
> &types);
> + }
>
> wl_list_for_each(i, &protocol->interface_list, link) {
> + p = fail_on_null(wl_array_add(&types, sizeof *p));
> + *p = i->name;
> + }
> +
> + qsort(types.data, types.size / sizeof *p, sizeof *p, cmp_names);
> + prev = NULL;
> + wl_array_for_each(p, &types) {
> + if (prev && strcmp(*p, prev) == 0)
> + continue;
> + printf("struct %s;\n", *p);
> + prev = *p;
> + }
> + printf("\n");
> +
> + prev = NULL;
> + wl_array_for_each(p, &types) {
> + if (prev && strcmp(*p, prev) == 0)
> + continue;
> printf("extern const struct wl_interface "
> - "%s_interface;\n",
> - i->name);
> + "%s_interface;\n", *p);
> + prev = *p;
> }
> +
> + wl_array_release(&types);
> printf("\n");
>
> wl_list_for_each(i, &protocol->interface_list, link) {
> @@ -1039,41 +1112,6 @@ emit_header(struct protocol *protocol, enum side
> side)
> }
>
> static void
> -emit_types_forward_declarations(struct protocol *protocol,
> - struct wl_list *message_list,
> - struct wl_array *types)
> -{
> - struct message *m;
> - struct arg *a;
> - int length;
> - char **p;
> -
> - wl_list_for_each(m, message_list, link) {
> - length = 0;
> - m->all_null = 1;
> - wl_list_for_each(a, &m->arg_list, link) {
> - length++;
> - switch (a->type) {
> - case NEW_ID:
> - case OBJECT:
> - if (!a->interface_name)
> - continue;
> -
> - m->all_null = 0;
> - p = fail_on_null(wl_array_add(types,
> sizeof *p));
> - *p = a->interface_name;
> - break;
> - default:
> - break;
> - }
> - }
> -
> - if (m->all_null && length > protocol->null_run_length)
> - protocol->null_run_length = length;
> - }
> -}
> -
> -static void
> emit_null_run(struct protocol *protocol)
> {
> int i;
> @@ -1176,14 +1214,6 @@ emit_messages(struct wl_list *message_list,
> printf("};\n\n");
> }
>
> -static int
> -cmp_names(const void *p1, const void *p2)
> -{
> - const char * const *s1 = p1, * const *s2 = p2;
> -
> - return strcmp(*s1, *s2);
> -}
> -
> static void
> emit_code(struct protocol *protocol)
> {
> @@ -1248,21 +1278,137 @@ emit_code(struct protocol *protocol)
> }
> }
>
> +enum option_type {
> + OPTION_INTEGER,
> + OPTION_UNSIGNED_INTEGER,
> + OPTION_STRING,
> + OPTION_BOOLEAN
> +};
> +
> +struct option {
> + enum option_type type;
> + const char *name;
> + int short_name;
> + void *data;
> +};
> +
> +static int
> +handle_option(const struct option *option, char *value)
> +{
> + char* p;
> +
> + switch (option->type) {
> + case OPTION_INTEGER:
> + * (int32_t *) option->data = strtol(value, &p, 0);
> + return *value && !*p;
> + case OPTION_UNSIGNED_INTEGER:
> + * (uint32_t *) option->data = strtoul(value, &p, 0);
> + return *value && !*p;
> + case OPTION_STRING:
> + * (char **) option->data = strdup(value);
> + return 1;
> + default:
> + return 0;
> + }
> +}
> +
> +static int
> +long_option(const struct option *options, int count, char *arg)
> +{
> + int k, len;
> +
> + for (k = 0; k < count; k++) {
> + if (!options[k].name)
> + continue;
> +
> + len = strlen(options[k].name);
> + if (strncmp(options[k].name, arg + 2, len) != 0)
> + continue;
> +
> + if (options[k].type == OPTION_BOOLEAN) {
> + if (!arg[len + 2]) {
> + * (int32_t *) options[k].data = 1;
> +
> + return 1;
> + }
> + } else if (arg[len+2] == '=') {
> + return handle_option(options + k, arg + len + 3);
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int
> +short_option(const struct option *options, int count, char *arg)
> +{
> + int k;
> +
> + if (!arg[1])
> + return 0;
> +
> + for (k = 0; k < count; k++) {
> + if (options[k].short_name != arg[1])
> + continue;
> +
> + if (options[k].type == OPTION_BOOLEAN) {
> + if (!arg[2]) {
> + * (int32_t *) options[k].data = 1;
> +
> + return 1;
> + }
> + } else {
> + return handle_option(options + k, arg + 2);
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int
> +parse_options(const struct option *options,
> + int count, int *argc, char *argv[])
> +{
> + int i, j;
> +
> + for (i = 1, j = 1; i < *argc; i++) {
> + if (argv[i][0] == '-') {
> + if (argv[i][1] == '-') {
> + if (long_option(options, count, argv[i]))
> + continue;
> + } else if (short_option(options, count, argv[i]))
> + continue;
> + }
> + argv[j++] = argv[i];
> + }
> + argv[j] = NULL;
> + *argc = j;
> +
> + return j;
> +}
> +
> int main(int argc, char *argv[])
> {
> struct parse_context ctx;
> struct protocol protocol;
> int len;
> void *buf;
> + int help = 0, include_core = 0;
> enum {
> CLIENT_HEADER,
> SERVER_HEADER,
> CODE,
> } mode;
>
> + const struct option options[] = {
> + { OPTION_BOOLEAN, "help", 'h', &help },
> + { OPTION_BOOLEAN, "include-core-headers", 0, &include_core
> },
> + };
> + parse_options(options, sizeof(options) / sizeof(options[0]),
> &argc, argv);
> +
> if (argc != 2)
> usage(EXIT_FAILURE);
> - else if (strcmp(argv[1], "help") == 0 || strcmp(argv[1], "--help")
> == 0)
> + else if (strcmp(argv[1], "help") == 0 || help)
> usage(EXIT_SUCCESS);
> else if (strcmp(argv[1], "client-header") == 0)
> mode = CLIENT_HEADER;
> @@ -1277,6 +1423,7 @@ int main(int argc, char *argv[])
> protocol.type_index = 0;
> protocol.null_run_length = 0;
> protocol.copyright = NULL;
> + protocol.include_core_headers = include_core;
> memset(&ctx, 0, sizeof ctx);
> ctx.protocol = &protocol;
>
> diff --git a/src/wayland-client-core.h b/src/wayland-client-core.h
> new file mode 100644
> index 0000000..d7a0d9e
> --- /dev/null
> +++ b/src/wayland-client-core.h
> @@ -0,0 +1,180 @@
> +/*
> + * 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.
> + */
> +
> +#ifndef WAYLAND_CLIENT_CORE_H
> +#define WAYLAND_CLIENT_CORE_H
> +
> +#include "wayland-util.h"
> +#include "wayland-version.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/** \class wl_proxy
> + *
> + * \brief Represents a protocol object on the client side.
> + *
> + * A wl_proxy acts as a client side proxy to an object existing in the
> + * compositor. The proxy is responsible for converting requests made by
> the
> + * clients with \ref wl_proxy_marshal() into Wayland's wire format. Events
> + * coming from the compositor are also handled by the proxy, which will in
> + * turn call the handler set with \ref wl_proxy_add_listener().
> + *
> + * \note With the exception of function \ref wl_proxy_set_queue(),
> functions
> + * accessing a wl_proxy are not normally used by client code. Clients
> + * should normally use the higher level interface generated by the
> scanner to
> + * interact with compositor objects.
> + *
> + */
> +struct wl_proxy;
> +
> +/** \class wl_display
> + *
> + * \brief Represents a connection to the compositor and acts as a proxy to
> + * the wl_display singleton object.
> + *
> + * A wl_display object represents a client connection to a Wayland
> + * compositor. It is created with either \ref wl_display_connect() or
> + * \ref wl_display_connect_to_fd(). A connection is terminated using
> + * \ref wl_display_disconnect().
> + *
> + * A wl_display is also used as the \ref wl_proxy for the wl_display
> + * singleton object on the compositor side.
> + *
> + * A wl_display object handles all the data sent from and to the
> + * compositor. When a \ref wl_proxy marshals a request, it will write its
> wire
> + * representation to the display's write buffer. The data is sent to the
> + * compositor when the client calls \ref wl_display_flush().
> + *
> + * Incoming data is handled in two steps: queueing and dispatching. In the
> + * queue step, the data coming from the display fd is interpreted and
> + * added to a queue. On the dispatch step, the handler for the incoming
> + * event set by the client on the corresponding \ref wl_proxy is called.
> + *
> + * A wl_display has at least one event queue, called the <em>default
> + * queue</em>. Clients can create additional event queues with \ref
> + * wl_display_create_queue() and assign \ref wl_proxy's to it. Events
> + * occurring in a particular proxy are always queued in its assigned
> queue.
> + * A client can ensure that a certain assumption, such as holding a lock
> + * or running from a given thread, is true when a proxy event handler is
> + * called by assigning that proxy to an event queue and making sure that
> + * this queue is only dispatched when the assumption holds.
> + *
> + * The default queue is dispatched by calling \ref wl_display_dispatch().
> + * This will dispatch any events queued on the default queue and attempt
> + * to read from the display fd if it's empty. Events read are then queued
> + * on the appropriate queues according to the proxy assignment.
> + *
> + * A user created queue is dispatched with \ref
> wl_display_dispatch_queue().
> + * This function behaves exactly the same as wl_display_dispatch()
> + * but it dispatches given queue instead of the default queue.
> + *
> + * A real world example of event queue usage is Mesa's implementation of
> + * eglSwapBuffers() for the Wayland platform. This function might need
> + * to block until a frame callback is received, but dispatching the
> default
> + * queue could cause an event handler on the client to start drawing
> + * again. This problem is solved using another event queue, so that only
> + * the events handled by the EGL code are dispatched during the block.
> + *
> + * This creates a problem where a thread dispatches a non-default
> + * queue, reading all the data from the display fd. If the application
> + * would call \em poll(2) after that it would block, even though there
> + * might be events queued on the default queue. Those events should be
> + * dispatched with \ref wl_display_dispatch_(queue_)pending() before
> + * flushing and blocking.
> + */
> +struct wl_display;
> +
> +/** \class wl_event_queue
> + *
> + * \brief A queue for \ref wl_proxy object events.
> + *
> + * Event queues allows the events on a display to be handled in a
> thread-safe
> + * manner. See \ref wl_display for details.
> + *
> + */
> +struct wl_event_queue;
> +
> +void wl_event_queue_destroy(struct wl_event_queue *queue);
> +
> +void wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode, ...);
> +void wl_proxy_marshal_array(struct wl_proxy *p, uint32_t opcode,
> + union wl_argument *args);
> +struct wl_proxy *wl_proxy_create(struct wl_proxy *factory,
> + const struct wl_interface *interface);
> +struct wl_proxy *wl_proxy_marshal_constructor(struct wl_proxy *proxy,
> + uint32_t opcode,
> + const struct wl_interface
> *interface,
> + ...);
> +struct wl_proxy *
> +wl_proxy_marshal_array_constructor(struct wl_proxy *proxy,
> + uint32_t opcode, union wl_argument
> *args,
> + const struct wl_interface *interface);
> +
> +void wl_proxy_destroy(struct wl_proxy *proxy);
> +int wl_proxy_add_listener(struct wl_proxy *proxy,
> + void (**implementation)(void), void *data);
> +const void *wl_proxy_get_listener(struct wl_proxy *proxy);
> +int wl_proxy_add_dispatcher(struct wl_proxy *proxy,
> + wl_dispatcher_func_t dispatcher_func,
> + const void * dispatcher_data, void *data);
> +void wl_proxy_set_user_data(struct wl_proxy *proxy, void *user_data);
> +void *wl_proxy_get_user_data(struct wl_proxy *proxy);
> +uint32_t wl_proxy_get_id(struct wl_proxy *proxy);
> +const char *wl_proxy_get_class(struct wl_proxy *proxy);
> +void wl_proxy_set_queue(struct wl_proxy *proxy, struct wl_event_queue
> *queue);
> +
> +struct wl_display *wl_display_connect(const char *name);
> +struct wl_display *wl_display_connect_to_fd(int fd);
> +void wl_display_disconnect(struct wl_display *display);
> +int wl_display_get_fd(struct wl_display *display);
> +int wl_display_dispatch(struct wl_display *display);
> +int wl_display_dispatch_queue(struct wl_display *display,
> + struct wl_event_queue *queue);
> +int wl_display_dispatch_queue_pending(struct wl_display *display,
> + struct wl_event_queue *queue);
> +int wl_display_dispatch_pending(struct wl_display *display);
> +int wl_display_get_error(struct wl_display *display);
> +uint32_t wl_display_get_protocol_error(struct wl_display *display,
> + const struct wl_interface
> **interface,
> + uint32_t *id);
> +
> +int wl_display_flush(struct wl_display *display);
> +int wl_display_roundtrip_queue(struct wl_display *display,
> + struct wl_event_queue *queue);
> +int wl_display_roundtrip(struct wl_display *display);
> +struct wl_event_queue *wl_display_create_queue(struct wl_display
> *display);
> +
> +int wl_display_prepare_read_queue(struct wl_display *display,
> + struct wl_event_queue *queue);
> +int wl_display_prepare_read(struct wl_display *display);
> +void wl_display_cancel_read(struct wl_display *display);
> +int wl_display_read_events(struct wl_display *display);
> +
> +void wl_log_set_handler_client(wl_log_func_t handler);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif
> diff --git a/src/wayland-client.h b/src/wayland-client.h
> index 71cd822..a39fee7 100644
> --- a/src/wayland-client.h
> +++ b/src/wayland-client.h
> @@ -23,158 +23,13 @@
> #ifndef WAYLAND_CLIENT_H
> #define WAYLAND_CLIENT_H
>
> -#include "wayland-util.h"
> -#include "wayland-version.h"
> -
> #ifdef __cplusplus
> extern "C" {
> #endif
>
> -/** \class wl_proxy
> - *
> - * \brief Represents a protocol object on the client side.
> - *
> - * A wl_proxy acts as a client side proxy to an object existing in the
> - * compositor. The proxy is responsible for converting requests made by
> the
> - * clients with \ref wl_proxy_marshal() into Wayland's wire format. Events
> - * coming from the compositor are also handled by the proxy, which will in
> - * turn call the handler set with \ref wl_proxy_add_listener().
> - *
> - * \note With the exception of function \ref wl_proxy_set_queue(),
> functions
> - * accessing a wl_proxy are not normally used by client code. Clients
> - * should normally use the higher level interface generated by the
> scanner to
> - * interact with compositor objects.
> - *
> - */
> -struct wl_proxy;
> -
> -/** \class wl_display
> - *
> - * \brief Represents a connection to the compositor and acts as a proxy to
> - * the wl_display singleton object.
> - *
> - * A wl_display object represents a client connection to a Wayland
> - * compositor. It is created with either \ref wl_display_connect() or
> - * \ref wl_display_connect_to_fd(). A connection is terminated using
> - * \ref wl_display_disconnect().
> - *
> - * A wl_display is also used as the \ref wl_proxy for the wl_display
> - * singleton object on the compositor side.
> - *
> - * A wl_display object handles all the data sent from and to the
> - * compositor. When a \ref wl_proxy marshals a request, it will write its
> wire
> - * representation to the display's write buffer. The data is sent to the
> - * compositor when the client calls \ref wl_display_flush().
> - *
> - * Incoming data is handled in two steps: queueing and dispatching. In the
> - * queue step, the data coming from the display fd is interpreted and
> - * added to a queue. On the dispatch step, the handler for the incoming
> - * event set by the client on the corresponding \ref wl_proxy is called.
> - *
> - * A wl_display has at least one event queue, called the <em>default
> - * queue</em>. Clients can create additional event queues with \ref
> - * wl_display_create_queue() and assign \ref wl_proxy's to it. Events
> - * occurring in a particular proxy are always queued in its assigned
> queue.
> - * A client can ensure that a certain assumption, such as holding a lock
> - * or running from a given thread, is true when a proxy event handler is
> - * called by assigning that proxy to an event queue and making sure that
> - * this queue is only dispatched when the assumption holds.
> - *
> - * The default queue is dispatched by calling \ref wl_display_dispatch().
> - * This will dispatch any events queued on the default queue and attempt
> - * to read from the display fd if it's empty. Events read are then queued
> - * on the appropriate queues according to the proxy assignment.
> - *
> - * A user created queue is dispatched with \ref
> wl_display_dispatch_queue().
> - * This function behaves exactly the same as wl_display_dispatch()
> - * but it dispatches given queue instead of the default queue.
> - *
> - * A real world example of event queue usage is Mesa's implementation of
> - * eglSwapBuffers() for the Wayland platform. This function might need
> - * to block until a frame callback is received, but dispatching the
> default
> - * queue could cause an event handler on the client to start drawing
> - * again. This problem is solved using another event queue, so that only
> - * the events handled by the EGL code are dispatched during the block.
> - *
> - * This creates a problem where a thread dispatches a non-default
> - * queue, reading all the data from the display fd. If the application
> - * would call \em poll(2) after that it would block, even though there
> - * might be events queued on the default queue. Those events should be
> - * dispatched with \ref wl_display_dispatch_(queue_)pending() before
> - * flushing and blocking.
> - */
> -struct wl_display;
> -
> -/** \class wl_event_queue
> - *
> - * \brief A queue for \ref wl_proxy object events.
> - *
> - * Event queues allows the events on a display to be handled in a
> thread-safe
> - * manner. See \ref wl_display for details.
> - *
> - */
> -struct wl_event_queue;
> -
> -void wl_event_queue_destroy(struct wl_event_queue *queue);
> -
> -void wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode, ...);
> -void wl_proxy_marshal_array(struct wl_proxy *p, uint32_t opcode,
> - union wl_argument *args);
> -struct wl_proxy *wl_proxy_create(struct wl_proxy *factory,
> - const struct wl_interface *interface);
> -struct wl_proxy *wl_proxy_marshal_constructor(struct wl_proxy *proxy,
> - uint32_t opcode,
> - const struct wl_interface
> *interface,
> - ...);
> -struct wl_proxy *
> -wl_proxy_marshal_array_constructor(struct wl_proxy *proxy,
> - uint32_t opcode, union wl_argument
> *args,
> - const struct wl_interface *interface);
> -
> -void wl_proxy_destroy(struct wl_proxy *proxy);
> -int wl_proxy_add_listener(struct wl_proxy *proxy,
> - void (**implementation)(void), void *data);
> -const void *wl_proxy_get_listener(struct wl_proxy *proxy);
> -int wl_proxy_add_dispatcher(struct wl_proxy *proxy,
> - wl_dispatcher_func_t dispatcher_func,
> - const void * dispatcher_data, void *data);
> -void wl_proxy_set_user_data(struct wl_proxy *proxy, void *user_data);
> -void *wl_proxy_get_user_data(struct wl_proxy *proxy);
> -uint32_t wl_proxy_get_id(struct wl_proxy *proxy);
> -const char *wl_proxy_get_class(struct wl_proxy *proxy);
> -void wl_proxy_set_queue(struct wl_proxy *proxy, struct wl_event_queue
> *queue);
> -
> +#include "wayland-client-core.h"
> #include "wayland-client-protocol.h"
>
> -struct wl_display *wl_display_connect(const char *name);
> -struct wl_display *wl_display_connect_to_fd(int fd);
> -void wl_display_disconnect(struct wl_display *display);
> -int wl_display_get_fd(struct wl_display *display);
> -int wl_display_dispatch(struct wl_display *display);
> -int wl_display_dispatch_queue(struct wl_display *display,
> - struct wl_event_queue *queue);
> -int wl_display_dispatch_queue_pending(struct wl_display *display,
> - struct wl_event_queue *queue);
> -int wl_display_dispatch_pending(struct wl_display *display);
> -int wl_display_get_error(struct wl_display *display);
> -uint32_t wl_display_get_protocol_error(struct wl_display *display,
> - const struct wl_interface
> **interface,
> - uint32_t *id);
> -
> -int wl_display_flush(struct wl_display *display);
> -int wl_display_roundtrip_queue(struct wl_display *display,
> - struct wl_event_queue *queue);
> -int wl_display_roundtrip(struct wl_display *display);
> -struct wl_event_queue *wl_display_create_queue(struct wl_display
> *display);
> -
> -int wl_display_prepare_read_queue(struct wl_display *display,
> - struct wl_event_queue *queue);
> -int wl_display_prepare_read(struct wl_display *display);
> -void wl_display_cancel_read(struct wl_display *display);
> -int wl_display_read_events(struct wl_display *display);
> -
> -void wl_log_set_handler_client(wl_log_func_t handler);
> -
> #ifdef __cplusplus
> }
> #endif
> diff --git a/src/wayland-egl.h b/src/wayland-egl.h
> index c40280b..714002f 100644
> --- a/src/wayland-egl.h
> +++ b/src/wayland-egl.h
> @@ -28,7 +28,7 @@
> extern "C" {
> #endif
>
> -#include <wayland-client.h>
> +#include <wayland-client-core.h>
>
> #define WL_EGL_PLATFORM 1
>
> diff --git a/src/wayland-server-core.h b/src/wayland-server-core.h
> new file mode 100644
> index 0000000..7bdd986
> --- /dev/null
> +++ b/src/wayland-server-core.h
> @@ -0,0 +1,455 @@
> +/*
> + * 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.
> + */
> +
> +#ifndef WAYLAND_SERVER_CORE_H
> +#define WAYLAND_SERVER_CORE_H
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <sys/types.h>
> +#include <stdint.h>
> +#include "wayland-util.h"
> +#include "wayland-version.h"
> +
> +enum {
> + WL_EVENT_READABLE = 0x01,
> + WL_EVENT_WRITABLE = 0x02,
> + WL_EVENT_HANGUP = 0x04,
> + WL_EVENT_ERROR = 0x08
> +};
> +
> +struct wl_event_loop;
> +struct wl_event_source;
> +typedef int (*wl_event_loop_fd_func_t)(int fd, uint32_t mask, void *data);
> +typedef int (*wl_event_loop_timer_func_t)(void *data);
> +typedef int (*wl_event_loop_signal_func_t)(int signal_number, void *data);
> +typedef void (*wl_event_loop_idle_func_t)(void *data);
> +
> +struct wl_event_loop *wl_event_loop_create(void);
> +void wl_event_loop_destroy(struct wl_event_loop *loop);
> +struct wl_event_source *wl_event_loop_add_fd(struct wl_event_loop *loop,
> + int fd, uint32_t mask,
> + wl_event_loop_fd_func_t func,
> + void *data);
> +int wl_event_source_fd_update(struct wl_event_source *source, uint32_t
> mask);
> +struct wl_event_source *wl_event_loop_add_timer(struct wl_event_loop
> *loop,
> + wl_event_loop_timer_func_t
> func,
> + void *data);
> +struct wl_event_source *
> +wl_event_loop_add_signal(struct wl_event_loop *loop,
> + int signal_number,
> + wl_event_loop_signal_func_t func,
> + void *data);
> +
> +int wl_event_source_timer_update(struct wl_event_source *source,
> + int ms_delay);
> +int wl_event_source_remove(struct wl_event_source *source);
> +void wl_event_source_check(struct wl_event_source *source);
> +
> +
> +int wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout);
> +void wl_event_loop_dispatch_idle(struct wl_event_loop *loop);
> +struct wl_event_source *wl_event_loop_add_idle(struct wl_event_loop *loop,
> + wl_event_loop_idle_func_t
> func,
> + void *data);
> +int wl_event_loop_get_fd(struct wl_event_loop *loop);
> +
> +struct wl_client;
> +struct wl_display;
> +struct wl_listener;
> +struct wl_resource;
> +struct wl_global;
> +typedef void (*wl_notify_func_t)(struct wl_listener *listener, void
> *data);
> +
> +void wl_event_loop_add_destroy_listener(struct wl_event_loop *loop,
> + struct wl_listener * listener);
> +struct wl_listener *wl_event_loop_get_destroy_listener(
> + struct wl_event_loop *loop,
> + wl_notify_func_t notify);
> +
> +struct wl_display *wl_display_create(void);
> +void wl_display_destroy(struct wl_display *display);
> +struct wl_event_loop *wl_display_get_event_loop(struct wl_display
> *display);
> +int wl_display_add_socket(struct wl_display *display, const char *name);
> +const char *wl_display_add_socket_auto(struct wl_display *display);
> +void wl_display_terminate(struct wl_display *display);
> +void wl_display_run(struct wl_display *display);
> +void wl_display_flush_clients(struct wl_display *display);
> +
> +typedef void (*wl_global_bind_func_t)(struct wl_client *client, void
> *data,
> + uint32_t version, uint32_t id);
> +
> +uint32_t wl_display_get_serial(struct wl_display *display);
> +uint32_t wl_display_next_serial(struct wl_display *display);
> +
> +void wl_display_add_destroy_listener(struct wl_display *display,
> + struct wl_listener *listener);
> +struct wl_listener *wl_display_get_destroy_listener(struct wl_display
> *display,
> + wl_notify_func_t
> notify);
> +
> +struct wl_global *wl_global_create(struct wl_display *display,
> + const struct wl_interface *interface,
> + int version,
> + void *data, wl_global_bind_func_t bind);
> +void wl_global_destroy(struct wl_global *global);
> +
> +struct wl_client *wl_client_create(struct wl_display *display, int fd);
> +void wl_client_destroy(struct wl_client *client);
> +void wl_client_flush(struct wl_client *client);
> +void wl_client_get_credentials(struct wl_client *client,
> + pid_t *pid, uid_t *uid, gid_t *gid);
> +
> +void wl_client_add_destroy_listener(struct wl_client *client,
> + struct wl_listener *listener);
> +struct wl_listener *wl_client_get_destroy_listener(struct wl_client
> *client,
> + wl_notify_func_t
> notify);
> +
> +struct wl_resource *
> +wl_client_get_object(struct wl_client *client, uint32_t id);
> +void
> +wl_client_post_no_memory(struct wl_client *client);
> +
> +/** \class wl_listener
> + *
> + * \brief A single listener for Wayland signals
> + *
> + * wl_listener provides the means to listen for wl_signal notifications.
> Many
> + * Wayland objects use wl_listener for notification of significant events
> like
> + * object destruction.
> + *
> + * Clients should create wl_listener objects manually and can register
> them as
> + * listeners to signals using #wl_signal_add, assuming the signal is
> + * directly accessible. For opaque structs like wl_event_loop, adding a
> + * listener should be done through provided accessor methods. A listener
> can
> + * only listen to one signal at a time.
> + *
> + * \code
> + * struct wl_listener your_listener;
> + *
> + * your_listener.notify = your_callback_method;
> + *
> + * // Direct access
> + * wl_signal_add(&some_object->destroy_signal, &your_listener);
> + *
> + * // Accessor access
> + * wl_event_loop *loop = ...;
> + * wl_event_loop_add_destroy_listener(loop, &your_listener);
> + * \endcode
> + *
> + * If the listener is part of a larger struct, #wl_container_of can be
> used
> + * to retrieve a pointer to it:
> + *
> + * \code
> + * void your_listener(struct wl_listener *listener, void *data)
> + * {
> + * struct your_data *data;
> + *
> + * your_data = wl_container_of(listener, data, your_member_name);
> + * }
> + * \endcode
> + *
> + * If you need to remove a listener from a signal, use wl_list_remove().
> + *
> + * \code
> + * wl_list_remove(&your_listener.link);
> + * \endcode
> + *
> + * \sa wl_signal
> + */
> +struct wl_listener {
> + struct wl_list link;
> + wl_notify_func_t notify;
> +};
> +
> +/** \class wl_signal
> + *
> + * \brief A source of a type of observable event
> + *
> + * Signals are recognized points where significant events can be observed.
> + * Compositors as well as the server can provide signals. Observers are
> + * wl_listener's that are added through #wl_signal_add. Signals are
> emitted
> + * using #wl_signal_emit, which will invoke all listeners until that
> + * listener is removed by wl_list_remove() (or whenever the signal is
> + * destroyed).
> + *
> + * \sa wl_listener for more information on using wl_signal
> + */
> +struct wl_signal {
> + struct wl_list listener_list;
> +};
> +
> +/** Initialize a new \ref wl_signal for use.
> + *
> + * \param signal The signal that will be initialized
> + *
> + * \memberof wl_signal
> + */
> +static inline void
> +wl_signal_init(struct wl_signal *signal)
> +{
> + wl_list_init(&signal->listener_list);
> +}
> +
> +/** Add the specified listener to this signal.
> + *
> + * \param signal The signal that will emit events to the listener
> + * \param listener The listener to add
> + *
> + * \memberof wl_signal
> + */
> +static inline void
> +wl_signal_add(struct wl_signal *signal, struct wl_listener *listener)
> +{
> + wl_list_insert(signal->listener_list.prev, &listener->link);
> +}
> +
> +/** Gets the listener struct for the specified callback.
> + *
> + * \param signal The signal that contains the specified listener
> + * \param notify The listener that is the target of this search
> + * \return the list item that corresponds to the specified listener, or
> NULL
> + * if none was found
> + *
> + * \memberof wl_signal
> + */
> +static inline struct wl_listener *
> +wl_signal_get(struct wl_signal *signal, wl_notify_func_t notify)
> +{
> + struct wl_listener *l;
> +
> + wl_list_for_each(l, &signal->listener_list, link)
> + if (l->notify == notify)
> + return l;
> +
> + return NULL;
> +}
> +
> +/** Emits this signal, notifying all registered listeners.
> + *
> + * \param signal The signal object that will emit the signal
> + * \param data The data that will be emitted with the signal
> + *
> + * \memberof wl_signal
> + */
> +static inline void
> +wl_signal_emit(struct wl_signal *signal, void *data)
> +{
> + struct wl_listener *l, *next;
> +
> + wl_list_for_each_safe(l, next, &signal->listener_list, link)
> + l->notify(l, data);
> +}
> +
> +typedef void (*wl_resource_destroy_func_t)(struct wl_resource *resource);
> +
> +#ifndef WL_HIDE_DEPRECATED
> +
> +struct wl_object {
> + const struct wl_interface *interface;
> + const void *implementation;
> + uint32_t id;
> +};
> +
> +struct wl_resource {
> + struct wl_object object;
> + wl_resource_destroy_func_t destroy;
> + struct wl_list link;
> + struct wl_signal destroy_signal;
> + struct wl_client *client;
> + void *data;
> +};
> +
> +struct wl_buffer {
> + struct wl_resource resource;
> + int32_t width, height;
> + uint32_t busy_count;
> +} WL_DEPRECATED;
> +
> +
> +uint32_t
> +wl_client_add_resource(struct wl_client *client,
> + struct wl_resource *resource) WL_DEPRECATED;
> +
> +struct wl_resource *
> +wl_client_add_object(struct wl_client *client,
> + const struct wl_interface *interface,
> + const void *implementation,
> + uint32_t id, void *data) WL_DEPRECATED;
> +struct wl_resource *
> +wl_client_new_object(struct wl_client *client,
> + const struct wl_interface *interface,
> + const void *implementation, void *data) WL_DEPRECATED;
> +
> +struct wl_global *
> +wl_display_add_global(struct wl_display *display,
> + const struct wl_interface *interface,
> + void *data,
> + wl_global_bind_func_t bind) WL_DEPRECATED;
> +
> +void
> +wl_display_remove_global(struct wl_display *display,
> + struct wl_global *global) WL_DEPRECATED;
> +
> +#endif
> +
> +/*
> + * Post an event to the client's object referred to by 'resource'.
> + * 'opcode' is the event number generated from the protocol XML
> + * description (the event name). The variable arguments are the event
> + * parameters, in the order they appear in the protocol XML specification.
> + *
> + * The variable arguments' types are:
> + * - type=uint: uint32_t
> + * - type=int: int32_t
> + * - type=fixed: wl_fixed_t
> + * - type=string: (const char *) to a nil-terminated string
> + * - type=array: (struct wl_array *)
> + * - type=fd: int, that is an open file descriptor
> + * - type=new_id: (struct wl_object *) or (struct wl_resource *)
> + * - type=object: (struct wl_object *) or (struct wl_resource *)
> + */
> +void wl_resource_post_event(struct wl_resource *resource,
> + uint32_t opcode, ...);
> +void wl_resource_post_event_array(struct wl_resource *resource,
> + uint32_t opcode, union wl_argument
> *args);
> +void wl_resource_queue_event(struct wl_resource *resource,
> + uint32_t opcode, ...);
> +void wl_resource_queue_event_array(struct wl_resource *resource,
> + uint32_t opcode, union wl_argument
> *args);
> +
> +/* msg is a printf format string, variable args are its args. */
> +void wl_resource_post_error(struct wl_resource *resource,
> + uint32_t code, const char *msg, ...)
> + __attribute__ ((format (printf, 3, 4)));
> +void wl_resource_post_no_memory(struct wl_resource *resource);
> +
> +struct wl_display *
> +wl_client_get_display(struct wl_client *client);
> +
> +struct wl_resource *
> +wl_resource_create(struct wl_client *client,
> + const struct wl_interface *interface,
> + int version, uint32_t id);
> +void
> +wl_resource_set_implementation(struct wl_resource *resource,
> + const void *implementation,
> + void *data,
> + wl_resource_destroy_func_t destroy);
> +void
> +wl_resource_set_dispatcher(struct wl_resource *resource,
> + wl_dispatcher_func_t dispatcher,
> + const void *implementation,
> + void *data,
> + wl_resource_destroy_func_t destroy);
> +
> +void
> +wl_resource_destroy(struct wl_resource *resource);
> +uint32_t
> +wl_resource_get_id(struct wl_resource *resource);
> +struct wl_list *
> +wl_resource_get_link(struct wl_resource *resource);
> +struct wl_resource *
> +wl_resource_from_link(struct wl_list *resource);
> +struct wl_resource *
> +wl_resource_find_for_client(struct wl_list *list, struct wl_client
> *client);
> +struct wl_client *
> +wl_resource_get_client(struct wl_resource *resource);
> +void
> +wl_resource_set_user_data(struct wl_resource *resource, void *data);
> +void *
> +wl_resource_get_user_data(struct wl_resource *resource);
> +int
> +wl_resource_get_version(struct wl_resource *resource);
> +void
> +wl_resource_set_destructor(struct wl_resource *resource,
> + wl_resource_destroy_func_t destroy);
> +int
> +wl_resource_instance_of(struct wl_resource *resource,
> + const struct wl_interface *interface,
> + const void *implementation);
> +
> +void
> +wl_resource_add_destroy_listener(struct wl_resource *resource,
> + struct wl_listener * listener);
> +struct wl_listener *
> +wl_resource_get_destroy_listener(struct wl_resource *resource,
> + wl_notify_func_t notify);
> +
> +#define wl_resource_for_each(resource, list)
> \
> + for (resource = 0, resource =
> wl_resource_from_link((list)->next); \
> + wl_resource_get_link(resource) != (list);
> \
> + resource =
> wl_resource_from_link(wl_resource_get_link(resource)->next))
> +
> +#define wl_resource_for_each_safe(resource, tmp, list)
> \
> + for (resource = 0, tmp = 0,
> \
> + resource = wl_resource_from_link((list)->next), \
> + tmp = wl_resource_from_link((list)->next->next); \
> + wl_resource_get_link(resource) != (list);
> \
> + resource = tmp,
> \
> + tmp =
> wl_resource_from_link(wl_resource_get_link(resource)->next))
> +
> +struct wl_shm_buffer;
> +
> +void
> +wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer);
> +
> +void
> +wl_shm_buffer_end_access(struct wl_shm_buffer *buffer);
> +
> +struct wl_shm_buffer *
> +wl_shm_buffer_get(struct wl_resource *resource);
> +
> +void *
> +wl_shm_buffer_get_data(struct wl_shm_buffer *buffer);
> +
> +int32_t
> +wl_shm_buffer_get_stride(struct wl_shm_buffer *buffer);
> +
> +uint32_t
> +wl_shm_buffer_get_format(struct wl_shm_buffer *buffer);
> +
> +int32_t
> +wl_shm_buffer_get_width(struct wl_shm_buffer *buffer);
> +
> +int32_t
> +wl_shm_buffer_get_height(struct wl_shm_buffer *buffer);
> +
> +int
> +wl_display_init_shm(struct wl_display *display);
> +
> +uint32_t *
> +wl_display_add_shm_format(struct wl_display *display, uint32_t format);
> +
> +struct wl_shm_buffer *
> +wl_shm_buffer_create(struct wl_client *client,
> + uint32_t id, int32_t width, int32_t height,
> + int32_t stride, uint32_t format);
> +
> +void wl_log_set_handler_server(wl_log_func_t handler);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif
> diff --git a/src/wayland-server.h b/src/wayland-server.h
> index af2f03d..18364fc 100644
> --- a/src/wayland-server.h
> +++ b/src/wayland-server.h
> @@ -27,429 +27,9 @@
> extern "C" {
> #endif
>
> -#include <sys/types.h>
> -#include <stdint.h>
> -#include "wayland-util.h"
> -#include "wayland-version.h"
> -
> -enum {
> - WL_EVENT_READABLE = 0x01,
> - WL_EVENT_WRITABLE = 0x02,
> - WL_EVENT_HANGUP = 0x04,
> - WL_EVENT_ERROR = 0x08
> -};
> -
> -struct wl_event_loop;
> -struct wl_event_source;
> -typedef int (*wl_event_loop_fd_func_t)(int fd, uint32_t mask, void *data);
> -typedef int (*wl_event_loop_timer_func_t)(void *data);
> -typedef int (*wl_event_loop_signal_func_t)(int signal_number, void *data);
> -typedef void (*wl_event_loop_idle_func_t)(void *data);
> -
> -struct wl_event_loop *wl_event_loop_create(void);
> -void wl_event_loop_destroy(struct wl_event_loop *loop);
> -struct wl_event_source *wl_event_loop_add_fd(struct wl_event_loop *loop,
> - int fd, uint32_t mask,
> - wl_event_loop_fd_func_t func,
> - void *data);
> -int wl_event_source_fd_update(struct wl_event_source *source, uint32_t
> mask);
> -struct wl_event_source *wl_event_loop_add_timer(struct wl_event_loop
> *loop,
> - wl_event_loop_timer_func_t
> func,
> - void *data);
> -struct wl_event_source *
> -wl_event_loop_add_signal(struct wl_event_loop *loop,
> - int signal_number,
> - wl_event_loop_signal_func_t func,
> - void *data);
> -
> -int wl_event_source_timer_update(struct wl_event_source *source,
> - int ms_delay);
> -int wl_event_source_remove(struct wl_event_source *source);
> -void wl_event_source_check(struct wl_event_source *source);
> -
> -
> -int wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout);
> -void wl_event_loop_dispatch_idle(struct wl_event_loop *loop);
> -struct wl_event_source *wl_event_loop_add_idle(struct wl_event_loop *loop,
> - wl_event_loop_idle_func_t
> func,
> - void *data);
> -int wl_event_loop_get_fd(struct wl_event_loop *loop);
> -
> -struct wl_client;
> -struct wl_display;
> -struct wl_listener;
> -struct wl_resource;
> -struct wl_global;
> -typedef void (*wl_notify_func_t)(struct wl_listener *listener, void
> *data);
> -
> -void wl_event_loop_add_destroy_listener(struct wl_event_loop *loop,
> - struct wl_listener * listener);
> -struct wl_listener *wl_event_loop_get_destroy_listener(
> - struct wl_event_loop *loop,
> - wl_notify_func_t notify);
> -
> -struct wl_display *wl_display_create(void);
> -void wl_display_destroy(struct wl_display *display);
> -struct wl_event_loop *wl_display_get_event_loop(struct wl_display
> *display);
> -int wl_display_add_socket(struct wl_display *display, const char *name);
> -const char *wl_display_add_socket_auto(struct wl_display *display);
> -void wl_display_terminate(struct wl_display *display);
> -void wl_display_run(struct wl_display *display);
> -void wl_display_flush_clients(struct wl_display *display);
> -
> -typedef void (*wl_global_bind_func_t)(struct wl_client *client, void
> *data,
> - uint32_t version, uint32_t id);
> -
> -uint32_t wl_display_get_serial(struct wl_display *display);
> -uint32_t wl_display_next_serial(struct wl_display *display);
> -
> -void wl_display_add_destroy_listener(struct wl_display *display,
> - struct wl_listener *listener);
> -struct wl_listener *wl_display_get_destroy_listener(struct wl_display
> *display,
> - wl_notify_func_t
> notify);
> -
> -struct wl_global *wl_global_create(struct wl_display *display,
> - const struct wl_interface *interface,
> - int version,
> - void *data, wl_global_bind_func_t bind);
> -void wl_global_destroy(struct wl_global *global);
> -
> -struct wl_client *wl_client_create(struct wl_display *display, int fd);
> -void wl_client_destroy(struct wl_client *client);
> -void wl_client_flush(struct wl_client *client);
> -void wl_client_get_credentials(struct wl_client *client,
> - pid_t *pid, uid_t *uid, gid_t *gid);
> -
> -void wl_client_add_destroy_listener(struct wl_client *client,
> - struct wl_listener *listener);
> -struct wl_listener *wl_client_get_destroy_listener(struct wl_client
> *client,
> - wl_notify_func_t
> notify);
> -
> -struct wl_resource *
> -wl_client_get_object(struct wl_client *client, uint32_t id);
> -void
> -wl_client_post_no_memory(struct wl_client *client);
> -
> -/** \class wl_listener
> - *
> - * \brief A single listener for Wayland signals
> - *
> - * wl_listener provides the means to listen for wl_signal notifications.
> Many
> - * Wayland objects use wl_listener for notification of significant events
> like
> - * object destruction.
> - *
> - * Clients should create wl_listener objects manually and can register
> them as
> - * listeners to signals using #wl_signal_add, assuming the signal is
> - * directly accessible. For opaque structs like wl_event_loop, adding a
> - * listener should be done through provided accessor methods. A listener
> can
> - * only listen to one signal at a time.
> - *
> - * \code
> - * struct wl_listener your_listener;
> - *
> - * your_listener.notify = your_callback_method;
> - *
> - * // Direct access
> - * wl_signal_add(&some_object->destroy_signal, &your_listener);
> - *
> - * // Accessor access
> - * wl_event_loop *loop = ...;
> - * wl_event_loop_add_destroy_listener(loop, &your_listener);
> - * \endcode
> - *
> - * If the listener is part of a larger struct, #wl_container_of can be
> used
> - * to retrieve a pointer to it:
> - *
> - * \code
> - * void your_listener(struct wl_listener *listener, void *data)
> - * {
> - * struct your_data *data;
> - *
> - * your_data = wl_container_of(listener, data, your_member_name);
> - * }
> - * \endcode
> - *
> - * If you need to remove a listener from a signal, use wl_list_remove().
> - *
> - * \code
> - * wl_list_remove(&your_listener.link);
> - * \endcode
> - *
> - * \sa wl_signal
> - */
> -struct wl_listener {
> - struct wl_list link;
> - wl_notify_func_t notify;
> -};
> -
> -/** \class wl_signal
> - *
> - * \brief A source of a type of observable event
> - *
> - * Signals are recognized points where significant events can be observed.
> - * Compositors as well as the server can provide signals. Observers are
> - * wl_listener's that are added through #wl_signal_add. Signals are
> emitted
> - * using #wl_signal_emit, which will invoke all listeners until that
> - * listener is removed by wl_list_remove() (or whenever the signal is
> - * destroyed).
> - *
> - * \sa wl_listener for more information on using wl_signal
> - */
> -struct wl_signal {
> - struct wl_list listener_list;
> -};
> -
> -/** Initialize a new \ref wl_signal for use.
> - *
> - * \param signal The signal that will be initialized
> - *
> - * \memberof wl_signal
> - */
> -static inline void
> -wl_signal_init(struct wl_signal *signal)
> -{
> - wl_list_init(&signal->listener_list);
> -}
> -
> -/** Add the specified listener to this signal.
> - *
> - * \param signal The signal that will emit events to the listener
> - * \param listener The listener to add
> - *
> - * \memberof wl_signal
> - */
> -static inline void
> -wl_signal_add(struct wl_signal *signal, struct wl_listener *listener)
> -{
> - wl_list_insert(signal->listener_list.prev, &listener->link);
> -}
> -
> -/** Gets the listener struct for the specified callback.
> - *
> - * \param signal The signal that contains the specified listener
> - * \param notify The listener that is the target of this search
> - * \return the list item that corresponds to the specified listener, or
> NULL
> - * if none was found
> - *
> - * \memberof wl_signal
> - */
> -static inline struct wl_listener *
> -wl_signal_get(struct wl_signal *signal, wl_notify_func_t notify)
> -{
> - struct wl_listener *l;
> -
> - wl_list_for_each(l, &signal->listener_list, link)
> - if (l->notify == notify)
> - return l;
> -
> - return NULL;
> -}
> -
> -/** Emits this signal, notifying all registered listeners.
> - *
> - * \param signal The signal object that will emit the signal
> - * \param data The data that will be emitted with the signal
> - *
> - * \memberof wl_signal
> - */
> -static inline void
> -wl_signal_emit(struct wl_signal *signal, void *data)
> -{
> - struct wl_listener *l, *next;
> -
> - wl_list_for_each_safe(l, next, &signal->listener_list, link)
> - l->notify(l, data);
> -}
> -
> -typedef void (*wl_resource_destroy_func_t)(struct wl_resource *resource);
> -
> -#ifndef WL_HIDE_DEPRECATED
> -
> -struct wl_object {
> - const struct wl_interface *interface;
> - const void *implementation;
> - uint32_t id;
> -};
> -
> -struct wl_resource {
> - struct wl_object object;
> - wl_resource_destroy_func_t destroy;
> - struct wl_list link;
> - struct wl_signal destroy_signal;
> - struct wl_client *client;
> - void *data;
> -};
> -
> -struct wl_buffer {
> - struct wl_resource resource;
> - int32_t width, height;
> - uint32_t busy_count;
> -} WL_DEPRECATED;
> -
> -
> -uint32_t
> -wl_client_add_resource(struct wl_client *client,
> - struct wl_resource *resource) WL_DEPRECATED;
> -
> -struct wl_resource *
> -wl_client_add_object(struct wl_client *client,
> - const struct wl_interface *interface,
> - const void *implementation,
> - uint32_t id, void *data) WL_DEPRECATED;
> -struct wl_resource *
> -wl_client_new_object(struct wl_client *client,
> - const struct wl_interface *interface,
> - const void *implementation, void *data) WL_DEPRECATED;
> -
> -struct wl_global *
> -wl_display_add_global(struct wl_display *display,
> - const struct wl_interface *interface,
> - void *data,
> - wl_global_bind_func_t bind) WL_DEPRECATED;
> -
> -void
> -wl_display_remove_global(struct wl_display *display,
> - struct wl_global *global) WL_DEPRECATED;
> -
> -#endif
> -
> -/*
> - * Post an event to the client's object referred to by 'resource'.
> - * 'opcode' is the event number generated from the protocol XML
> - * description (the event name). The variable arguments are the event
> - * parameters, in the order they appear in the protocol XML specification.
> - *
> - * The variable arguments' types are:
> - * - type=uint: uint32_t
> - * - type=int: int32_t
> - * - type=fixed: wl_fixed_t
> - * - type=string: (const char *) to a nil-terminated string
> - * - type=array: (struct wl_array *)
> - * - type=fd: int, that is an open file descriptor
> - * - type=new_id: (struct wl_object *) or (struct wl_resource *)
> - * - type=object: (struct wl_object *) or (struct wl_resource *)
> - */
> -void wl_resource_post_event(struct wl_resource *resource,
> - uint32_t opcode, ...);
> -void wl_resource_post_event_array(struct wl_resource *resource,
> - uint32_t opcode, union wl_argument
> *args);
> -void wl_resource_queue_event(struct wl_resource *resource,
> - uint32_t opcode, ...);
> -void wl_resource_queue_event_array(struct wl_resource *resource,
> - uint32_t opcode, union wl_argument
> *args);
> -
> -/* msg is a printf format string, variable args are its args. */
> -void wl_resource_post_error(struct wl_resource *resource,
> - uint32_t code, const char *msg, ...)
> - __attribute__ ((format (printf, 3, 4)));
> -void wl_resource_post_no_memory(struct wl_resource *resource);
> -
> +#include "wayland-server-core.h"
> #include "wayland-server-protocol.h"
>
> -struct wl_display *
> -wl_client_get_display(struct wl_client *client);
> -
> -struct wl_resource *
> -wl_resource_create(struct wl_client *client,
> - const struct wl_interface *interface,
> - int version, uint32_t id);
> -void
> -wl_resource_set_implementation(struct wl_resource *resource,
> - const void *implementation,
> - void *data,
> - wl_resource_destroy_func_t destroy);
> -void
> -wl_resource_set_dispatcher(struct wl_resource *resource,
> - wl_dispatcher_func_t dispatcher,
> - const void *implementation,
> - void *data,
> - wl_resource_destroy_func_t destroy);
> -
> -void
> -wl_resource_destroy(struct wl_resource *resource);
> -uint32_t
> -wl_resource_get_id(struct wl_resource *resource);
> -struct wl_list *
> -wl_resource_get_link(struct wl_resource *resource);
> -struct wl_resource *
> -wl_resource_from_link(struct wl_list *resource);
> -struct wl_resource *
> -wl_resource_find_for_client(struct wl_list *list, struct wl_client
> *client);
> -struct wl_client *
> -wl_resource_get_client(struct wl_resource *resource);
> -void
> -wl_resource_set_user_data(struct wl_resource *resource, void *data);
> -void *
> -wl_resource_get_user_data(struct wl_resource *resource);
> -int
> -wl_resource_get_version(struct wl_resource *resource);
> -void
> -wl_resource_set_destructor(struct wl_resource *resource,
> - wl_resource_destroy_func_t destroy);
> -int
> -wl_resource_instance_of(struct wl_resource *resource,
> - const struct wl_interface *interface,
> - const void *implementation);
> -
> -void
> -wl_resource_add_destroy_listener(struct wl_resource *resource,
> - struct wl_listener * listener);
> -struct wl_listener *
> -wl_resource_get_destroy_listener(struct wl_resource *resource,
> - wl_notify_func_t notify);
> -
> -#define wl_resource_for_each(resource, list)
> \
> - for (resource = 0, resource =
> wl_resource_from_link((list)->next); \
> - wl_resource_get_link(resource) != (list);
> \
> - resource =
> wl_resource_from_link(wl_resource_get_link(resource)->next))
> -
> -#define wl_resource_for_each_safe(resource, tmp, list)
> \
> - for (resource = 0, tmp = 0,
> \
> - resource = wl_resource_from_link((list)->next), \
> - tmp = wl_resource_from_link((list)->next->next); \
> - wl_resource_get_link(resource) != (list);
> \
> - resource = tmp,
> \
> - tmp =
> wl_resource_from_link(wl_resource_get_link(resource)->next))
> -
> -struct wl_shm_buffer;
> -
> -void
> -wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer);
> -
> -void
> -wl_shm_buffer_end_access(struct wl_shm_buffer *buffer);
> -
> -struct wl_shm_buffer *
> -wl_shm_buffer_get(struct wl_resource *resource);
> -
> -void *
> -wl_shm_buffer_get_data(struct wl_shm_buffer *buffer);
> -
> -int32_t
> -wl_shm_buffer_get_stride(struct wl_shm_buffer *buffer);
> -
> -uint32_t
> -wl_shm_buffer_get_format(struct wl_shm_buffer *buffer);
> -
> -int32_t
> -wl_shm_buffer_get_width(struct wl_shm_buffer *buffer);
> -
> -int32_t
> -wl_shm_buffer_get_height(struct wl_shm_buffer *buffer);
> -
> -int
> -wl_display_init_shm(struct wl_display *display);
> -
> -uint32_t *
> -wl_display_add_shm_format(struct wl_display *display, uint32_t format);
> -
> -struct wl_shm_buffer *
> -wl_shm_buffer_create(struct wl_client *client,
> - uint32_t id, int32_t width, int32_t height,
> - int32_t stride, uint32_t format);
> -
> -void wl_log_set_handler_server(wl_log_func_t handler);
> -
> #ifdef __cplusplus
> }
> #endif
> --
> 2.3.5
>
> _______________________________________________
> wayland-devel mailing list
> wayland-devel at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/wayland-devel
>
And the patch doesn't apply on master.
Cheers,
Marek
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.freedesktop.org/archives/wayland-devel/attachments/20150427/1080fcfc/attachment-0001.html>
More information about the wayland-devel
mailing list