mirrors/wayland
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/wayland.git synced 2025-11-03 09:01:42 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
wayland/src/wayland-client.h

76 lines
2.8 KiB
C
Raw Normal View History

Put Wayland under the MIT license.
2008-12-02 15:15:01 -05: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.
*/
Bunch of new stuff: simple compositor, cairo+gem use in client, events.
2008-10-07 10:10:36 -04:00
#ifndef _WAYLAND_CLIENT_H
#define _WAYLAND_CLIENT_H
Use "" when including our own header files
2010-07-29 15:43:46 -04:00
#include "wayland-util.h"
Add a public header for the version number This adds a public header so that applications can get the Wayland version number at compile time. This can be used to make applications that support compiling against multiple versions of Wayland. There is a separate installed header called cogl-version.h which gets included by both wayland-client.h and wayland-server.h The canonical place for the version number is the configure.ac script which splits it into three separate m4 defines for the major, minor and micro version. These are copied into the generated wayland-version.h header using AC_SUBST. There is also a string form of the complete version number. The version number is now also automatically copied into the two .pc files. Because the major, minor and micro parts are required it is no longer possible to leave the version number as 'master' when building from git. Most projects seem to immediately bump the git repo to a fake version number (usually odd) after making a release so that there is always a relative number that can be used for comparison. This patch sets the git version to 0.99.0 under the assumption that the next release will be 1.0.0.
2012-04-11 16:59:05 +01:00
#include "wayland-version.h"
Fix some warnings
2010-06-25 16:51:57 -04:00
Add extern "C" wrappers to public header files
2010-06-10 13:48:44 -04:00
#ifdef __cplusplus
extern "C" {
#endif
Move proxy prototype to wayland-client.h Let's try to avoid to generate more code than we need to.
2011-04-13 16:27:06 -04:00
struct wl_proxy;
struct wl_display;
client: Add wl_event_queue for multi-thread dispatching This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.
2012-10-05 13:49:48 -04:00
struct wl_event_queue;
void wl_event_queue_destroy(struct wl_event_queue *queue);
Move proxy prototype to wayland-client.h Let's try to avoid to generate more code than we need to.
2011-04-13 16:27:06 -04:00
void wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode, ...);
struct wl_proxy *wl_proxy_create(struct wl_proxy *factory,
const struct wl_interface *interface);
Add support for server allocated object IDs We set aside a range of the object ID space for use by the server. This allows the server to bind an object to an ID for a client and pass that object to the client. The client can use the object immediately and the server can emit events to the object immdiately.
2011-11-18 21:59:36 -05:00
Move proxy prototype to wayland-client.h Let's try to avoid to generate more code than we need to.
2011-04-13 16:27:06 -04:00
void wl_proxy_destroy(struct wl_proxy *proxy);
int wl_proxy_add_listener(struct wl_proxy *proxy,
void (**implementation)(void), 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);
Add wl_proxy_get_id()
2012-04-27 11:31:07 -04:00
uint32_t wl_proxy_get_id(struct wl_proxy *proxy);
client: Add wl_event_queue for multi-thread dispatching This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.
2012-10-05 13:49:48 -04:00
void wl_proxy_set_queue(struct wl_proxy *proxy, struct wl_event_queue *queue);
Move proxy prototype to wayland-client.h Let's try to avoid to generate more code than we need to.
2011-04-13 16:27:06 -04:00
#include "wayland-client-protocol.h"
Add glib main loop integration, use it in flower client.
2008-11-07 14:27:23 -05:00
typedef int (*wl_display_update_func_t)(uint32_t mask, void *data);
Use a callback object instead of ad-hoc lists for sync and frame events So obvious in retrospect. The object system can do all the work for us and keep track of pending calls as regular objects and we don't need to abuse the resource system to get them cleaned up on client exit. We don't need the custom key management or (broken) lookup, we just sue object IDs. And last but not least, anybody can receive the callback, not just display listeners.
2011-07-29 19:51:22 -07:00
typedef void (*wl_callback_func_t)(void *data, uint32_t time);
Add glib main loop integration, use it in flower client.
2008-11-07 14:27:23 -05:00
Create socket in /var/run/user/${HOME} Use the runtime dir from XDG Base Directory Specification for creating the socket in a directory only the user can read and write.
2010-12-01 15:36:20 -05:00
struct wl_display *wl_display_connect(const char *name);
client: Add wl_display_connect_to_fd() function This lets us connect a display to an already existing socket fd.
2012-08-14 13:16:10 -04:00
struct wl_display *wl_display_connect_to_fd(int fd);
Rename client side wl_display_destroy() to wl_display_disconnect() This avoids the clash with the wayland-server version with the same name, and allows linking against both wayland-client and wayland-server at the same time, which can be useful for unit testing purposes as well as for nested compositing. Without this there will be crashes as the wrong wl_display_destroy() is called.
2012-02-27 17:10:03 +01:00
void wl_display_disconnect(struct wl_display *display);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
int wl_display_get_fd(struct wl_display *display);
int wl_display_dispatch(struct wl_display *display);
client: Add wl_event_queue for multi-thread dispatching This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.
2012-10-05 13:49:48 -04:00
int wl_display_dispatch_queue(struct wl_display *display,
struct wl_event_queue *queue);
client: Add wl_display_dispatch_pending() for dispatching without reading If the main thread ends up dispatching a non-main queue, and not in a wl_display_dispatch() callback, we may queue up main queue events and read all data from the socket fd. When we get back to the main loop, the socket fd is no longer readable and nothing will trigger dispatching of the queued up events. The new function wl_display_dispatch_pending() will dispatch any pending events, but not attempt to read from the socket. Clients that integrate the wayland socket fd into a main loop should call wl_display_dispatch_pending() and then wl_display_flush() before going back to blocking in poll(2) or similar mechanism.
2012-10-11 17:15:08 -04:00
int wl_display_dispatch_pending(struct wl_display *display);
client: Add wl_event_queue for multi-thread dispatching This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.
2012-10-05 13:49:48 -04:00
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
int wl_display_flush(struct wl_display *display);
Use a callback object instead of ad-hoc lists for sync and frame events So obvious in retrospect. The object system can do all the work for us and keep track of pending calls as regular objects and we don't need to abuse the resource system to get them cleaned up on client exit. We don't need the custom key management or (broken) lookup, we just sue object IDs. And last but not least, anybody can receive the callback, not just display listeners.
2011-07-29 19:51:22 -07:00
void wl_display_roundtrip(struct wl_display *display);
client: Add wl_event_queue for multi-thread dispatching This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.
2012-10-05 13:49:48 -04:00
struct wl_event_queue *wl_display_create_queue(struct wl_display *display);
Bunch of new stuff: simple compositor, cairo+gem use in client, events.
2008-10-07 10:10:36 -04:00
Wayland: logging The core libwayland libraries should not handle logging, only passing the error messages to subscribed functions. An application linked to libwayland-server or libwayland-client will be able to set own functions (one per library) to handle error messages. Change in this series: make the wl_log return int, because of compatibility with printf. It will return the number of bytes logged.
2012-05-29 17:37:02 +02:00
void wl_log_set_handler_client(wl_log_func_t handler);
Add extern "C" wrappers to public header files
2010-06-10 13:48:44 -04:00
#ifdef __cplusplus
}
#endif
Bunch of new stuff: simple compositor, cairo+gem use in client, events.
2008-10-07 10:10:36 -04:00
#endif
Reference in a new issue Copy permalink