Client API¶
Client Introduction¶
The open-source reference implementation of Wayland protocol is split in two C libraries, libwayland-client and Server API. Their main responsibility is to handle the Inter-process communication (IPC) with each other, therefore guaranteeing the protocol objects marshaling and messages synchronization.
A client uses libwayland-client to communicate with one or more wayland
servers. A wl_display
object is created and manages each open
connection to a server. At least one wl_event_queue
object is created
for each wl_display, this holds events as they are received from the server
until they can be processed. Multi-threading is supported by creating an
additional wl_event_queue for each additional thread, each object can have it’s
events placed in a particular queue, so potentially a different thread could be
made to handle the events for each object created.
Though some convenience functions are provided, libwayland-client is designed to allow the calling code to wait for events, so that different polling mechanisms can be used. A file descriptor is provided, when it becomes ready for reading the calling code can ask libwayland-client to read the available events from it into the wl_event_queue objects.
The library only provides low-level access to the wayland objects. Each object
created by the client is represented by a wl_proxy
object that this library
creates. This includes the id that is actually communicated over the socket to
the server, a void* data pointer that is intended to point at a client’s
representation of the object, and a pointer to a static wl_interface
object,
which is generated from the xml and identifies the object’s class and can be used for
introspection into the messages and events.
Messages are sent by calling wl_proxy_marshal()
. This will write a
message to the socket, by using the message id and the wl_interface to identify
the types of each argument and convert them into stream format. Most software
will call type-safe wrappers generated from the xml description of the
Wayland protocol specification. For instance the C header file generated
from the xml defines the following inline function to transmit the
wl_surface_attach()
message:
static inline void
wl_surface_attach(struct wl_surface *wl_surface, struct wl_buffer *buffer, int32_t x, int32_t y)
{
wl_proxy_marshal((struct wl_proxy *) wl_surface, WL_SURFACE_ATTACH, buffer, x, y);
}
Events (messages from the server) are handled by calling a “dispatcher”
callback the client stores in the wl_proxy for each event. A language binding
for a string-based interpreter, such as CPython, might have a dispatcher that
uses the event name from the wl_interface
to identify the function to call. The
default dispatcher uses the message id number to index an array of functions
pointers, called a wl_listener, and the wl_interface to convert data from the
stream into arguments to the function. The C header file generated from the xml
defines a per-class structure that forces the function pointers to be of the
correct type, for instance the wl_surface_enter()
event
defines this pointer in the wl_surface_listener
object:
struct wl_surface_listener {
void (*enter)(void *data, struct wl_surface *, struct wl_output *);
...
}
-
union
wl_argument
¶ - #include <wayland-util.h>
Protocol message argument data types.
This union represents all of the argument types in the Wayland protocol wire format. The protocol implementation uses wl_argument within its marshalling machinery for dispatching messages between a client and a compositor.
- See
- wl_message
- See
- wl_interface
- See
- Wire Format
-
class
wl_array
¶ - #include <wayland-util.h>
Dynamic array.
A wl_array is a dynamic array that can only grow until released. It is intended for relatively small allocations whose size is variable or not known in advance. While construction of a wl_array does not require all elements to be of the same size, wl_array_for_each() does require all elements to have the same type and size.
Public Functions
-
void
wl_array_init
(struct wl_array *array)¶ Initializes the array.
- Parameters
array
: Array to initialize
-
void
wl_array_release
(struct wl_array *array)¶ Releases the array data.
- Note
- Leaves the array in an invalid state.
- Parameters
array
: Array whose data is to be released
-
void *
wl_array_add
(struct wl_array *array, size_t size)¶ Increases the size of the array by
size
bytes.- Return
- A pointer to the beginning of the newly appended space, or NULL when resizing fails.
- Parameters
array
: Array whose size is to be increasedsize
: Number of bytes to increase the size of the array by
Related
-
wl_array_for_each
(pos, array)¶ Iterates over an array.
This macro expresses a for-each iterator for wl_array. It assigns each element in the array to
pos
, which can then be referenced in a trailing code block.pos
must be a pointer to the array element type, and all array elements must be of the same type and size.- See
- wl_list_for_each()
- Parameters
pos
: Cursor that each array element will be assigned toarray
: Array to iterate over
-
void
-
class
wl_display
¶ - #include <wayland-client-core.h>
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 wl_display_connect() or wl_display_connect_to_fd(). A connection is terminated using wl_display_disconnect().
A wl_display is also used as the 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 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 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 wl_proxy is called.
A wl_display has at least one event queue, called the default queue. Clients can create additional event queues with wl_display_create_queue() and assign 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 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 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 poll(2) after that it would block, even though there might be events queued on the default queue. Those events should be dispatched with wl_display_dispatch_pending() or wl_display_dispatch_queue_pending() before flushing and blocking.
Public Functions
-
struct wl_event_queue *
wl_display_create_queue
(struct wl_display *display)¶ Create a new event queue for this display.
- Return
- A new event queue associated with this display or NULL on failure.
- Parameters
display
: The display context object
-
struct wl_display *
wl_display_connect_to_fd
(int fd)¶ Connect to Wayland display on an already open fd.
The
wl_display takes ownership of the fd and will close it when the display is destroyed. The fd will also be closed in case of failure.- Return
- A wl_display object or
NULL
on failure - Parameters
fd
: The fd to use for the connection
-
struct wl_display *
wl_display_connect
(const char *name)¶ Connect to a Wayland display.
Connect to the Wayland display named
name
. Ifname
isNULL
, its value will be replaced with the WAYLAND_DISPLAY environment variable if it is set, otherwise display “wayland-0” will be used.- Return
- A wl_display object or
NULL
on failure - Parameters
name
: Name of the Wayland display to connect to
If
name
is an absolute path, then that path is used as-is for the location of the socket at which the Wayland server is listening; no qualification inside XDG_RUNTIME_DIR is attempted.If
name
isNULL
and the WAYLAND_DISPLAY environment variable is set to an absolute pathname, then that pathname is used as-is for the socket in the same manner as ifname
held an absolute path. Support for absolute paths inname
and WAYLAND_DISPLAY is present since Wayland version 1.15.
-
void
wl_display_disconnect
(struct wl_display *display)¶ Close a connection to a Wayland display.
Close the connection to
display
and free all resources associated with it.- Parameters
display
: The display context object
-
int
wl_display_get_fd
(struct wl_display *display)¶ Get a display context’s file descriptor.
Return the file descriptor associated with a display so it can be integrated into the client’s main loop.
- Return
- Display object file descriptor
- Parameters
display
: The display context object
-
int
wl_display_roundtrip_queue
(struct wl_display *display, struct wl_event_queue *queue)¶ Block until all pending request are processed by the server.
This function blocks until the server has processed all currently issued requests by sending a request to the display server and waiting for a reply before returning.
- Return
- The number of dispatched events on success or -1 on failure
- Parameters
display
: The display context objectqueue
: The queue on which to run the roundtrip
This function uses wl_display_dispatch_queue() internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.
- Note
- This function may dispatch other events being received on the given queue.
- See
- wl_display_roundtrip()
-
int
wl_display_roundtrip
(struct wl_display *display)¶ Block until all pending request are processed by the server.
This function blocks until the server has processed all currently issued requests by sending a request to the display server and waiting for a reply before returning.
- Return
- The number of dispatched events on success or -1 on failure
- Parameters
display
: The display context object
This function uses wl_display_dispatch_queue() internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.
- Note
- This function may dispatch other events being received on the default queue.
-
int
wl_display_read_events
(struct wl_display *display)¶ Read events from display file descriptor.
Calling this function will result in data available on the display file descriptor being read and read events will be queued on their corresponding event queues.
- Return
- 0 on success or -1 on error. In case of error errno will be set accordingly
- Parameters
display
: The display context object
Before calling this function, depending on what thread it is to be called from, wl_display_prepare_read_queue() or wl_display_prepare_read() needs to be called. See wl_display_prepare_read_queue() for more details.
When being called at a point where other threads have been prepared to read (using wl_display_prepare_read_queue() or wl_display_prepare_read()) this function will sleep until all other prepared threads have either been cancelled (using wl_display_cancel_read()) or them self entered this function. The last thread that calls this function will then read and queue events on their corresponding event queues, and finally wake up all other wl_display_read_events() calls causing them to return.
If a thread cancels a read preparation when all other threads that have prepared to read has either called wl_display_cancel_read() or wl_display_read_events(), all reader threads will return without having read any data.
To dispatch events that may have been queued, call wl_display_dispatch_pending() or wl_display_dispatch_queue_pending().
-
int
wl_display_prepare_read_queue
(struct wl_display *display, struct wl_event_queue *queue)¶ Prepare to read events from the display’s file descriptor to a queue.
This function (or
wl_display_prepare_read()) must be called before reading from the file descriptor using wl_display_read_events(). Calling wl_display_prepare_read_queue() announces the calling thread’s intention to read and ensures that until the thread is ready to read and calls wl_display_read_events(), no other thread will read from the file descriptor. This only succeeds if the event queue is empty, and if not -1 is returned and errno set to EAGAIN.- Return
- 0 on success or -1 if event queue was not empty
- Parameters
display
: The display context objectqueue
: The event queue to use
If a thread successfully calls wl_display_prepare_read_queue(), it must either call wl_display_read_events() when it’s ready or cancel the read intention by calling wl_display_cancel_read().
Use this function before polling on the display fd or integrate the fd into a toolkit event loop in a race-free way. A correct usage would be (with most error checking left out):
while (wl_display_prepare_read_queue(display, queue) != 0) wl_display_dispatch_queue_pending(display, queue); wl_display_flush(display); ret = poll(fds, nfds, -1); if (has_error(ret)) wl_display_cancel_read(display); else wl_display_read_events(display); wl_display_dispatch_queue_pending(display, queue);
Here we call wl_display_prepare_read_queue(), which ensures that between returning from that call and eventually calling wl_display_read_events(), no other thread will read from the fd and queue events in our queue. If the call to wl_display_prepare_read_queue() fails, we dispatch the pending events and try again until we’re successful.
The wl_display_prepare_read_queue() function doesn’t acquire exclusive access to the display’s fd. It only registers that the thread calling this function has intention to read from fd. When all registered readers call wl_display_read_events(), only one (at random) eventually reads and queues the events and the others are sleeping meanwhile. This way we avoid races and still can read from more threads.
-
int
wl_display_prepare_read
(struct wl_display *display)¶ Prepare to read events from the display’s file descriptor.
This function does the same thing as
wl_display_prepare_read_queue() with the default queue passed as the queue.- Return
- 0 on success or -1 if event queue was not empty
- Parameters
display
: The display context object
-
void
wl_display_cancel_read
(struct wl_display *display)¶ Cancel read intention on display’s fd.
After a thread successfully called
wl_display_prepare_read() it must either call wl_display_read_events() or wl_display_cancel_read(). If the threads do not follow this rule it will lead to deadlock.- Parameters
display
: The display context object
-
int
wl_display_dispatch_queue
(struct wl_display *display, struct wl_event_queue *queue)¶ Dispatch events in an event queue.
Dispatch events on the given event queue.
- Return
- The number of dispatched events on success or -1 on failure
- Parameters
display
: The display context objectqueue
: The event queue to dispatch
If the given event queue is empty, this function blocks until there are events to be read from the display fd. Events are read and queued on the appropriate event queues. Finally, events on given event queue are dispatched. On failure -1 is returned and errno set appropriately.
In a multi threaded environment, do not manually wait using poll() (or equivalent) before calling this function, as doing so might cause a dead lock. If external reliance on poll() (or equivalent) is required, see wl_display_prepare_read_queue() of how to do so.
This function is thread safe as long as it dispatches the right queue on the right thread. It is also compatible with the multi thread event reading preparation API (see wl_display_prepare_read_queue()), and uses the equivalent functionality internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.
It can be used as a helper function to ease the procedure of reading and dispatching events.
- Note
- Since Wayland 1.5 the display has an extra queue for its own events (i. e. delete_id). This queue is dispatched always, no matter what queue we passed as an argument to this function. That means that this function can return non-0 value even when it haven’t dispatched any event for the given queue.
- See
- wl_display_dispatch(), wl_display_dispatch_pending(), wl_display_dispatch_queue_pending(), wl_display_prepare_read_queue()
-
int
wl_display_dispatch_queue_pending
(struct wl_display *display, struct wl_event_queue *queue)¶ Dispatch pending events in an event queue.
Dispatch all incoming events for objects assigned to the given event queue. On failure -1 is returned and errno set appropriately. If there are no events queued, this function returns immediately.
- Return
- The number of dispatched events on success or -1 on failure
- Parameters
display
: The display context objectqueue
: The event queue to dispatch
- Since
- 1.0.2
-
int
wl_display_dispatch
(struct wl_display *display)¶ Process incoming events.
Dispatch events on the default event queue.
- Return
- The number of dispatched events on success or -1 on failure
- Parameters
display
: The display context object
If the default event queue is empty, this function blocks until there are events to be read from the display fd. Events are read and queued on the appropriate event queues. Finally, events on the default event queue are dispatched. On failure -1 is returned and errno set appropriately.
In a multi threaded environment, do not manually wait using poll() (or equivalent) before calling this function, as doing so might cause a dead lock. If external reliance on poll() (or equivalent) is required, see wl_display_prepare_read_queue() of how to do so.
This function is thread safe as long as it dispatches the right queue on the right thread. It is also compatible with the multi thread event reading preparation API (see wl_display_prepare_read_queue()), and uses the equivalent functionality internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.
- Note
- It is not possible to check if there are events on the queue or not. For dispatching default queue events without blocking, see wl_display_dispatch_pending().
- See
- wl_display_dispatch_pending(), wl_display_dispatch_queue(), wl_display_read_events()
-
int
wl_display_dispatch_pending
(struct wl_display *display)¶ Dispatch default queue events without reading from the display fd.
This function dispatches events on the main event queue. It does not attempt to read the display fd and simply returns zero if the main queue is empty, i.e., it doesn’t block.
- Return
- The number of dispatched events or -1 on failure
- Parameters
display
: The display context object
-
int
wl_display_get_error
(struct wl_display *display)¶ Retrieve the last error that occurred on a display.
Return the last error that occurred on the display. This may be an error sent by the server or caused by the local client.
- Return
- The last error that occurred on
display
or 0 if no error occurred - Parameters
display
: The display context object
- Note
- Errors are fatal. If this function returns non-zero the display can no longer be used.
-
uint32_t
wl_display_get_protocol_error
(struct wl_display *display, const struct wl_interface **interface, uint32_t *id)¶ Retrieves the information about a protocol error:
int err = wl_display_get_error(display); if (err == EPROTO) { code = wl_display_get_protocol_error(display, &interface, &id); handle_error(code, interface, id); } ...
- Return
- The error code as defined in the interface specification.
- Parameters
display
: The Wayland displayinterface
: if not NULL, stores the interface where the error occurred, or NULL, if unknown.id
: if not NULL, stores the object id that generated the error, or 0, if the object id is unknown. There’s no guarantee the object is still valid; the client must know if it deleted the object.
-
int
wl_display_flush
(struct wl_display *display)¶ Send all buffered requests on the display to the server.
Send all buffered data on the client side to the server. Clients should always call this function before blocking on input from the display fd. On success, the number of bytes sent to the server is returned. On failure, this function returns -1 and errno is set appropriately.
- Return
- The number of bytes sent on success or -1 on failure
- Parameters
display
: The display context object
wl_display_flush() never blocks. It will write as much data as possible, but if all data could not be written, errno will be set to EAGAIN and -1 returned. In that case, use poll on the display file descriptor to wait for it to become writable again.
-
struct wl_event_queue *
-
class
wl_event_queue
¶ - #include <wayland-client-core.h>
A queue for wl_proxy object events.
Event queues allows the events on a display to be handled in a thread-safe manner. See wl_display for details.
Public Functions
-
void
wl_event_queue_destroy
(struct wl_event_queue *queue)¶ Destroy an event queue.
Destroy the given event queue. Any pending event on that queue is discarded.
- Parameters
queue
: The event queue to be destroyed
The wl_display object used to create the queue should not be destroyed until all event queues created with it are destroyed with this function.
-
void
-
struct
wl_interface
¶ - #include <wayland-util.h>
Protocol object interface.
A wl_interface describes the API of a protocol object defined in the Wayland protocol specification. The protocol implementation uses a wl_interface within its marshalling machinery for encoding client requests.
The
name
of a wl_interface is the name of the corresponding protocol interface, andversion
represents the version of the interface. The membersmethod_count
andevent_count
represent the number ofmethods
(requests) andevents
in the respective wl_message members.For example, consider a protocol interface
foo
, marked as version1
, with two requests and one event.<interface name="foo" version="1"> <request name="a"></request> <request name="b"></request> <event name="c"></event> </interface>
Given two wl_message arrays
foo_requests
andfoo_events
, a wl_interface forfoo
might be:struct wl_interface foo_interface = { "foo", 1, 2, foo_requests, 1, foo_events };
- Note
- The server side of the protocol may define interface implementation types that incorporate the term
interface
in their name. Take care to not confuse these server-sidestruct
s with a wl_interface variable whose name also ends ininterface
. For example, while the server may define a typestruct wl_foo_interface
, the client may define astruct wl_interface wl_foo_interface
. - See
- wl_message
- See
- wl_proxy
- See
- Interfaces
- See
- Versioning
Public Members
-
const char *
name
¶ Interface name.
-
int
version
¶ Interface version.
-
int
method_count
¶ Number of methods (requests)
-
const struct wl_message *
methods
¶ Method (request) signatures.
-
int
event_count
¶ Number of events.
-
const struct wl_message *
events
¶ Event signatures.
-
class
wl_list
¶ - #include <wayland-util.h>
Doubly-linked list.
On its own, an instance of
struct wl_list
represents the sentinel head of a doubly-linked list, and must be initialized using wl_list_init(). When empty, the list head’snext
andprev
members point to the list head itself, otherwisenext
references the first element in the list, andprev
refers to the last element in the list.Use the
struct wl_list
type to represent both the list head and the links between elements within the list. Use wl_list_empty() to determine if the list is empty in O(1).All elements in the list must be of the same type. The element type must have a
struct wl_list
member, often namedlink
by convention. Prior to insertion, there is no need to initialize an element’slink
- invoking wl_list_init() on an individual list element’sstruct wl_list
member is unnecessary if the very next operation is wl_list_insert(). However, a common idiom is to initialize an element’slink
prior to removal - ensure safety by invoking wl_list_init() before wl_list_remove().Consider a list reference
struct wl_list foo_list
, an element type asstruct element
, and an element’s link member asstruct wl_list link
.The following code initializes a list and adds three elements to it.
struct wl_list foo_list; struct element { int foo; struct wl_list link; }; struct element e1, e2, e3; wl_list_init(&foo_list); wl_list_insert(&foo_list, &e1.link); // e1 is the first element wl_list_insert(&foo_list, &e2.link); // e2 is now the first element wl_list_insert(&e2.link, &e3.link); // insert e3 after e2
The list now looks like [e2, e3, e1].
The
wl_list
API provides some iterator macros. For example, to iterate a list in ascending order:struct element *e; wl_list_for_each(e, foo_list, link) { do_something_with_element(e); }
See the documentation of each iterator for details.
Public Functions
-
void
wl_list_insert
(struct wl_list *list, struct wl_list *elm)¶ Inserts an element into the list, after the element represented by
list
.When
list
is a reference to the list itself (the head), set the containing struct ofelm
as the first element in the list.- Note
- If
elm
is already part of a list, inserting it again will lead to list corruption. - Parameters
list
: List element after which the new element is insertedelm
: Link of the containing struct to insert into the list
-
void
wl_list_remove
(struct wl_list *elm)¶ Removes an element from the list.
- Note
- This operation leaves
elm
in an invalid state. - Parameters
elm
: Link of the containing struct to remove from the list
-
int
wl_list_length
(const struct wl_list *list)¶ Determines the length of the list.
- Note
- This is an O(n) operation.
- Return
- Number of elements in the list
- Parameters
list
: List whose length is to be determined
-
int
wl_list_empty
(const struct wl_list *list)¶ Determines if the list is empty.
- Return
- 1 if empty, or 0 if not empty
- Parameters
list
: List whose emptiness is to be determined
-
void
wl_list_insert_list
(struct wl_list *list, struct wl_list *other)¶ Inserts all of the elements of one list into another, after the element represented by
list
.- Note
- This leaves
other
in an invalid state. - Parameters
list
: List element after which the other list elements will be insertedother
: List of elements to insert
Public Members
Related
-
wl_list_for_each
(pos, head, member)¶ Iterates over a list.
This macro expresses a for-each iterator for wl_list. Given a list and wl_list link member name (often named
link
by convention), this macro assigns each element in the list topos
, which can then be referenced in a trailing code block. For example, given a wl_list ofstruct message
elements:struct message { char *contents; wl_list link; }; struct wl_list *message_list; // Assume message_list now "contains" many messages struct message *m; wl_list_for_each(m, message_list, link) { do_something_with_message(m); }
- Parameters
pos
: Cursor that each list element will be assigned tohead
: Head of the list to iterate overmember
: Name of the link member within the element struct
-
wl_list_for_each_safe
(pos, tmp, head, member)¶ Iterates over a list, safe against removal of the list element.
- Note
- Only removal of the current element,
pos
, is safe. Removing any other element during traversal may lead to a loop malfunction. - See
- wl_list_for_each()
- Parameters
pos
: Cursor that each list element will be assigned totmp
: Temporary pointer of the same type aspos
head
: Head of the list to iterate overmember
: Name of the link member within the element struct
-
wl_list_for_each_reverse
(pos, head, member)¶ Iterates backwards over a list.
- See
- wl_list_for_each()
- Parameters
pos
: Cursor that each list element will be assigned tohead
: Head of the list to iterate overmember
: Name of the link member within the element struct
-
wl_list_for_each_reverse_safe
(pos, tmp, head, member)¶ Iterates backwards over a list, safe against removal of the list element.
- Note
- Only removal of the current element,
pos
, is safe. Removing any other element during traversal may lead to a loop malfunction. - See
- wl_list_for_each()
- Parameters
pos
: Cursor that each list element will be assigned totmp
: Temporary pointer of the same type aspos
head
: Head of the list to iterate overmember
: Name of the link member within the element struct
-
void
-
struct
wl_message
¶ - #include <wayland-util.h>
Protocol message signature.
A wl_message describes the signature of an actual protocol message, such as a request or event, that adheres to the Wayland protocol wire format. The protocol implementation uses a wl_message within its demarshal machinery for decoding messages between a compositor and its clients. In a sense, a wl_message is to a protocol message like a class is to an object.
The
name
of a wl_message is the name of the corresponding protocol message.The
signature
is an ordered list of symbols representing the data types of message arguments and, optionally, a protocol version and indicators for nullability. A leading integer in thesignature
indicates the since version of the protocol message. A?
preceding a data type symbol indicates that the following argument type is nullable. While it is a protocol violation to send messages with non-nullable arguments set toNULL
, event handlers in clients might still get called with non-nullable object arguments set toNULL
. This can happen when the client destroyed the object being used as argument on its side and an event referencing that object was sent before the server knew about its destruction. As this race cannot be prevented, clients should - as a general rule - program their event handlers such that they can handle object arguments declared non-nullable beingNULL
gracefully.When no arguments accompany a message,
signature
is an empty string.Symbols:
i
: intu
: uintf
: fixeds
: stringo
: objectn
: new_ida
: arrayh
: fd?
: following argument is nullable
While demarshaling primitive arguments is straightforward, when demarshaling messages containing
object
ornew_id
arguments, the protocol implementation often must determine the type of the object. Thetypes
of a wl_message is an array of wl_interface references that correspond too
andn
arguments insignature
, withNULL
placeholders for arguments with non-object types.Consider the protocol event wl_display
delete_id
that has a singleuint
argument. The wl_message is:{ "delete_id", "u", [NULL] }
Here, the message
name
is"delete_id"
, thesignature
is"u"
, and the argumenttypes
is[NULL]
, indicating that theuint
argument has no corresponding wl_interface since it is a primitive argument.In contrast, consider a
wl_foo
interface supporting protocol requestbar
that has existed since version 2, and has two arguments: auint
and an object of typewl_baz_interface
that may beNULL
. Such awl_message
might be:{ "bar", "2u?o", [NULL, &wl_baz_interface] }
Here, the message
name
is"bar"
, and thesignature
is"2u?o"
. Notice how the2
indicates the protocol version, theu
indicates the first argument type isuint
, and the?o
indicates that the second argument is an object that may beNULL
. Lastly, the argumenttypes
array indicates that no wl_interface corresponds to the first argument, while the typewl_baz_interface
corresponds to the second argument.- See
- wl_argument
- See
- wl_interface
- See
- Wire Format
Public Members
-
const char *
name
¶ Message name.
-
const char *
signature
¶ Message signature.
-
const struct wl_interface **
types
¶ Object argument interfaces.
-
class
wl_object
¶ - #include <wayland-util.h>
A protocol object.
A
wl_object
is an opaque struct identifying the protocol object underlying awl_proxy
orwl_resource
.- Note
- Functions accessing a
wl_object
are not normally used by client code. Clients should normally use the higher level interface generated by the scanner to interact with compositor objects.
-
class
wl_proxy
¶ - #include <wayland-client-core.h>
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 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 wl_proxy_add_listener().
- Note
- With the exception of function 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.
Public Functions
-
struct wl_proxy *
wl_proxy_create
(struct wl_proxy *factory, const struct wl_interface *interface)¶ Create a proxy object with a given interface.
This function creates a new proxy object with the supplied interface. The proxy object will have an id assigned from the client id space. The id should be created on the compositor side by sending an appropriate request with
wl_proxy_marshal().- Return
- A newly allocated proxy object or NULL on failure
- Parameters
factory
: Factory proxy objectinterface
: Interface the proxy object should use
The proxy will inherit the display and event queue of the factory object.
- Note
- This should not normally be used by non-generated code.
- See
- wl_display, wl_event_queue, wl_proxy_marshal()
-
void
wl_proxy_destroy
(struct wl_proxy *proxy)¶ Destroy a proxy object.
proxy
must not be a proxy wrapper.- Parameters
proxy
: The proxy to be destroyed
-
int
wl_proxy_add_listener
(struct wl_proxy *proxy, void (**implementation)(void), void *data, )¶ Set a proxy’s listener.
Set proxy’s listener to
implementation
and its user data todata
. If a listener has already been set, this function fails and nothing is changed.- Return
- 0 on success or -1 on failure
- Parameters
proxy
: The proxy objectimplementation
: The listener to be added to proxydata
: User data to be associated with the proxy
implementation
is a vector of function pointers. For an opcoden
,implementation
[n] should point to the handler ofn
for the given object.proxy
must not be a proxy wrapper.
-
const void *
wl_proxy_get_listener
(struct wl_proxy *proxy)¶ Get a proxy’s listener.
Gets the address to the proxy’s listener; which is the listener set with
wl_proxy_add_listener.- Return
- The address of the proxy’s listener or NULL if no listener is set
- Parameters
proxy
: The proxy object
This function is useful in clients with multiple listeners on the same interface to allow the identification of which code to execute.
-
int
wl_proxy_add_dispatcher
(struct wl_proxy *proxy, wl_dispatcher_func_t dispatcher, const void *implementation, void *data)¶ Set a proxy’s listener (with dispatcher)
Set proxy’s listener to use
dispatcher_func
as its dispatcher anddispatcher_data
as its dispatcher-specific implementation and its user data todata
. If a listener has already been set, this function fails and nothing is changed.- Return
- 0 on success or -1 on failure
- Parameters
proxy
: The proxy objectdispatcher
: The dispatcher to be used for this proxyimplementation
: The dispatcher-specific listener implementationdata
: User data to be associated with the proxy
The exact details of dispatcher_data depend on the dispatcher used. This function is intended to be used by language bindings, not user code.
proxy
must not be a proxy wrapper.
-
struct wl_proxy *
wl_proxy_marshal_array_constructor
(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface)¶ Prepare a request to be sent to the compositor.
This function translates a request given an opcode, an interface and a
wl_argument array to the wire format and writes it to the connection buffer.- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sentargs
: Extra arguments for the given requestinterface
: The interface to use for the new proxy
For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will inherit their version from their parent.
- Note
- This is intended to be used by language bindings and not in non-generated code.
- See
- wl_proxy_marshal()
-
struct wl_proxy *
wl_proxy_marshal_array_constructor_versioned
(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface, uint32_t version)¶ Prepare a request to be sent to the compositor.
Translates the request given by opcode and the extra arguments into the wire format and write it to the connection buffer. This version takes an array of the union type
wl_argument.- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sentargs
: Extra arguments for the given requestinterface
: The interface to use for the new proxyversion
: The protocol object version for the new proxy
For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will have the version specified.
- Note
- This is intended to be used by language bindings and not in non-generated code.
- See
- wl_proxy_marshal()
-
void
wl_proxy_marshal
(struct wl_proxy *proxy, uint32_t opcode, ...)¶ Prepare a request to be sent to the compositor.
This function is similar to
wl_proxy_marshal_constructor(), except it doesn’t create proxies for new-id arguments.- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sent...
: Extra arguments for the given request
- Note
- This should not normally be used by non-generated code.
- See
- wl_proxy_create()
-
struct wl_proxy *
wl_proxy_marshal_constructor
(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, ...)¶ Prepare a request to be sent to the compositor.
This function translates a request given an opcode, an interface and extra arguments to the wire format and writes it to the connection buffer. The types of the extra arguments must correspond to the argument types of the method associated with the opcode in the interface.
- Return
- A new wl_proxy for the new_id argument or NULL on error
- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sentinterface
: The interface to use for the new proxy...
: Extra arguments for the given request
For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will inherit their version from their parent.
- Note
- This should not normally be used by non-generated code.
-
struct wl_proxy *
wl_proxy_marshal_constructor_versioned
(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version, ...)¶ Prepare a request to be sent to the compositor.
Translates the request given by opcode and the extra arguments into the wire format and write it to the connection buffer.
- Return
- A new wl_proxy for the new_id argument or NULL on error
- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sentinterface
: The interface to use for the new proxyversion
: The protocol object version of the new proxy...
: Extra arguments for the given request
For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will have the version specified.
- Note
- This should not normally be used by non-generated code.
-
void
wl_proxy_marshal_array
(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args)¶ Prepare a request to be sent to the compositor.
This function is similar to
wl_proxy_marshal_array_constructor(), except it doesn’t create proxies for new-id arguments.- Parameters
proxy
: The proxy objectopcode
: Opcode of the request to be sentargs
: Extra arguments for the given request
- Note
- This is intended to be used by language bindings and not in non-generated code.
- See
- wl_proxy_marshal()
-
void
wl_proxy_set_user_data
(struct wl_proxy *proxy, void *user_data)¶ Set the user data associated with a proxy.
Set the user data associated with
proxy
. When events for this proxy are received,user_data
will be supplied to its listener.- Parameters
proxy
: The proxy objectuser_data
: The data to be associated with proxy
-
void *
wl_proxy_get_user_data
(struct wl_proxy *proxy)¶ Get the user data associated with a proxy.
- Return
- The user data associated with proxy
- Parameters
proxy
: The proxy object
-
uint32_t
wl_proxy_get_version
(struct wl_proxy *proxy)¶ Get the protocol object version of a proxy object.
Gets the protocol object version of a proxy object, or 0 if the proxy was created with unversioned API.
- Return
- The protocol object version of the proxy or 0
- Parameters
proxy
: The proxy object
A returned value of 0 means that no version information is available, so the caller must make safe assumptions about the object’s real version.
wl_display’s version will always return 0.
-
uint32_t
wl_proxy_get_id
(struct wl_proxy *proxy)¶ Get the id of a proxy object.
- Return
- The id the object associated with the proxy
- Parameters
proxy
: The proxy object
-
const char *
wl_proxy_get_class
(struct wl_proxy *proxy)¶ Get the interface name (class) of a proxy object.
- Return
- The interface name of the object associated with the proxy
- Parameters
proxy
: The proxy object
-
void
wl_proxy_set_queue
(struct wl_proxy *proxy, struct wl_event_queue *queue)¶ Assign a proxy to an event queue.
Assign proxy to event queue. Events coming from
proxy
will be queued inqueue
from now. If queue is NULL, then the display’s default queue is set to the proxy.- Parameters
proxy
: The proxy objectqueue
: The event queue that will handle this proxy or NULL
- Note
- By default, the queue set in proxy is the one inherited from parent.
- See
- wl_display_dispatch_queue()
-
void *
wl_proxy_create_wrapper
(void *proxy)¶ Create a proxy wrapper for making queue assignments thread-safe.
A proxy wrapper is type of ‘struct
wl_proxy’ instance that can be used when sending requests instead of using the original proxy. A proxy wrapper does not have an implementation or dispatcher, and events received on the object is still emitted on the original proxy. Trying to set an implementation or dispatcher will have no effect but result in a warning being logged.- Return
- A proxy wrapper for the given proxy or NULL on failure
- Parameters
proxy
: The proxy object to be wrapped
Setting the proxy queue of the proxy wrapper will make new objects created using the proxy wrapper use the set proxy queue. Even though there is no implementation nor dispatcher, the proxy queue can be changed. This will affect the default queue of new objects created by requests sent via the proxy wrapper.
A proxy wrapper can only be destroyed using wl_proxy_wrapper_destroy().
A proxy wrapper must be destroyed before the proxy it was created from.
If a user reads and dispatches events on more than one thread, it is necessary to use a proxy wrapper when sending requests on objects when the intention is that a newly created proxy is to use a proxy queue different from the proxy the request was sent on, as creating the new proxy and then setting the queue is not thread safe.
For example, a module that runs using its own proxy queue that needs to do display roundtrip must wrap the wl_display proxy object before sending the wl_display.sync request. For example:
struct wl_event_queue *queue = ...; struct wl_display *wrapped_display; struct wl_callback *callback; wrapped_display = wl_proxy_create_wrapper(display); wl_proxy_set_queue((struct wl_proxy *) wrapped_display, queue); callback = wl_display_sync(wrapped_display); wl_proxy_wrapper_destroy(wrapped_display); wl_callback_add_listener(callback, ...);
-
void
wl_proxy_wrapper_destroy
(void *proxy_wrapper)¶ Destroy a proxy wrapper.
- Parameters
proxy_wrapper
: The proxy wrapper to be destroyed
-
file
wayland-client-core.h
- #include <stdint.h>#include “wayland-util.h”#include “wayland-version.h”
Functions
-
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)
-
void *
wl_proxy_create_wrapper
(void *proxy)
-
void
wl_proxy_wrapper_destroy
(void *proxy_wrapper)
-
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_constructor_versioned
(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version, ...)
-
struct wl_proxy *
wl_proxy_marshal_array_constructor
(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface)
-
struct wl_proxy *
wl_proxy_marshal_array_constructor_versioned
(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface, uint32_t version)
-
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_version
(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)¶
-
void
-
file
wayland-client.c
- #include <stdlib.h>#include <stdint.h>#include <stddef.h>#include <stdio.h>#include <stdbool.h>#include <errno.h>#include <string.h>#include <unistd.h>#include <sys/socket.h>#include <sys/un.h>#include <ctype.h>#include <assert.h>#include <fcntl.h>#include <poll.h>#include <pthread.h>#include “wayland-util.h”#include “wayland-os.h”#include “wayland-client.h”#include “wayland-private.h”#include <stdarg.h>#include “/home/mvlad/src/wayland/src/wayland-server-core.h”#include <sys/types.h>#include “/home/mvlad/src/wayland/src/wayland-version.h”
Defines
-
_GNU_SOURCE
¶
Functions
-
static void
display_wakeup_threads
(struct wl_display *display)¶ This helper function wakes up all threads that are waiting for display->reader_cond (i.
e. when reading is done, canceled, or an error occurred)
NOTE: must be called with display->mutex locked
-
static void
display_fatal_error
(struct wl_display *display, int error)¶ This function is called for local errors (no memory, server hung up)
- Note
- this function is called with display mutex locked
- Parameters
display
:error
: error value (EINVAL, EFAULT, …)
-
static void
display_protocol_error
(struct wl_display *display, uint32_t code, uint32_t id, const struct wl_interface *intf)¶ This function is called for error events and indicates that in some object an error occurred.
The difference between this function and display_fatal_error() is that this one handles errors that will come by wire, whereas display_fatal_error() is called for local errors.
- Parameters
display
:code
: error codeid
: id of the object that generated the errorintf
: protocol interface
-
static void
wl_event_queue_init
(struct wl_event_queue *queue, struct wl_display *display)¶
-
static void
validate_closure_objects
(struct wl_closure *closure)¶
-
static void
destroy_queued_closure
(struct wl_closure *closure)¶
-
static void
wl_event_queue_release
(struct wl_event_queue *queue)¶
-
static int
message_count_fds
(const char *signature)¶
-
static enum wl_iterator_result
free_zombies
(void *element, void *data, uint32_t flags)¶
-
static struct wl_proxy *
proxy_create
(struct wl_proxy *factory, const struct wl_interface *interface, uint32_t version)¶
-
static struct wl_proxy *
wl_proxy_create_for_id
(struct wl_proxy *factory, uint32_t id, const struct wl_interface *interface)¶
-
static struct wl_proxy *
create_outgoing_proxy
(struct wl_proxy *proxy, const struct wl_message *message, union wl_argument *args, const struct wl_interface *interface, uint32_t version)¶
-
static void
display_handle_error
(void *data, struct wl_display *display, void *object, uint32_t code, const char *message)¶
-
static void
display_handle_delete_id
(void *data, struct wl_display *display, uint32_t id)¶
-
static int
connect_to_socket
(const char *name)¶
-
static void
sync_callback
(void *data, struct wl_callback *callback, uint32_t serial)¶
-
static void
increase_closure_args_refcount
(struct wl_closure *closure)¶
-
static int
queue_event
(struct wl_display *display, int len)¶
-
static void
dispatch_event
(struct wl_display *display, struct wl_event_queue *queue)¶
-
static int
read_events
(struct wl_display *display)¶
-
static void
cancel_read
(struct wl_display *display)¶
-
static int
dispatch_queue
(struct wl_display *display, struct wl_event_queue *queue)¶
-
static int
wl_display_poll
(struct wl_display *display, short int events)¶
-
void
wl_log_set_handler_client
(wl_log_func_t handler)
Variables
-
int
debug_client
= 0¶
-
const struct wl_display_listener
display_listener
= {display_handle_error, display_handle_delete_id}¶
-
const struct wl_callback_listener
sync_listener
= { sync_callback }¶
-
-
file
wayland-client.h
- #include “wayland-client-core.h”#include “wayland-client-protocol.h”
Include the client API and protocol C API.
- Warning
- Use of this header file is discouraged. Prefer including wayland-client-core.h instead, which does not include the client protocol header and as such only defines the library API.
-
file
wayland-util.h
- #include <math.h>#include <stddef.h>#include <inttypes.h>#include <stdarg.h>
Utility classes, functions, and macros.
Defines
-
WL_EXPORT
¶ Visibility attribute.
-
WL_DEPRECATED
¶ Deprecated attribute.
-
WL_PRINTF
(x, y)¶ Printf-style argument attribute.
- See
- https://gcc.gnu.org/onlinedocs/gcc-3.2.1/gcc/Function-Attributes.html
- Parameters
x
: Ordinality of the format string argumenty
: Ordinality of the argument to check against the format string
-
wl_container_of
(ptr, sample, member)¶ Retrieves a pointer to a containing struct, given a member name.
This macro allows “conversion” from a pointer to a member to its containing struct. This is useful if you have a contained item like a wl_list, wl_listener, or wl_signal, provided via a callback or other means, and would like to retrieve the struct that contains it.
To demonstrate, the following example retrieves a pointer to
example_container
given only itsdestroy_listener
member:struct example_container { struct wl_listener destroy_listener; // other members... }; void example_container_destroy(struct wl_listener *listener, void *data) { struct example_container *ctr; ctr = wl_container_of(listener, ctr, destroy_listener); // destroy ctr... }
- Note
sample
need not be a valid pointer. A null or uninitialised pointer is sufficient.- Return
- The container for the specified pointer
- Parameters
ptr
: Valid pointer to the contained membersample
: Pointer to a struct whose type containsptr
member
: Named location ofptr
within thesample
type
Typedefs
-
typedef int32_t
wl_fixed_t
¶ Fixed-point number.
A
wl_fixed_t
is a 24.8 signed fixed-point number with a sign bit, 23 bits of integer precision and 8 bits of decimal precision. Considerwl_fixed_t
as an opaque struct with methods that facilitate conversion to and fromdouble
andint
types.
-
typedef int (*
wl_dispatcher_func_t
)(const void *, void *, uint32_t, const struct wl_message *, union wl_argument *)¶ Dispatcher function type alias.
A dispatcher is a function that handles the emitting of callbacks in client code. For programs directly using the C library, this is done by using libffi to call function pointers. When binding to languages other than C, dispatchers provide a way to abstract the function calling process to be friendlier to other function calling systems.
A dispatcher takes five arguments: The first is the dispatcher-specific implementation associated with the target object. The second is the object upon which the callback is being invoked (either wl_proxy or wl_resource). The third and fourth arguments are the opcode and the wl_message corresponding to the callback. The final argument is an array of arguments received from the other process via the wire protocol.
- Return
- 0 on success, or -1 on failure
- Parameters
const void *
: Dispatcher-specific implementation datavoid *
: Callback invocation target (wl_proxy orwl_resource
)uint32_t
: Callback opcodeconst struct wl_message *
: Callback message signatureunion wl_argument *
: Array of received arguments
-
typedef void (*
wl_log_func_t
)(const char *, va_list)¶ Log function type alias.
The C implementation of the Wayland protocol abstracts the details of logging. Users may customize the logging behavior, with a function conforming to the
wl_log_func_t
type, viawl_log_set_handler_client
andwl_log_set_handler_server
.A
wl_log_func_t
must conform to the expectations ofvprintf
, and expects two arguments: a string to write and a corresponding variable argument list. While the string to write may contain format specifiers and use values in the variable argument list, the behavior of anywl_log_func_t
depends on the implementation.- Note
- Take care to not confuse this with
wl_protocol_logger_func_t
, which is a specific server-side logger for requests and events. - See
- wl_log_set_handler_client
- See
- wl_log_set_handler_server
- Parameters
const char *
: String to write to the log, containing optional format specifiersva_list
: Variable argument list
Enums
Functions
-
static double
wl_fixed_to_double
(wl_fixed_t f)¶ Converts a fixed-point number to a floating-point number.
- Return
- Floating-point representation of the fixed-point argument
- Parameters
f
: Fixed-point number to convert
-
static wl_fixed_t
wl_fixed_from_double
(double d)¶ Converts a floating-point number to a fixed-point number.
- Return
- Fixed-point representation of the floating-point argument
- Parameters
d
: Floating-point number to convert
-
static int
wl_fixed_to_int
(wl_fixed_t f)¶ Converts a fixed-point number to an integer.
- Return
- Integer component of the fixed-point argument
- Parameters
f
: Fixed-point number to convert
-
static wl_fixed_t
wl_fixed_from_int
(int i)¶ Converts an integer to a fixed-point number.
- Return
- Fixed-point representation of the integer argument
- Parameters
i
: Integer to convert
-
-
dir
/home/mvlad/src/wayland/src