external/mit/xorg/lib/libxcb/files/xinerama.c

   1 /*
   2  * This file generated automatically from xinerama.xml by c_client.py.
   3  * Edit at your peril.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 #include "config.h"
   8 #endif
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <assert.h>
  12 #include <stddef.h>  /* for offsetof() */
  13 #include "xcbext.h"
  14 #include "xinerama.h"
  15
  16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
  17 #include "xproto.h"
  18
  19 xcb_extension_t xcb_xinerama_id = { "XINERAMA", 0 };
  20
  21 void
  22 xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i  /**< */)
  23 {
  24     --i->rem;
  25     ++i->data;
  26     i->index += sizeof(xcb_xinerama_screen_info_t);
  27 }
  28
  29 xcb_generic_iterator_t
  30 xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i  /**< */)
  31 {
  32     xcb_generic_iterator_t ret;
  33     ret.data = i.data + i.rem;
  34     ret.index = i.index + ((char *) ret.data - (char *) i.data);
  35     ret.rem = 0;
  36     return ret;
  37 }
  38
  39 xcb_xinerama_query_version_cookie_t
  40 xcb_xinerama_query_version (xcb_connection_t *c  /**< */,
  41                             uint8_t           major  /**< */,
  42                             uint8_t           minor  /**< */)
  43 {
  44     static const xcb_protocol_request_t xcb_req = {
  45         /* count */ 2,
  46         /* ext */ &xcb_xinerama_id,
  47         /* opcode */ XCB_XINERAMA_QUERY_VERSION,
  48         /* isvoid */ 0
  49     };
  50
  51     struct iovec xcb_parts[4];
  52     xcb_xinerama_query_version_cookie_t xcb_ret;
  53     xcb_xinerama_query_version_request_t xcb_out;
  54
  55     xcb_out.major = major;
  56     xcb_out.minor = minor;
  57
  58     xcb_parts[2].iov_base = (char *) &xcb_out;
  59     xcb_parts[2].iov_len = sizeof(xcb_out);
  60     xcb_parts[3].iov_base = 0;
  61     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
  62
  63     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
  64     return xcb_ret;
  65 }
  66
  67 xcb_xinerama_query_version_cookie_t
  68 xcb_xinerama_query_version_unchecked (xcb_connection_t *c  /**< */,
  69                                       uint8_t           major  /**< */,
  70                                       uint8_t           minor  /**< */)
  71 {
  72     static const xcb_protocol_request_t xcb_req = {
  73         /* count */ 2,
  74         /* ext */ &xcb_xinerama_id,
  75         /* opcode */ XCB_XINERAMA_QUERY_VERSION,
  76         /* isvoid */ 0
  77     };
  78
  79     struct iovec xcb_parts[4];
  80     xcb_xinerama_query_version_cookie_t xcb_ret;
  81     xcb_xinerama_query_version_request_t xcb_out;
  82
  83     xcb_out.major = major;
  84     xcb_out.minor = minor;
  85
  86     xcb_parts[2].iov_base = (char *) &xcb_out;
  87     xcb_parts[2].iov_len = sizeof(xcb_out);
  88     xcb_parts[3].iov_base = 0;
  89     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
  90
  91     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
  92     return xcb_ret;
  93 }
  94
  95 xcb_xinerama_query_version_reply_t *
  96 xcb_xinerama_query_version_reply (xcb_connection_t                     *c  /**< */,
  97                                   xcb_xinerama_query_version_cookie_t   cookie  /**< */,
  98                                   xcb_generic_error_t                 **e  /**< */)
  99 {
 100     return (xcb_xinerama_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 101 }
 102
 103 xcb_xinerama_get_state_cookie_t
 104 xcb_xinerama_get_state (xcb_connection_t *c  /**< */,
 105                         xcb_window_t      window  /**< */)
 106 {
 107     static const xcb_protocol_request_t xcb_req = {
 108         /* count */ 2,
 109         /* ext */ &xcb_xinerama_id,
 110         /* opcode */ XCB_XINERAMA_GET_STATE,
 111         /* isvoid */ 0
 112     };
 113
 114     struct iovec xcb_parts[4];
 115     xcb_xinerama_get_state_cookie_t xcb_ret;
 116     xcb_xinerama_get_state_request_t xcb_out;
 117
 118     xcb_out.window = window;
 119
 120     xcb_parts[2].iov_base = (char *) &xcb_out;
 121     xcb_parts[2].iov_len = sizeof(xcb_out);
 122     xcb_parts[3].iov_base = 0;
 123     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 124
 125     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
 126     return xcb_ret;
 127 }
 128
 129 xcb_xinerama_get_state_cookie_t
 130 xcb_xinerama_get_state_unchecked (xcb_connection_t *c  /**< */,
 131                                   xcb_window_t      window  /**< */)
 132 {
 133     static const xcb_protocol_request_t xcb_req = {
 134         /* count */ 2,
 135         /* ext */ &xcb_xinerama_id,
 136         /* opcode */ XCB_XINERAMA_GET_STATE,
 137         /* isvoid */ 0
 138     };
 139
 140     struct iovec xcb_parts[4];
 141     xcb_xinerama_get_state_cookie_t xcb_ret;
 142     xcb_xinerama_get_state_request_t xcb_out;
 143
 144     xcb_out.window = window;
 145
 146     xcb_parts[2].iov_base = (char *) &xcb_out;
 147     xcb_parts[2].iov_len = sizeof(xcb_out);
 148     xcb_parts[3].iov_base = 0;
 149     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 150
 151     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
 152     return xcb_ret;
 153 }
 154
 155 xcb_xinerama_get_state_reply_t *
 156 xcb_xinerama_get_state_reply (xcb_connection_t                 *c  /**< */,
 157                               xcb_xinerama_get_state_cookie_t   cookie  /**< */,
 158                               xcb_generic_error_t             **e  /**< */)
 159 {
 160     return (xcb_xinerama_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 161 }
 162
 163 xcb_xinerama_get_screen_count_cookie_t
 164 xcb_xinerama_get_screen_count (xcb_connection_t *c  /**< */,
 165                                xcb_window_t      window  /**< */)
 166 {
 167     static const xcb_protocol_request_t xcb_req = {
 168         /* count */ 2,
 169         /* ext */ &xcb_xinerama_id,
 170         /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT,
 171         /* isvoid */ 0
 172     };
 173
 174     struct iovec xcb_parts[4];
 175     xcb_xinerama_get_screen_count_cookie_t xcb_ret;
 176     xcb_xinerama_get_screen_count_request_t xcb_out;
 177
 178     xcb_out.window = window;
 179
 180     xcb_parts[2].iov_base = (char *) &xcb_out;
 181     xcb_parts[2].iov_len = sizeof(xcb_out);
 182     xcb_parts[3].iov_base = 0;
 183     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 184
 185     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
 186     return xcb_ret;
 187 }
 188
 189 xcb_xinerama_get_screen_count_cookie_t
 190 xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c  /**< */,
 191                                          xcb_window_t      window  /**< */)
 192 {
 193     static const xcb_protocol_request_t xcb_req = {
 194         /* count */ 2,
 195         /* ext */ &xcb_xinerama_id,
 196         /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT,
 197         /* isvoid */ 0
 198     };
 199
 200     struct iovec xcb_parts[4];
 201     xcb_xinerama_get_screen_count_cookie_t xcb_ret;
 202     xcb_xinerama_get_screen_count_request_t xcb_out;
 203
 204     xcb_out.window = window;
 205
 206     xcb_parts[2].iov_base = (char *) &xcb_out;
 207     xcb_parts[2].iov_len = sizeof(xcb_out);
 208     xcb_parts[3].iov_base = 0;
 209     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 210
 211     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
 212     return xcb_ret;
 213 }
 214
 215 xcb_xinerama_get_screen_count_reply_t *
 216 xcb_xinerama_get_screen_count_reply (xcb_connection_t                        *c  /**< */,
 217                                      xcb_xinerama_get_screen_count_cookie_t   cookie  /**< */,
 218                                      xcb_generic_error_t                    **e  /**< */)
 219 {
 220     return (xcb_xinerama_get_screen_count_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 221 }
 222
 223 xcb_xinerama_get_screen_size_cookie_t
 224 xcb_xinerama_get_screen_size (xcb_connection_t *c  /**< */,
 225                               xcb_window_t      window  /**< */,
 226                               uint32_t          screen  /**< */)
 227 {
 228     static const xcb_protocol_request_t xcb_req = {
 229         /* count */ 2,
 230         /* ext */ &xcb_xinerama_id,
 231         /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE,
 232         /* isvoid */ 0
 233     };
 234
 235     struct iovec xcb_parts[4];
 236     xcb_xinerama_get_screen_size_cookie_t xcb_ret;
 237     xcb_xinerama_get_screen_size_request_t xcb_out;
 238
 239     xcb_out.window = window;
 240     xcb_out.screen = screen;
 241
 242     xcb_parts[2].iov_base = (char *) &xcb_out;
 243     xcb_parts[2].iov_len = sizeof(xcb_out);
 244     xcb_parts[3].iov_base = 0;
 245     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 246
 247     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
 248     return xcb_ret;
 249 }
 250
 251 xcb_xinerama_get_screen_size_cookie_t
 252 xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c  /**< */,
 253                                         xcb_window_t      window  /**< */,
 254                                         uint32_t          screen  /**< */)
 255 {
 256     static const xcb_protocol_request_t xcb_req = {
 257         /* count */ 2,
 258         /* ext */ &xcb_xinerama_id,
 259         /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE,
 260         /* isvoid */ 0
 261     };
 262
 263     struct iovec xcb_parts[4];
 264     xcb_xinerama_get_screen_size_cookie_t xcb_ret;
 265     xcb_xinerama_get_screen_size_request_t xcb_out;
 266
 267     xcb_out.window = window;
 268     xcb_out.screen = screen;
 269
 270     xcb_parts[2].iov_base = (char *) &xcb_out;
 271     xcb_parts[2].iov_len = sizeof(xcb_out);
 272     xcb_parts[3].iov_base = 0;
 273     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 274
 275     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
 276     return xcb_ret;
 277 }
 278
 279 xcb_xinerama_get_screen_size_reply_t *
 280 xcb_xinerama_get_screen_size_reply (xcb_connection_t                       *c  /**< */,
 281                                     xcb_xinerama_get_screen_size_cookie_t   cookie  /**< */,
 282                                     xcb_generic_error_t                   **e  /**< */)
 283 {
 284     return (xcb_xinerama_get_screen_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 285 }
 286
 287 xcb_xinerama_is_active_cookie_t
 288 xcb_xinerama_is_active (xcb_connection_t *c  /**< */)
 289 {
 290     static const xcb_protocol_request_t xcb_req = {
 291         /* count */ 2,
 292         /* ext */ &xcb_xinerama_id,
 293         /* opcode */ XCB_XINERAMA_IS_ACTIVE,
 294         /* isvoid */ 0
 295     };
 296
 297     struct iovec xcb_parts[4];
 298     xcb_xinerama_is_active_cookie_t xcb_ret;
 299     xcb_xinerama_is_active_request_t xcb_out;
 300
 301
 302     xcb_parts[2].iov_base = (char *) &xcb_out;
 303     xcb_parts[2].iov_len = sizeof(xcb_out);
 304     xcb_parts[3].iov_base = 0;
 305     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 306
 307     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
 308     return xcb_ret;
 309 }
 310
 311 xcb_xinerama_is_active_cookie_t
 312 xcb_xinerama_is_active_unchecked (xcb_connection_t *c  /**< */)
 313 {
 314     static const xcb_protocol_request_t xcb_req = {
 315         /* count */ 2,
 316         /* ext */ &xcb_xinerama_id,
 317         /* opcode */ XCB_XINERAMA_IS_ACTIVE,
 318         /* isvoid */ 0
 319     };
 320
 321     struct iovec xcb_parts[4];
 322     xcb_xinerama_is_active_cookie_t xcb_ret;
 323     xcb_xinerama_is_active_request_t xcb_out;
 324
 325
 326     xcb_parts[2].iov_base = (char *) &xcb_out;
 327     xcb_parts[2].iov_len = sizeof(xcb_out);
 328     xcb_parts[3].iov_base = 0;
 329     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 330
 331     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
 332     return xcb_ret;
 333 }
 334
 335 xcb_xinerama_is_active_reply_t *
 336 xcb_xinerama_is_active_reply (xcb_connection_t                 *c  /**< */,
 337                               xcb_xinerama_is_active_cookie_t   cookie  /**< */,
 338                               xcb_generic_error_t             **e  /**< */)
 339 {
 340     return (xcb_xinerama_is_active_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 341 }
 342
 343 int
 344 xcb_xinerama_query_screens_sizeof (const void  *_buffer  /**< */)
 345 {
 346     char *xcb_tmp = (char *)_buffer;
 347     const xcb_xinerama_query_screens_reply_t *_aux = (xcb_xinerama_query_screens_reply_t *)_buffer;
 348     unsigned int xcb_buffer_len = 0;
 349     unsigned int xcb_block_len = 0;
 350     unsigned int xcb_pad = 0;
 351     unsigned int xcb_align_to = 0;
 352
 353
 354     xcb_block_len += sizeof(xcb_xinerama_query_screens_reply_t);
 355     xcb_tmp += xcb_block_len;
 356     xcb_buffer_len += xcb_block_len;
 357     xcb_block_len = 0;
 358     /* screen_info */
 359     xcb_block_len += _aux->number * sizeof(xcb_xinerama_screen_info_t);
 360     xcb_tmp += xcb_block_len;
 361     xcb_align_to = ALIGNOF(xcb_xinerama_screen_info_t);
 362     /* insert padding */
 363     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
 364     xcb_buffer_len += xcb_block_len + xcb_pad;
 365     if (0 != xcb_pad) {
 366         xcb_tmp += xcb_pad;
 367         xcb_pad = 0;
 368     }
 369     xcb_block_len = 0;
 370
 371     return xcb_buffer_len;
 372 }
 373
 374 xcb_xinerama_query_screens_cookie_t
 375 xcb_xinerama_query_screens (xcb_connection_t *c  /**< */)
 376 {
 377     static const xcb_protocol_request_t xcb_req = {
 378         /* count */ 2,
 379         /* ext */ &xcb_xinerama_id,
 380         /* opcode */ XCB_XINERAMA_QUERY_SCREENS,
 381         /* isvoid */ 0
 382     };
 383
 384     struct iovec xcb_parts[4];
 385     xcb_xinerama_query_screens_cookie_t xcb_ret;
 386     xcb_xinerama_query_screens_request_t xcb_out;
 387
 388
 389     xcb_parts[2].iov_base = (char *) &xcb_out;
 390     xcb_parts[2].iov_len = sizeof(xcb_out);
 391     xcb_parts[3].iov_base = 0;
 392     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 393
 394     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
 395     return xcb_ret;
 396 }
 397
 398 xcb_xinerama_query_screens_cookie_t
 399 xcb_xinerama_query_screens_unchecked (xcb_connection_t *c  /**< */)
 400 {
 401     static const xcb_protocol_request_t xcb_req = {
 402         /* count */ 2,
 403         /* ext */ &xcb_xinerama_id,
 404         /* opcode */ XCB_XINERAMA_QUERY_SCREENS,
 405         /* isvoid */ 0
 406     };
 407
 408     struct iovec xcb_parts[4];
 409     xcb_xinerama_query_screens_cookie_t xcb_ret;
 410     xcb_xinerama_query_screens_request_t xcb_out;
 411
 412
 413     xcb_parts[2].iov_base = (char *) &xcb_out;
 414     xcb_parts[2].iov_len = sizeof(xcb_out);
 415     xcb_parts[3].iov_base = 0;
 416     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 417
 418     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
 419     return xcb_ret;
 420 }
 421
 422 xcb_xinerama_screen_info_t *
 423 xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R  /**< */)
 424 {
 425     return (xcb_xinerama_screen_info_t *) (R + 1);
 426 }
 427
 428 int
 429 xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R  /**< */)
 430 {
 431     return R->number;
 432 }
 433
 434 xcb_xinerama_screen_info_iterator_t
 435 xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R  /**< */)
 436 {
 437     xcb_xinerama_screen_info_iterator_t i;
 438     i.data = (xcb_xinerama_screen_info_t *) (R + 1);
 439     i.rem = R->number;
 440     i.index = (char *) i.data - (char *) R;
 441     return i;
 442 }
 443
 444 xcb_xinerama_query_screens_reply_t *
 445 xcb_xinerama_query_screens_reply (xcb_connection_t                     *c  /**< */,
 446                                   xcb_xinerama_query_screens_cookie_t   cookie  /**< */,
 447                                   xcb_generic_error_t                 **e  /**< */)
 448 {
 449     return (xcb_xinerama_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 450 }
 451