"Fossies" - the Fresh Open Source Software Archive

Member "wayland-1.18.0/src/wayland-server-core.h" (11 Feb 2020, 19021 Bytes) of package /linux/misc/wayland-1.18.0.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "wayland-server-core.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.17.0_vs_1.18.0.

    1 /*
    2  * Copyright © 2008 Kristian Høgsberg
    3  *
    4  * Permission is hereby granted, free of charge, to any person obtaining
    5  * a copy of this software and associated documentation files (the
    6  * "Software"), to deal in the Software without restriction, including
    7  * without limitation the rights to use, copy, modify, merge, publish,
    8  * distribute, sublicense, and/or sell copies of the Software, and to
    9  * permit persons to whom the Software is furnished to do so, subject to
   10  * the following conditions:
   11  *
   12  * The above copyright notice and this permission notice (including the
   13  * next paragraph) shall be included in all copies or substantial
   14  * portions of the Software.
   15  *
   16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   20  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   21  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   23  * SOFTWARE.
   24  */
   25 
   26 #ifndef WAYLAND_SERVER_CORE_H
   27 #define WAYLAND_SERVER_CORE_H
   28 
   29 #include <sys/types.h>
   30 #include <stdint.h>
   31 #include <stdbool.h>
   32 #include "wayland-util.h"
   33 #include "wayland-version.h"
   34 
   35 #ifdef  __cplusplus
   36 extern "C" {
   37 #endif
   38 
   39 enum {
   40     WL_EVENT_READABLE = 0x01,
   41     WL_EVENT_WRITABLE = 0x02,
   42     WL_EVENT_HANGUP   = 0x04,
   43     WL_EVENT_ERROR    = 0x08
   44 };
   45 
   46 /** File descriptor dispatch function type
   47  *
   48  * Functions of this type are used as callbacks for file descriptor events.
   49  *
   50  * \param fd The file descriptor delivering the event.
   51  * \param mask Describes the kind of the event as a bitwise-or of:
   52  * \c WL_EVENT_READABLE, \c WL_EVENT_WRITABLE, \c WL_EVENT_HANGUP,
   53  * \c WL_EVENT_ERROR.
   54  * \param data The user data argument of the related wl_event_loop_add_fd()
   55  * call.
   56  * \return If the event source is registered for re-check with
   57  * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
   58  * If not registered, the return value is ignored and should be zero.
   59  *
   60  * \sa wl_event_loop_add_fd()
   61  * \memberof wl_event_source
   62  */
   63 typedef int (*wl_event_loop_fd_func_t)(int fd, uint32_t mask, void *data);
   64 
   65 /** Timer dispatch function type
   66  *
   67  * Functions of this type are used as callbacks for timer expiry.
   68  *
   69  * \param data The user data argument of the related wl_event_loop_add_timer()
   70  * call.
   71  * \return If the event source is registered for re-check with
   72  * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
   73  * If not registered, the return value is ignored and should be zero.
   74  *
   75  * \sa wl_event_loop_add_timer()
   76  * \memberof wl_event_source
   77  */
   78 typedef int (*wl_event_loop_timer_func_t)(void *data);
   79 
   80 /** Signal dispatch function type
   81  *
   82  * Functions of this type are used as callbacks for (POSIX) signals.
   83  *
   84  * \param signal_number
   85  * \param data The user data argument of the related wl_event_loop_add_signal()
   86  * call.
   87  * \return If the event source is registered for re-check with
   88  * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
   89  * If not registered, the return value is ignored and should be zero.
   90  *
   91  * \sa wl_event_loop_add_signal()
   92  * \memberof wl_event_source
   93  */
   94 typedef int (*wl_event_loop_signal_func_t)(int signal_number, void *data);
   95 
   96 /** Idle task function type
   97  *
   98  * Functions of this type are used as callbacks before blocking in
   99  * wl_event_loop_dispatch().
  100  *
  101  * \param data The user data argument of the related wl_event_loop_add_idle()
  102  * call.
  103  *
  104  * \sa wl_event_loop_add_idle() wl_event_loop_dispatch()
  105  * \memberof wl_event_source
  106  */
  107 typedef void (*wl_event_loop_idle_func_t)(void *data);
  108 
  109 /** \struct wl_event_loop
  110  *
  111  * \brief An event loop context
  112  *
  113  * Usually you create an event loop context, add sources to it, and call
  114  * wl_event_loop_dispatch() in a loop to process events.
  115  *
  116  * \sa wl_event_source
  117  */
  118 
  119 /** \struct wl_event_source
  120  *
  121  * \brief An abstract event source
  122  *
  123  * This is the generic type for fd, timer, signal, and idle sources.
  124  * Functions that operate on specific source types must not be used with
  125  * a different type, even if the function signature allows it.
  126  */
  127 
  128 struct wl_event_loop *
  129 wl_event_loop_create(void);
  130 
  131 void
  132 wl_event_loop_destroy(struct wl_event_loop *loop);
  133 
  134 struct wl_event_source *
  135 wl_event_loop_add_fd(struct wl_event_loop *loop,
  136              int fd, uint32_t mask,
  137              wl_event_loop_fd_func_t func,
  138              void *data);
  139 
  140 int
  141 wl_event_source_fd_update(struct wl_event_source *source, uint32_t mask);
  142 
  143 struct wl_event_source *
  144 wl_event_loop_add_timer(struct wl_event_loop *loop,
  145             wl_event_loop_timer_func_t func,
  146             void *data);
  147 
  148 struct wl_event_source *
  149 wl_event_loop_add_signal(struct wl_event_loop *loop,
  150              int signal_number,
  151              wl_event_loop_signal_func_t func,
  152              void *data);
  153 
  154 int
  155 wl_event_source_timer_update(struct wl_event_source *source,
  156                  int ms_delay);
  157 
  158 int
  159 wl_event_source_remove(struct wl_event_source *source);
  160 
  161 void
  162 wl_event_source_check(struct wl_event_source *source);
  163 
  164 int
  165 wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout);
  166 
  167 void
  168 wl_event_loop_dispatch_idle(struct wl_event_loop *loop);
  169 
  170 struct wl_event_source *
  171 wl_event_loop_add_idle(struct wl_event_loop *loop,
  172                wl_event_loop_idle_func_t func,
  173                void *data);
  174 
  175 int
  176 wl_event_loop_get_fd(struct wl_event_loop *loop);
  177 
  178 struct wl_listener;
  179 
  180 typedef void (*wl_notify_func_t)(struct wl_listener *listener, void *data);
  181 
  182 void
  183 wl_event_loop_add_destroy_listener(struct wl_event_loop *loop,
  184                    struct wl_listener *listener);
  185 
  186 struct wl_listener *
  187 wl_event_loop_get_destroy_listener(struct wl_event_loop *loop,
  188                    wl_notify_func_t notify);
  189 
  190 struct wl_display *
  191 wl_display_create(void);
  192 
  193 void
  194 wl_display_destroy(struct wl_display *display);
  195 
  196 struct wl_event_loop *
  197 wl_display_get_event_loop(struct wl_display *display);
  198 
  199 int
  200 wl_display_add_socket(struct wl_display *display, const char *name);
  201 
  202 const char *
  203 wl_display_add_socket_auto(struct wl_display *display);
  204 
  205 int
  206 wl_display_add_socket_fd(struct wl_display *display, int sock_fd);
  207 
  208 void
  209 wl_display_terminate(struct wl_display *display);
  210 
  211 void
  212 wl_display_run(struct wl_display *display);
  213 
  214 void
  215 wl_display_flush_clients(struct wl_display *display);
  216 
  217 void
  218 wl_display_destroy_clients(struct wl_display *display);
  219 
  220 struct wl_client;
  221 
  222 typedef void (*wl_global_bind_func_t)(struct wl_client *client, void *data,
  223                       uint32_t version, uint32_t id);
  224 
  225 uint32_t
  226 wl_display_get_serial(struct wl_display *display);
  227 
  228 uint32_t
  229 wl_display_next_serial(struct wl_display *display);
  230 
  231 void
  232 wl_display_add_destroy_listener(struct wl_display *display,
  233                 struct wl_listener *listener);
  234 
  235 void
  236 wl_display_add_client_created_listener(struct wl_display *display,
  237                     struct wl_listener *listener);
  238 
  239 struct wl_listener *
  240 wl_display_get_destroy_listener(struct wl_display *display,
  241                 wl_notify_func_t notify);
  242 
  243 struct wl_global *
  244 wl_global_create(struct wl_display *display,
  245          const struct wl_interface *interface,
  246          int version,
  247          void *data, wl_global_bind_func_t bind);
  248 
  249 void
  250 wl_global_remove(struct wl_global *global);
  251 
  252 void
  253 wl_global_destroy(struct wl_global *global);
  254 
  255 /** A filter function for wl_global objects
  256  *
  257  * \param client The client object
  258  * \param global The global object to show or hide
  259  * \param data   The user data pointer
  260  *
  261  * A filter function enables the server to decide which globals to
  262  * advertise to each client.
  263  *
  264  * When a wl_global filter is set, the given callback funtion will be
  265  * called during wl_global advertisment and binding.
  266  *
  267  * This function should return true if the global object should be made
  268  * visible to the client or false otherwise.
  269  */
  270 typedef bool (*wl_display_global_filter_func_t)(const struct wl_client *client,
  271                         const struct wl_global *global,
  272                         void *data);
  273 
  274 void
  275 wl_display_set_global_filter(struct wl_display *display,
  276                  wl_display_global_filter_func_t filter,
  277                  void *data);
  278 
  279 const struct wl_interface *
  280 wl_global_get_interface(const struct wl_global *global);
  281 
  282 void *
  283 wl_global_get_user_data(const struct wl_global *global);
  284 
  285 void
  286 wl_global_set_user_data(struct wl_global *global, void *data);
  287 
  288 struct wl_client *
  289 wl_client_create(struct wl_display *display, int fd);
  290 
  291 struct wl_list *
  292 wl_display_get_client_list(struct wl_display *display);
  293 
  294 struct wl_list *
  295 wl_client_get_link(struct wl_client *client);
  296 
  297 struct wl_client *
  298 wl_client_from_link(struct wl_list *link);
  299 
  300 /** Iterate over a list of clients. */
  301 #define wl_client_for_each(client, list)                \
  302     for (client = wl_client_from_link((list)->next);    \
  303          wl_client_get_link(client) != (list);          \
  304          client = wl_client_from_link(wl_client_get_link(client)->next))
  305 
  306 void
  307 wl_client_destroy(struct wl_client *client);
  308 
  309 void
  310 wl_client_flush(struct wl_client *client);
  311 
  312 void
  313 wl_client_get_credentials(struct wl_client *client,
  314               pid_t *pid, uid_t *uid, gid_t *gid);
  315 
  316 int
  317 wl_client_get_fd(struct wl_client *client);
  318 
  319 void
  320 wl_client_add_destroy_listener(struct wl_client *client,
  321                    struct wl_listener *listener);
  322 
  323 struct wl_listener *
  324 wl_client_get_destroy_listener(struct wl_client *client,
  325                    wl_notify_func_t notify);
  326 
  327 struct wl_resource *
  328 wl_client_get_object(struct wl_client *client, uint32_t id);
  329 
  330 void
  331 wl_client_post_no_memory(struct wl_client *client);
  332 
  333 void
  334 wl_client_post_implementation_error(struct wl_client *client,
  335                                     const char* msg, ...) WL_PRINTF(2,3);
  336 
  337 void
  338 wl_client_add_resource_created_listener(struct wl_client *client,
  339                                         struct wl_listener *listener);
  340 
  341 typedef enum wl_iterator_result (*wl_client_for_each_resource_iterator_func_t)(
  342                         struct wl_resource *resource,
  343                         void *user_data);
  344 
  345 void
  346 wl_client_for_each_resource(struct wl_client *client,
  347                             wl_client_for_each_resource_iterator_func_t iterator,
  348                             void *user_data);
  349 
  350 /** \class wl_listener
  351  *
  352  * \brief A single listener for Wayland signals
  353  *
  354  * wl_listener provides the means to listen for wl_signal notifications. Many
  355  * Wayland objects use wl_listener for notification of significant events like
  356  * object destruction.
  357  *
  358  * Clients should create wl_listener objects manually and can register them as
  359  * listeners to signals using #wl_signal_add, assuming the signal is
  360  * directly accessible. For opaque structs like wl_event_loop, adding a
  361  * listener should be done through provided accessor methods. A listener can
  362  * only listen to one signal at a time.
  363  *
  364  * \code
  365  * struct wl_listener your_listener;
  366  *
  367  * your_listener.notify = your_callback_method;
  368  *
  369  * // Direct access
  370  * wl_signal_add(&some_object->destroy_signal, &your_listener);
  371  *
  372  * // Accessor access
  373  * wl_event_loop *loop = ...;
  374  * wl_event_loop_add_destroy_listener(loop, &your_listener);
  375  * \endcode
  376  *
  377  * If the listener is part of a larger struct, #wl_container_of can be used
  378  * to retrieve a pointer to it:
  379  *
  380  * \code
  381  * void your_listener(struct wl_listener *listener, void *data)
  382  * {
  383  *  struct your_data *data;
  384  *
  385  *  your_data = wl_container_of(listener, data, your_member_name);
  386  * }
  387  * \endcode
  388  *
  389  * If you need to remove a listener from a signal, use wl_list_remove().
  390  *
  391  * \code
  392  * wl_list_remove(&your_listener.link);
  393  * \endcode
  394  *
  395  * \sa wl_signal
  396  */
  397 struct wl_listener {
  398     struct wl_list link;
  399     wl_notify_func_t notify;
  400 };
  401 
  402 /** \class wl_signal
  403  *
  404  * \brief A source of a type of observable event
  405  *
  406  * Signals are recognized points where significant events can be observed.
  407  * Compositors as well as the server can provide signals. Observers are
  408  * wl_listener's that are added through #wl_signal_add. Signals are emitted
  409  * using #wl_signal_emit, which will invoke all listeners until that
  410  * listener is removed by wl_list_remove() (or whenever the signal is
  411  * destroyed).
  412  *
  413  * \sa wl_listener for more information on using wl_signal
  414  */
  415 struct wl_signal {
  416     struct wl_list listener_list;
  417 };
  418 
  419 /** Initialize a new \ref wl_signal for use.
  420  *
  421  * \param signal The signal that will be initialized
  422  *
  423  * \memberof wl_signal
  424  */
  425 static inline void
  426 wl_signal_init(struct wl_signal *signal)
  427 {
  428     wl_list_init(&signal->listener_list);
  429 }
  430 
  431 /** Add the specified listener to this signal.
  432  *
  433  * \param signal The signal that will emit events to the listener
  434  * \param listener The listener to add
  435  *
  436  * \memberof wl_signal
  437  */
  438 static inline void
  439 wl_signal_add(struct wl_signal *signal, struct wl_listener *listener)
  440 {
  441     wl_list_insert(signal->listener_list.prev, &listener->link);
  442 }
  443 
  444 /** Gets the listener struct for the specified callback.
  445  *
  446  * \param signal The signal that contains the specified listener
  447  * \param notify The listener that is the target of this search
  448  * \return the list item that corresponds to the specified listener, or NULL
  449  * if none was found
  450  *
  451  * \memberof wl_signal
  452  */
  453 static inline struct wl_listener *
  454 wl_signal_get(struct wl_signal *signal, wl_notify_func_t notify)
  455 {
  456     struct wl_listener *l;
  457 
  458     wl_list_for_each(l, &signal->listener_list, link)
  459         if (l->notify == notify)
  460             return l;
  461 
  462     return NULL;
  463 }
  464 
  465 /** Emits this signal, notifying all registered listeners.
  466  *
  467  * \param signal The signal object that will emit the signal
  468  * \param data The data that will be emitted with the signal
  469  *
  470  * \memberof wl_signal
  471  */
  472 static inline void
  473 wl_signal_emit(struct wl_signal *signal, void *data)
  474 {
  475     struct wl_listener *l, *next;
  476 
  477     wl_list_for_each_safe(l, next, &signal->listener_list, link)
  478         l->notify(l, data);
  479 }
  480 
  481 typedef void (*wl_resource_destroy_func_t)(struct wl_resource *resource);
  482 
  483 /*
  484  * Post an event to the client's object referred to by 'resource'.
  485  * 'opcode' is the event number generated from the protocol XML
  486  * description (the event name). The variable arguments are the event
  487  * parameters, in the order they appear in the protocol XML specification.
  488  *
  489  * The variable arguments' types are:
  490  * - type=uint: uint32_t
  491  * - type=int:      int32_t
  492  * - type=fixed:    wl_fixed_t
  493  * - type=string:   (const char *) to a nil-terminated string
  494  * - type=array:    (struct wl_array *)
  495  * - type=fd:       int, that is an open file descriptor
  496  * - type=new_id:   (struct wl_object *) or (struct wl_resource *)
  497  * - type=object:   (struct wl_object *) or (struct wl_resource *)
  498  */
  499 void
  500 wl_resource_post_event(struct wl_resource *resource,
  501                uint32_t opcode, ...);
  502 
  503 void
  504 wl_resource_post_event_array(struct wl_resource *resource,
  505                  uint32_t opcode, union wl_argument *args);
  506 
  507 void
  508 wl_resource_queue_event(struct wl_resource *resource,
  509             uint32_t opcode, ...);
  510 
  511 void
  512 wl_resource_queue_event_array(struct wl_resource *resource,
  513                   uint32_t opcode, union wl_argument *args);
  514 
  515 /* msg is a printf format string, variable args are its args. */
  516 void
  517 wl_resource_post_error(struct wl_resource *resource,
  518                uint32_t code, const char *msg, ...) WL_PRINTF(3, 4);
  519 
  520 void
  521 wl_resource_post_no_memory(struct wl_resource *resource);
  522 
  523 struct wl_display *
  524 wl_client_get_display(struct wl_client *client);
  525 
  526 struct wl_resource *
  527 wl_resource_create(struct wl_client *client,
  528            const struct wl_interface *interface,
  529            int version, uint32_t id);
  530 
  531 void
  532 wl_resource_set_implementation(struct wl_resource *resource,
  533                    const void *implementation,
  534                    void *data,
  535                    wl_resource_destroy_func_t destroy);
  536 
  537 void
  538 wl_resource_set_dispatcher(struct wl_resource *resource,
  539                wl_dispatcher_func_t dispatcher,
  540                const void *implementation,
  541                void *data,
  542                wl_resource_destroy_func_t destroy);
  543 
  544 void
  545 wl_resource_destroy(struct wl_resource *resource);
  546 
  547 uint32_t
  548 wl_resource_get_id(struct wl_resource *resource);
  549 
  550 struct wl_list *
  551 wl_resource_get_link(struct wl_resource *resource);
  552 
  553 struct wl_resource *
  554 wl_resource_from_link(struct wl_list *resource);
  555 
  556 struct wl_resource *
  557 wl_resource_find_for_client(struct wl_list *list, struct wl_client *client);
  558 
  559 struct wl_client *
  560 wl_resource_get_client(struct wl_resource *resource);
  561 
  562 void
  563 wl_resource_set_user_data(struct wl_resource *resource, void *data);
  564 
  565 void *
  566 wl_resource_get_user_data(struct wl_resource *resource);
  567 
  568 int
  569 wl_resource_get_version(struct wl_resource *resource);
  570 
  571 void
  572 wl_resource_set_destructor(struct wl_resource *resource,
  573                wl_resource_destroy_func_t destroy);
  574 
  575 int
  576 wl_resource_instance_of(struct wl_resource *resource,
  577             const struct wl_interface *interface,
  578             const void *implementation);
  579 const char *
  580 wl_resource_get_class(struct wl_resource *resource);
  581 
  582 void
  583 wl_resource_add_destroy_listener(struct wl_resource *resource,
  584                  struct wl_listener *listener);
  585 
  586 struct wl_listener *
  587 wl_resource_get_destroy_listener(struct wl_resource *resource,
  588                  wl_notify_func_t notify);
  589 
  590 #define wl_resource_for_each(resource, list)                    \
  591     for (resource = 0, resource = wl_resource_from_link((list)->next);  \
  592          wl_resource_get_link(resource) != (list);              \
  593          resource = wl_resource_from_link(wl_resource_get_link(resource)->next))
  594 
  595 #define wl_resource_for_each_safe(resource, tmp, list)                  \
  596     for (resource = 0, tmp = 0,                         \
  597          resource = wl_resource_from_link((list)->next),    \
  598          tmp = wl_resource_from_link((list)->next->next);   \
  599          wl_resource_get_link(resource) != (list);              \
  600          resource = tmp,                            \
  601          tmp = wl_resource_from_link(wl_resource_get_link(resource)->next))
  602 
  603 struct wl_shm_buffer *
  604 wl_shm_buffer_get(struct wl_resource *resource);
  605 
  606 void
  607 wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer);
  608 
  609 void
  610 wl_shm_buffer_end_access(struct wl_shm_buffer *buffer);
  611 
  612 void *
  613 wl_shm_buffer_get_data(struct wl_shm_buffer *buffer);
  614 
  615 int32_t
  616 wl_shm_buffer_get_stride(struct wl_shm_buffer *buffer);
  617 
  618 uint32_t
  619 wl_shm_buffer_get_format(struct wl_shm_buffer *buffer);
  620 
  621 int32_t
  622 wl_shm_buffer_get_width(struct wl_shm_buffer *buffer);
  623 
  624 int32_t
  625 wl_shm_buffer_get_height(struct wl_shm_buffer *buffer);
  626 
  627 struct wl_shm_pool *
  628 wl_shm_buffer_ref_pool(struct wl_shm_buffer *buffer);
  629 
  630 void
  631 wl_shm_pool_unref(struct wl_shm_pool *pool);
  632 
  633 int
  634 wl_display_init_shm(struct wl_display *display);
  635 
  636 uint32_t *
  637 wl_display_add_shm_format(struct wl_display *display, uint32_t format);
  638 
  639 struct wl_shm_buffer *
  640 wl_shm_buffer_create(struct wl_client *client,
  641              uint32_t id, int32_t width, int32_t height,
  642              int32_t stride, uint32_t format) WL_DEPRECATED;
  643 
  644 void
  645 wl_log_set_handler_server(wl_log_func_t handler);
  646 
  647 enum wl_protocol_logger_type {
  648     WL_PROTOCOL_LOGGER_REQUEST,
  649     WL_PROTOCOL_LOGGER_EVENT,
  650 };
  651 
  652 struct wl_protocol_logger_message {
  653     struct wl_resource *resource;
  654     int message_opcode;
  655     const struct wl_message *message;
  656     int arguments_count;
  657     const union wl_argument *arguments;
  658 };
  659 
  660 typedef void (*wl_protocol_logger_func_t)(void *user_data,
  661                       enum wl_protocol_logger_type direction,
  662                       const struct wl_protocol_logger_message *message);
  663 
  664 struct wl_protocol_logger *
  665 wl_display_add_protocol_logger(struct wl_display *display,
  666                    wl_protocol_logger_func_t, void *user_data);
  667 
  668 void
  669 wl_protocol_logger_destroy(struct wl_protocol_logger *logger);
  670 
  671 #ifdef  __cplusplus
  672 }
  673 #endif
  674 
  675 #endif