1 /* 2 * This file generated automatically from randr.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 "randr.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 #include "render.h" 19 20 xcb_extension_t xcb_randr_id = { "RANDR", 0 }; 21 22 void 23 xcb_randr_mode_next (xcb_randr_mode_iterator_t *i /**< */) 24 { 25 --i->rem; 26 ++i->data; 27 i->index += sizeof(xcb_randr_mode_t); 28 } 29 30 xcb_generic_iterator_t 31 xcb_randr_mode_end (xcb_randr_mode_iterator_t i /**< */) 32 { 33 xcb_generic_iterator_t ret; 34 ret.data = i.data + i.rem; 35 ret.index = i.index + ((char *) ret.data - (char *) i.data); 36 ret.rem = 0; 37 return ret; 38 } 39 40 void 41 xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i /**< */) 42 { 43 --i->rem; 44 ++i->data; 45 i->index += sizeof(xcb_randr_crtc_t); 46 } 47 48 xcb_generic_iterator_t 49 xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i /**< */) 50 { 51 xcb_generic_iterator_t ret; 52 ret.data = i.data + i.rem; 53 ret.index = i.index + ((char *) ret.data - (char *) i.data); 54 ret.rem = 0; 55 return ret; 56 } 57 58 void 59 xcb_randr_output_next (xcb_randr_output_iterator_t *i /**< */) 60 { 61 --i->rem; 62 ++i->data; 63 i->index += sizeof(xcb_randr_output_t); 64 } 65 66 xcb_generic_iterator_t 67 xcb_randr_output_end (xcb_randr_output_iterator_t i /**< */) 68 { 69 xcb_generic_iterator_t ret; 70 ret.data = i.data + i.rem; 71 ret.index = i.index + ((char *) ret.data - (char *) i.data); 72 ret.rem = 0; 73 return ret; 74 } 75 76 void 77 xcb_randr_provider_next (xcb_randr_provider_iterator_t *i /**< */) 78 { 79 --i->rem; 80 ++i->data; 81 i->index += sizeof(xcb_randr_provider_t); 82 } 83 84 xcb_generic_iterator_t 85 xcb_randr_provider_end (xcb_randr_provider_iterator_t i /**< */) 86 { 87 xcb_generic_iterator_t ret; 88 ret.data = i.data + i.rem; 89 ret.index = i.index + ((char *) ret.data - (char *) i.data); 90 ret.rem = 0; 91 return ret; 92 } 93 94 void 95 xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */) 96 { 97 --i->rem; 98 ++i->data; 99 i->index += sizeof(xcb_randr_screen_size_t); 100 } 101 102 xcb_generic_iterator_t 103 xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */) 104 { 105 xcb_generic_iterator_t ret; 106 ret.data = i.data + i.rem; 107 ret.index = i.index + ((char *) ret.data - (char *) i.data); 108 ret.rem = 0; 109 return ret; 110 } 111 112 int 113 xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */) 114 { 115 char *xcb_tmp = (char *)_buffer; 116 const xcb_randr_refresh_rates_t *_aux = (xcb_randr_refresh_rates_t *)_buffer; 117 unsigned int xcb_buffer_len = 0; 118 unsigned int xcb_block_len = 0; 119 unsigned int xcb_pad = 0; 120 unsigned int xcb_align_to = 0; 121 122 123 xcb_block_len += sizeof(xcb_randr_refresh_rates_t); 124 xcb_tmp += xcb_block_len; 125 xcb_buffer_len += xcb_block_len; 126 xcb_block_len = 0; 127 /* rates */ 128 xcb_block_len += _aux->nRates * sizeof(uint16_t); 129 xcb_tmp += xcb_block_len; 130 xcb_align_to = ALIGNOF(uint16_t); 131 /* insert padding */ 132 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 133 xcb_buffer_len += xcb_block_len + xcb_pad; 134 if (0 != xcb_pad) { 135 xcb_tmp += xcb_pad; 136 xcb_pad = 0; 137 } 138 xcb_block_len = 0; 139 140 return xcb_buffer_len; 141 } 142 143 uint16_t * 144 xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R /**< */) 145 { 146 return (uint16_t *) (R + 1); 147 } 148 149 int 150 xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R /**< */) 151 { 152 return R->nRates; 153 } 154 155 xcb_generic_iterator_t 156 xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R /**< */) 157 { 158 xcb_generic_iterator_t i; 159 i.data = ((uint16_t *) (R + 1)) + (R->nRates); 160 i.rem = 0; 161 i.index = (char *) i.data - (char *) R; 162 return i; 163 } 164 165 void 166 xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */) 167 { 168 xcb_randr_refresh_rates_t *R = i->data; 169 xcb_generic_iterator_t child; 170 child.data = (xcb_randr_refresh_rates_t *)(((char *)R) + xcb_randr_refresh_rates_sizeof(R)); 171 i->index = (char *) child.data - (char *) i->data; 172 --i->rem; 173 i->data = (xcb_randr_refresh_rates_t *) child.data; 174 } 175 176 xcb_generic_iterator_t 177 xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */) 178 { 179 xcb_generic_iterator_t ret; 180 while(i.rem > 0) 181 xcb_randr_refresh_rates_next(&i); 182 ret.data = i.data; 183 ret.rem = i.rem; 184 ret.index = i.index; 185 return ret; 186 } 187 188 xcb_randr_query_version_cookie_t 189 xcb_randr_query_version (xcb_connection_t *c /**< */, 190 uint32_t major_version /**< */, 191 uint32_t minor_version /**< */) 192 { 193 static const xcb_protocol_request_t xcb_req = { 194 /* count */ 2, 195 /* ext */ &xcb_randr_id, 196 /* opcode */ XCB_RANDR_QUERY_VERSION, 197 /* isvoid */ 0 198 }; 199 200 struct iovec xcb_parts[4]; 201 xcb_randr_query_version_cookie_t xcb_ret; 202 xcb_randr_query_version_request_t xcb_out; 203 204 xcb_out.major_version = major_version; 205 xcb_out.minor_version = minor_version; 206 207 xcb_parts[2].iov_base = (char *) &xcb_out; 208 xcb_parts[2].iov_len = sizeof(xcb_out); 209 xcb_parts[3].iov_base = 0; 210 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 211 212 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 213 return xcb_ret; 214 } 215 216 xcb_randr_query_version_cookie_t 217 xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, 218 uint32_t major_version /**< */, 219 uint32_t minor_version /**< */) 220 { 221 static const xcb_protocol_request_t xcb_req = { 222 /* count */ 2, 223 /* ext */ &xcb_randr_id, 224 /* opcode */ XCB_RANDR_QUERY_VERSION, 225 /* isvoid */ 0 226 }; 227 228 struct iovec xcb_parts[4]; 229 xcb_randr_query_version_cookie_t xcb_ret; 230 xcb_randr_query_version_request_t xcb_out; 231 232 xcb_out.major_version = major_version; 233 xcb_out.minor_version = minor_version; 234 235 xcb_parts[2].iov_base = (char *) &xcb_out; 236 xcb_parts[2].iov_len = sizeof(xcb_out); 237 xcb_parts[3].iov_base = 0; 238 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 239 240 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 241 return xcb_ret; 242 } 243 244 xcb_randr_query_version_reply_t * 245 xcb_randr_query_version_reply (xcb_connection_t *c /**< */, 246 xcb_randr_query_version_cookie_t cookie /**< */, 247 xcb_generic_error_t **e /**< */) 248 { 249 return (xcb_randr_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 250 } 251 252 xcb_randr_set_screen_config_cookie_t 253 xcb_randr_set_screen_config (xcb_connection_t *c /**< */, 254 xcb_window_t window /**< */, 255 xcb_timestamp_t timestamp /**< */, 256 xcb_timestamp_t config_timestamp /**< */, 257 uint16_t sizeID /**< */, 258 uint16_t rotation /**< */, 259 uint16_t rate /**< */) 260 { 261 static const xcb_protocol_request_t xcb_req = { 262 /* count */ 2, 263 /* ext */ &xcb_randr_id, 264 /* opcode */ XCB_RANDR_SET_SCREEN_CONFIG, 265 /* isvoid */ 0 266 }; 267 268 struct iovec xcb_parts[4]; 269 xcb_randr_set_screen_config_cookie_t xcb_ret; 270 xcb_randr_set_screen_config_request_t xcb_out; 271 272 xcb_out.window = window; 273 xcb_out.timestamp = timestamp; 274 xcb_out.config_timestamp = config_timestamp; 275 xcb_out.sizeID = sizeID; 276 xcb_out.rotation = rotation; 277 xcb_out.rate = rate; 278 memset(xcb_out.pad0, 0, 2); 279 280 xcb_parts[2].iov_base = (char *) &xcb_out; 281 xcb_parts[2].iov_len = sizeof(xcb_out); 282 xcb_parts[3].iov_base = 0; 283 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 284 285 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 286 return xcb_ret; 287 } 288 289 xcb_randr_set_screen_config_cookie_t 290 xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, 291 xcb_window_t window /**< */, 292 xcb_timestamp_t timestamp /**< */, 293 xcb_timestamp_t config_timestamp /**< */, 294 uint16_t sizeID /**< */, 295 uint16_t rotation /**< */, 296 uint16_t rate /**< */) 297 { 298 static const xcb_protocol_request_t xcb_req = { 299 /* count */ 2, 300 /* ext */ &xcb_randr_id, 301 /* opcode */ XCB_RANDR_SET_SCREEN_CONFIG, 302 /* isvoid */ 0 303 }; 304 305 struct iovec xcb_parts[4]; 306 xcb_randr_set_screen_config_cookie_t xcb_ret; 307 xcb_randr_set_screen_config_request_t xcb_out; 308 309 xcb_out.window = window; 310 xcb_out.timestamp = timestamp; 311 xcb_out.config_timestamp = config_timestamp; 312 xcb_out.sizeID = sizeID; 313 xcb_out.rotation = rotation; 314 xcb_out.rate = rate; 315 memset(xcb_out.pad0, 0, 2); 316 317 xcb_parts[2].iov_base = (char *) &xcb_out; 318 xcb_parts[2].iov_len = sizeof(xcb_out); 319 xcb_parts[3].iov_base = 0; 320 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 321 322 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 323 return xcb_ret; 324 } 325 326 xcb_randr_set_screen_config_reply_t * 327 xcb_randr_set_screen_config_reply (xcb_connection_t *c /**< */, 328 xcb_randr_set_screen_config_cookie_t cookie /**< */, 329 xcb_generic_error_t **e /**< */) 330 { 331 return (xcb_randr_set_screen_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 332 } 333 334 xcb_void_cookie_t 335 xcb_randr_select_input_checked (xcb_connection_t *c /**< */, 336 xcb_window_t window /**< */, 337 uint16_t enable /**< */) 338 { 339 static const xcb_protocol_request_t xcb_req = { 340 /* count */ 2, 341 /* ext */ &xcb_randr_id, 342 /* opcode */ XCB_RANDR_SELECT_INPUT, 343 /* isvoid */ 1 344 }; 345 346 struct iovec xcb_parts[4]; 347 xcb_void_cookie_t xcb_ret; 348 xcb_randr_select_input_request_t xcb_out; 349 350 xcb_out.window = window; 351 xcb_out.enable = enable; 352 memset(xcb_out.pad0, 0, 2); 353 354 xcb_parts[2].iov_base = (char *) &xcb_out; 355 xcb_parts[2].iov_len = sizeof(xcb_out); 356 xcb_parts[3].iov_base = 0; 357 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 358 359 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 360 return xcb_ret; 361 } 362 363 xcb_void_cookie_t 364 xcb_randr_select_input (xcb_connection_t *c /**< */, 365 xcb_window_t window /**< */, 366 uint16_t enable /**< */) 367 { 368 static const xcb_protocol_request_t xcb_req = { 369 /* count */ 2, 370 /* ext */ &xcb_randr_id, 371 /* opcode */ XCB_RANDR_SELECT_INPUT, 372 /* isvoid */ 1 373 }; 374 375 struct iovec xcb_parts[4]; 376 xcb_void_cookie_t xcb_ret; 377 xcb_randr_select_input_request_t xcb_out; 378 379 xcb_out.window = window; 380 xcb_out.enable = enable; 381 memset(xcb_out.pad0, 0, 2); 382 383 xcb_parts[2].iov_base = (char *) &xcb_out; 384 xcb_parts[2].iov_len = sizeof(xcb_out); 385 xcb_parts[3].iov_base = 0; 386 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 387 388 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 389 return xcb_ret; 390 } 391 392 int 393 xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */) 394 { 395 char *xcb_tmp = (char *)_buffer; 396 const xcb_randr_get_screen_info_reply_t *_aux = (xcb_randr_get_screen_info_reply_t *)_buffer; 397 unsigned int xcb_buffer_len = 0; 398 unsigned int xcb_block_len = 0; 399 unsigned int xcb_pad = 0; 400 unsigned int xcb_align_to = 0; 401 402 unsigned int i; 403 unsigned int xcb_tmp_len; 404 405 xcb_block_len += sizeof(xcb_randr_get_screen_info_reply_t); 406 xcb_tmp += xcb_block_len; 407 xcb_buffer_len += xcb_block_len; 408 xcb_block_len = 0; 409 /* sizes */ 410 xcb_block_len += _aux->nSizes * sizeof(xcb_randr_screen_size_t); 411 xcb_tmp += xcb_block_len; 412 xcb_align_to = ALIGNOF(xcb_randr_screen_size_t); 413 /* insert padding */ 414 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 415 xcb_buffer_len += xcb_block_len + xcb_pad; 416 if (0 != xcb_pad) { 417 xcb_tmp += xcb_pad; 418 xcb_pad = 0; 419 } 420 xcb_block_len = 0; 421 /* rates */ 422 for(i=0; i<(_aux->nInfo - _aux->nSizes); i++) { 423 xcb_tmp_len = xcb_randr_refresh_rates_sizeof(xcb_tmp); 424 xcb_block_len += xcb_tmp_len; 425 xcb_tmp += xcb_tmp_len; 426 } 427 xcb_align_to = ALIGNOF(xcb_randr_refresh_rates_t); 428 /* insert padding */ 429 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 430 xcb_buffer_len += xcb_block_len + xcb_pad; 431 if (0 != xcb_pad) { 432 xcb_tmp += xcb_pad; 433 xcb_pad = 0; 434 } 435 xcb_block_len = 0; 436 437 return xcb_buffer_len; 438 } 439 440 xcb_randr_get_screen_info_cookie_t 441 xcb_randr_get_screen_info (xcb_connection_t *c /**< */, 442 xcb_window_t window /**< */) 443 { 444 static const xcb_protocol_request_t xcb_req = { 445 /* count */ 2, 446 /* ext */ &xcb_randr_id, 447 /* opcode */ XCB_RANDR_GET_SCREEN_INFO, 448 /* isvoid */ 0 449 }; 450 451 struct iovec xcb_parts[4]; 452 xcb_randr_get_screen_info_cookie_t xcb_ret; 453 xcb_randr_get_screen_info_request_t xcb_out; 454 455 xcb_out.window = window; 456 457 xcb_parts[2].iov_base = (char *) &xcb_out; 458 xcb_parts[2].iov_len = sizeof(xcb_out); 459 xcb_parts[3].iov_base = 0; 460 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 461 462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 463 return xcb_ret; 464 } 465 466 xcb_randr_get_screen_info_cookie_t 467 xcb_randr_get_screen_info_unchecked (xcb_connection_t *c /**< */, 468 xcb_window_t window /**< */) 469 { 470 static const xcb_protocol_request_t xcb_req = { 471 /* count */ 2, 472 /* ext */ &xcb_randr_id, 473 /* opcode */ XCB_RANDR_GET_SCREEN_INFO, 474 /* isvoid */ 0 475 }; 476 477 struct iovec xcb_parts[4]; 478 xcb_randr_get_screen_info_cookie_t xcb_ret; 479 xcb_randr_get_screen_info_request_t xcb_out; 480 481 xcb_out.window = window; 482 483 xcb_parts[2].iov_base = (char *) &xcb_out; 484 xcb_parts[2].iov_len = sizeof(xcb_out); 485 xcb_parts[3].iov_base = 0; 486 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 487 488 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 489 return xcb_ret; 490 } 491 492 xcb_randr_screen_size_t * 493 xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R /**< */) 494 { 495 return (xcb_randr_screen_size_t *) (R + 1); 496 } 497 498 int 499 xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R /**< */) 500 { 501 return R->nSizes; 502 } 503 504 xcb_randr_screen_size_iterator_t 505 xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */) 506 { 507 xcb_randr_screen_size_iterator_t i; 508 i.data = (xcb_randr_screen_size_t *) (R + 1); 509 i.rem = R->nSizes; 510 i.index = (char *) i.data - (char *) R; 511 return i; 512 } 513 514 int 515 xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R /**< */) 516 { 517 return (R->nInfo - R->nSizes); 518 } 519 520 xcb_randr_refresh_rates_iterator_t 521 xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */) 522 { 523 xcb_randr_refresh_rates_iterator_t i; 524 xcb_generic_iterator_t prev = xcb_randr_screen_size_end(xcb_randr_get_screen_info_sizes_iterator(R)); 525 i.data = (xcb_randr_refresh_rates_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_refresh_rates_t, prev.index)); 526 i.rem = (R->nInfo - R->nSizes); 527 i.index = (char *) i.data - (char *) R; 528 return i; 529 } 530 531 xcb_randr_get_screen_info_reply_t * 532 xcb_randr_get_screen_info_reply (xcb_connection_t *c /**< */, 533 xcb_randr_get_screen_info_cookie_t cookie /**< */, 534 xcb_generic_error_t **e /**< */) 535 { 536 return (xcb_randr_get_screen_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 537 } 538 539 xcb_randr_get_screen_size_range_cookie_t 540 xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, 541 xcb_window_t window /**< */) 542 { 543 static const xcb_protocol_request_t xcb_req = { 544 /* count */ 2, 545 /* ext */ &xcb_randr_id, 546 /* opcode */ XCB_RANDR_GET_SCREEN_SIZE_RANGE, 547 /* isvoid */ 0 548 }; 549 550 struct iovec xcb_parts[4]; 551 xcb_randr_get_screen_size_range_cookie_t xcb_ret; 552 xcb_randr_get_screen_size_range_request_t xcb_out; 553 554 xcb_out.window = window; 555 556 xcb_parts[2].iov_base = (char *) &xcb_out; 557 xcb_parts[2].iov_len = sizeof(xcb_out); 558 xcb_parts[3].iov_base = 0; 559 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 560 561 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 562 return xcb_ret; 563 } 564 565 xcb_randr_get_screen_size_range_cookie_t 566 xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, 567 xcb_window_t window /**< */) 568 { 569 static const xcb_protocol_request_t xcb_req = { 570 /* count */ 2, 571 /* ext */ &xcb_randr_id, 572 /* opcode */ XCB_RANDR_GET_SCREEN_SIZE_RANGE, 573 /* isvoid */ 0 574 }; 575 576 struct iovec xcb_parts[4]; 577 xcb_randr_get_screen_size_range_cookie_t xcb_ret; 578 xcb_randr_get_screen_size_range_request_t xcb_out; 579 580 xcb_out.window = window; 581 582 xcb_parts[2].iov_base = (char *) &xcb_out; 583 xcb_parts[2].iov_len = sizeof(xcb_out); 584 xcb_parts[3].iov_base = 0; 585 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 586 587 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 588 return xcb_ret; 589 } 590 591 xcb_randr_get_screen_size_range_reply_t * 592 xcb_randr_get_screen_size_range_reply (xcb_connection_t *c /**< */, 593 xcb_randr_get_screen_size_range_cookie_t cookie /**< */, 594 xcb_generic_error_t **e /**< */) 595 { 596 return (xcb_randr_get_screen_size_range_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 597 } 598 599 xcb_void_cookie_t 600 xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, 601 xcb_window_t window /**< */, 602 uint16_t width /**< */, 603 uint16_t height /**< */, 604 uint32_t mm_width /**< */, 605 uint32_t mm_height /**< */) 606 { 607 static const xcb_protocol_request_t xcb_req = { 608 /* count */ 2, 609 /* ext */ &xcb_randr_id, 610 /* opcode */ XCB_RANDR_SET_SCREEN_SIZE, 611 /* isvoid */ 1 612 }; 613 614 struct iovec xcb_parts[4]; 615 xcb_void_cookie_t xcb_ret; 616 xcb_randr_set_screen_size_request_t xcb_out; 617 618 xcb_out.window = window; 619 xcb_out.width = width; 620 xcb_out.height = height; 621 xcb_out.mm_width = mm_width; 622 xcb_out.mm_height = mm_height; 623 624 xcb_parts[2].iov_base = (char *) &xcb_out; 625 xcb_parts[2].iov_len = sizeof(xcb_out); 626 xcb_parts[3].iov_base = 0; 627 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 628 629 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 630 return xcb_ret; 631 } 632 633 xcb_void_cookie_t 634 xcb_randr_set_screen_size (xcb_connection_t *c /**< */, 635 xcb_window_t window /**< */, 636 uint16_t width /**< */, 637 uint16_t height /**< */, 638 uint32_t mm_width /**< */, 639 uint32_t mm_height /**< */) 640 { 641 static const xcb_protocol_request_t xcb_req = { 642 /* count */ 2, 643 /* ext */ &xcb_randr_id, 644 /* opcode */ XCB_RANDR_SET_SCREEN_SIZE, 645 /* isvoid */ 1 646 }; 647 648 struct iovec xcb_parts[4]; 649 xcb_void_cookie_t xcb_ret; 650 xcb_randr_set_screen_size_request_t xcb_out; 651 652 xcb_out.window = window; 653 xcb_out.width = width; 654 xcb_out.height = height; 655 xcb_out.mm_width = mm_width; 656 xcb_out.mm_height = mm_height; 657 658 xcb_parts[2].iov_base = (char *) &xcb_out; 659 xcb_parts[2].iov_len = sizeof(xcb_out); 660 xcb_parts[3].iov_base = 0; 661 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 662 663 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 664 return xcb_ret; 665 } 666 667 void 668 xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */) 669 { 670 --i->rem; 671 ++i->data; 672 i->index += sizeof(xcb_randr_mode_info_t); 673 } 674 675 xcb_generic_iterator_t 676 xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */) 677 { 678 xcb_generic_iterator_t ret; 679 ret.data = i.data + i.rem; 680 ret.index = i.index + ((char *) ret.data - (char *) i.data); 681 ret.rem = 0; 682 return ret; 683 } 684 685 int 686 xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */) 687 { 688 char *xcb_tmp = (char *)_buffer; 689 const xcb_randr_get_screen_resources_reply_t *_aux = (xcb_randr_get_screen_resources_reply_t *)_buffer; 690 unsigned int xcb_buffer_len = 0; 691 unsigned int xcb_block_len = 0; 692 unsigned int xcb_pad = 0; 693 unsigned int xcb_align_to = 0; 694 695 696 xcb_block_len += sizeof(xcb_randr_get_screen_resources_reply_t); 697 xcb_tmp += xcb_block_len; 698 xcb_buffer_len += xcb_block_len; 699 xcb_block_len = 0; 700 /* crtcs */ 701 xcb_block_len += _aux->num_crtcs * sizeof(uint32_t); 702 xcb_tmp += xcb_block_len; 703 xcb_align_to = ALIGNOF(xcb_randr_crtc_t); 704 /* insert padding */ 705 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 706 xcb_buffer_len += xcb_block_len + xcb_pad; 707 if (0 != xcb_pad) { 708 xcb_tmp += xcb_pad; 709 xcb_pad = 0; 710 } 711 xcb_block_len = 0; 712 /* outputs */ 713 xcb_block_len += _aux->num_outputs * sizeof(uint32_t); 714 xcb_tmp += xcb_block_len; 715 xcb_align_to = ALIGNOF(xcb_randr_output_t); 716 /* insert padding */ 717 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 718 xcb_buffer_len += xcb_block_len + xcb_pad; 719 if (0 != xcb_pad) { 720 xcb_tmp += xcb_pad; 721 xcb_pad = 0; 722 } 723 xcb_block_len = 0; 724 /* modes */ 725 xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t); 726 xcb_tmp += xcb_block_len; 727 xcb_align_to = ALIGNOF(xcb_randr_mode_info_t); 728 /* insert padding */ 729 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 730 xcb_buffer_len += xcb_block_len + xcb_pad; 731 if (0 != xcb_pad) { 732 xcb_tmp += xcb_pad; 733 xcb_pad = 0; 734 } 735 xcb_block_len = 0; 736 /* names */ 737 xcb_block_len += _aux->names_len * sizeof(uint8_t); 738 xcb_tmp += xcb_block_len; 739 xcb_align_to = ALIGNOF(uint8_t); 740 /* insert padding */ 741 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 742 xcb_buffer_len += xcb_block_len + xcb_pad; 743 if (0 != xcb_pad) { 744 xcb_tmp += xcb_pad; 745 xcb_pad = 0; 746 } 747 xcb_block_len = 0; 748 749 return xcb_buffer_len; 750 } 751 752 xcb_randr_get_screen_resources_cookie_t 753 xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, 754 xcb_window_t window /**< */) 755 { 756 static const xcb_protocol_request_t xcb_req = { 757 /* count */ 2, 758 /* ext */ &xcb_randr_id, 759 /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES, 760 /* isvoid */ 0 761 }; 762 763 struct iovec xcb_parts[4]; 764 xcb_randr_get_screen_resources_cookie_t xcb_ret; 765 xcb_randr_get_screen_resources_request_t xcb_out; 766 767 xcb_out.window = window; 768 769 xcb_parts[2].iov_base = (char *) &xcb_out; 770 xcb_parts[2].iov_len = sizeof(xcb_out); 771 xcb_parts[3].iov_base = 0; 772 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 773 774 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 775 return xcb_ret; 776 } 777 778 xcb_randr_get_screen_resources_cookie_t 779 xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c /**< */, 780 xcb_window_t window /**< */) 781 { 782 static const xcb_protocol_request_t xcb_req = { 783 /* count */ 2, 784 /* ext */ &xcb_randr_id, 785 /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES, 786 /* isvoid */ 0 787 }; 788 789 struct iovec xcb_parts[4]; 790 xcb_randr_get_screen_resources_cookie_t xcb_ret; 791 xcb_randr_get_screen_resources_request_t xcb_out; 792 793 xcb_out.window = window; 794 795 xcb_parts[2].iov_base = (char *) &xcb_out; 796 xcb_parts[2].iov_len = sizeof(xcb_out); 797 xcb_parts[3].iov_base = 0; 798 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 799 800 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 801 return xcb_ret; 802 } 803 804 xcb_randr_crtc_t * 805 xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R /**< */) 806 { 807 return (xcb_randr_crtc_t *) (R + 1); 808 } 809 810 int 811 xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) 812 { 813 return R->num_crtcs; 814 } 815 816 xcb_generic_iterator_t 817 xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) 818 { 819 xcb_generic_iterator_t i; 820 i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); 821 i.rem = 0; 822 i.index = (char *) i.data - (char *) R; 823 return i; 824 } 825 826 xcb_randr_output_t * 827 xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R /**< */) 828 { 829 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_crtcs_end(R); 830 return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); 831 } 832 833 int 834 xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) 835 { 836 return R->num_outputs; 837 } 838 839 xcb_generic_iterator_t 840 xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) 841 { 842 xcb_generic_iterator_t i; 843 xcb_generic_iterator_t child = xcb_randr_get_screen_resources_crtcs_end(R); 844 i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); 845 i.rem = 0; 846 i.index = (char *) i.data - (char *) R; 847 return i; 848 } 849 850 xcb_randr_mode_info_t * 851 xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R /**< */) 852 { 853 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R); 854 return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0); 855 } 856 857 int 858 xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) 859 { 860 return R->num_modes; 861 } 862 863 xcb_randr_mode_info_iterator_t 864 xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R /**< */) 865 { 866 xcb_randr_mode_info_iterator_t i; 867 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R); 868 i.data = (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index)); 869 i.rem = R->num_modes; 870 i.index = (char *) i.data - (char *) R; 871 return i; 872 } 873 874 uint8_t * 875 xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R /**< */) 876 { 877 xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R)); 878 return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); 879 } 880 881 int 882 xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) 883 { 884 return R->names_len; 885 } 886 887 xcb_generic_iterator_t 888 xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) 889 { 890 xcb_generic_iterator_t i; 891 xcb_generic_iterator_t child = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R)); 892 i.data = ((uint8_t *) child.data) + (R->names_len); 893 i.rem = 0; 894 i.index = (char *) i.data - (char *) R; 895 return i; 896 } 897 898 xcb_randr_get_screen_resources_reply_t * 899 xcb_randr_get_screen_resources_reply (xcb_connection_t *c /**< */, 900 xcb_randr_get_screen_resources_cookie_t cookie /**< */, 901 xcb_generic_error_t **e /**< */) 902 { 903 return (xcb_randr_get_screen_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 904 } 905 906 int 907 xcb_randr_get_output_info_sizeof (const void *_buffer /**< */) 908 { 909 char *xcb_tmp = (char *)_buffer; 910 const xcb_randr_get_output_info_reply_t *_aux = (xcb_randr_get_output_info_reply_t *)_buffer; 911 unsigned int xcb_buffer_len = 0; 912 unsigned int xcb_block_len = 0; 913 unsigned int xcb_pad = 0; 914 unsigned int xcb_align_to = 0; 915 916 917 xcb_block_len += sizeof(xcb_randr_get_output_info_reply_t); 918 xcb_tmp += xcb_block_len; 919 xcb_buffer_len += xcb_block_len; 920 xcb_block_len = 0; 921 /* crtcs */ 922 xcb_block_len += _aux->num_crtcs * sizeof(xcb_randr_output_t); 923 xcb_tmp += xcb_block_len; 924 xcb_align_to = ALIGNOF(xcb_randr_crtc_t); 925 /* insert padding */ 926 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 927 xcb_buffer_len += xcb_block_len + xcb_pad; 928 if (0 != xcb_pad) { 929 xcb_tmp += xcb_pad; 930 xcb_pad = 0; 931 } 932 xcb_block_len = 0; 933 /* modes */ 934 xcb_block_len += _aux->num_modes * sizeof(xcb_randr_output_t); 935 xcb_tmp += xcb_block_len; 936 xcb_align_to = ALIGNOF(xcb_randr_mode_t); 937 /* insert padding */ 938 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 939 xcb_buffer_len += xcb_block_len + xcb_pad; 940 if (0 != xcb_pad) { 941 xcb_tmp += xcb_pad; 942 xcb_pad = 0; 943 } 944 xcb_block_len = 0; 945 /* clones */ 946 xcb_block_len += _aux->num_clones * sizeof(xcb_randr_output_t); 947 xcb_tmp += xcb_block_len; 948 xcb_align_to = ALIGNOF(xcb_randr_output_t); 949 /* insert padding */ 950 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 951 xcb_buffer_len += xcb_block_len + xcb_pad; 952 if (0 != xcb_pad) { 953 xcb_tmp += xcb_pad; 954 xcb_pad = 0; 955 } 956 xcb_block_len = 0; 957 /* name */ 958 xcb_block_len += _aux->name_len * sizeof(uint8_t); 959 xcb_tmp += xcb_block_len; 960 xcb_align_to = ALIGNOF(uint8_t); 961 /* insert padding */ 962 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 963 xcb_buffer_len += xcb_block_len + xcb_pad; 964 if (0 != xcb_pad) { 965 xcb_tmp += xcb_pad; 966 xcb_pad = 0; 967 } 968 xcb_block_len = 0; 969 970 return xcb_buffer_len; 971 } 972 973 xcb_randr_get_output_info_cookie_t 974 xcb_randr_get_output_info (xcb_connection_t *c /**< */, 975 xcb_randr_output_t output /**< */, 976 xcb_timestamp_t config_timestamp /**< */) 977 { 978 static const xcb_protocol_request_t xcb_req = { 979 /* count */ 2, 980 /* ext */ &xcb_randr_id, 981 /* opcode */ XCB_RANDR_GET_OUTPUT_INFO, 982 /* isvoid */ 0 983 }; 984 985 struct iovec xcb_parts[4]; 986 xcb_randr_get_output_info_cookie_t xcb_ret; 987 xcb_randr_get_output_info_request_t xcb_out; 988 989 xcb_out.output = output; 990 xcb_out.config_timestamp = config_timestamp; 991 992 xcb_parts[2].iov_base = (char *) &xcb_out; 993 xcb_parts[2].iov_len = sizeof(xcb_out); 994 xcb_parts[3].iov_base = 0; 995 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 996 997 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 998 return xcb_ret; 999 } 1000 1001 xcb_randr_get_output_info_cookie_t 1002 xcb_randr_get_output_info_unchecked (xcb_connection_t *c /**< */, 1003 xcb_randr_output_t output /**< */, 1004 xcb_timestamp_t config_timestamp /**< */) 1005 { 1006 static const xcb_protocol_request_t xcb_req = { 1007 /* count */ 2, 1008 /* ext */ &xcb_randr_id, 1009 /* opcode */ XCB_RANDR_GET_OUTPUT_INFO, 1010 /* isvoid */ 0 1011 }; 1012 1013 struct iovec xcb_parts[4]; 1014 xcb_randr_get_output_info_cookie_t xcb_ret; 1015 xcb_randr_get_output_info_request_t xcb_out; 1016 1017 xcb_out.output = output; 1018 xcb_out.config_timestamp = config_timestamp; 1019 1020 xcb_parts[2].iov_base = (char *) &xcb_out; 1021 xcb_parts[2].iov_len = sizeof(xcb_out); 1022 xcb_parts[3].iov_base = 0; 1023 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1024 1025 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1026 return xcb_ret; 1027 } 1028 1029 xcb_randr_crtc_t * 1030 xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R /**< */) 1031 { 1032 return (xcb_randr_crtc_t *) (R + 1); 1033 } 1034 1035 int 1036 xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R /**< */) 1037 { 1038 return R->num_crtcs; 1039 } 1040 1041 xcb_generic_iterator_t 1042 xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R /**< */) 1043 { 1044 xcb_generic_iterator_t i; 1045 i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); 1046 i.rem = 0; 1047 i.index = (char *) i.data - (char *) R; 1048 return i; 1049 } 1050 1051 xcb_randr_mode_t * 1052 xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R /**< */) 1053 { 1054 xcb_generic_iterator_t prev = xcb_randr_get_output_info_crtcs_end(R); 1055 return (xcb_randr_mode_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_t, prev.index) + 0); 1056 } 1057 1058 int 1059 xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R /**< */) 1060 { 1061 return R->num_modes; 1062 } 1063 1064 xcb_generic_iterator_t 1065 xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R /**< */) 1066 { 1067 xcb_generic_iterator_t i; 1068 xcb_generic_iterator_t child = xcb_randr_get_output_info_crtcs_end(R); 1069 i.data = ((xcb_randr_mode_t *) child.data) + (R->num_modes); 1070 i.rem = 0; 1071 i.index = (char *) i.data - (char *) R; 1072 return i; 1073 } 1074 1075 xcb_randr_output_t * 1076 xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R /**< */) 1077 { 1078 xcb_generic_iterator_t prev = xcb_randr_get_output_info_modes_end(R); 1079 return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); 1080 } 1081 1082 int 1083 xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R /**< */) 1084 { 1085 return R->num_clones; 1086 } 1087 1088 xcb_generic_iterator_t 1089 xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R /**< */) 1090 { 1091 xcb_generic_iterator_t i; 1092 xcb_generic_iterator_t child = xcb_randr_get_output_info_modes_end(R); 1093 i.data = ((xcb_randr_output_t *) child.data) + (R->num_clones); 1094 i.rem = 0; 1095 i.index = (char *) i.data - (char *) R; 1096 return i; 1097 } 1098 1099 uint8_t * 1100 xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R /**< */) 1101 { 1102 xcb_generic_iterator_t prev = xcb_randr_get_output_info_clones_end(R); 1103 return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); 1104 } 1105 1106 int 1107 xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R /**< */) 1108 { 1109 return R->name_len; 1110 } 1111 1112 xcb_generic_iterator_t 1113 xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R /**< */) 1114 { 1115 xcb_generic_iterator_t i; 1116 xcb_generic_iterator_t child = xcb_randr_get_output_info_clones_end(R); 1117 i.data = ((uint8_t *) child.data) + (R->name_len); 1118 i.rem = 0; 1119 i.index = (char *) i.data - (char *) R; 1120 return i; 1121 } 1122 1123 xcb_randr_get_output_info_reply_t * 1124 xcb_randr_get_output_info_reply (xcb_connection_t *c /**< */, 1125 xcb_randr_get_output_info_cookie_t cookie /**< */, 1126 xcb_generic_error_t **e /**< */) 1127 { 1128 return (xcb_randr_get_output_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1129 } 1130 1131 int 1132 xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */) 1133 { 1134 char *xcb_tmp = (char *)_buffer; 1135 const xcb_randr_list_output_properties_reply_t *_aux = (xcb_randr_list_output_properties_reply_t *)_buffer; 1136 unsigned int xcb_buffer_len = 0; 1137 unsigned int xcb_block_len = 0; 1138 unsigned int xcb_pad = 0; 1139 unsigned int xcb_align_to = 0; 1140 1141 1142 xcb_block_len += sizeof(xcb_randr_list_output_properties_reply_t); 1143 xcb_tmp += xcb_block_len; 1144 xcb_buffer_len += xcb_block_len; 1145 xcb_block_len = 0; 1146 /* atoms */ 1147 xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t); 1148 xcb_tmp += xcb_block_len; 1149 xcb_align_to = ALIGNOF(xcb_atom_t); 1150 /* insert padding */ 1151 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1152 xcb_buffer_len += xcb_block_len + xcb_pad; 1153 if (0 != xcb_pad) { 1154 xcb_tmp += xcb_pad; 1155 xcb_pad = 0; 1156 } 1157 xcb_block_len = 0; 1158 1159 return xcb_buffer_len; 1160 } 1161 1162 xcb_randr_list_output_properties_cookie_t 1163 xcb_randr_list_output_properties (xcb_connection_t *c /**< */, 1164 xcb_randr_output_t output /**< */) 1165 { 1166 static const xcb_protocol_request_t xcb_req = { 1167 /* count */ 2, 1168 /* ext */ &xcb_randr_id, 1169 /* opcode */ XCB_RANDR_LIST_OUTPUT_PROPERTIES, 1170 /* isvoid */ 0 1171 }; 1172 1173 struct iovec xcb_parts[4]; 1174 xcb_randr_list_output_properties_cookie_t xcb_ret; 1175 xcb_randr_list_output_properties_request_t xcb_out; 1176 1177 xcb_out.output = output; 1178 1179 xcb_parts[2].iov_base = (char *) &xcb_out; 1180 xcb_parts[2].iov_len = sizeof(xcb_out); 1181 xcb_parts[3].iov_base = 0; 1182 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1183 1184 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1185 return xcb_ret; 1186 } 1187 1188 xcb_randr_list_output_properties_cookie_t 1189 xcb_randr_list_output_properties_unchecked (xcb_connection_t *c /**< */, 1190 xcb_randr_output_t output /**< */) 1191 { 1192 static const xcb_protocol_request_t xcb_req = { 1193 /* count */ 2, 1194 /* ext */ &xcb_randr_id, 1195 /* opcode */ XCB_RANDR_LIST_OUTPUT_PROPERTIES, 1196 /* isvoid */ 0 1197 }; 1198 1199 struct iovec xcb_parts[4]; 1200 xcb_randr_list_output_properties_cookie_t xcb_ret; 1201 xcb_randr_list_output_properties_request_t xcb_out; 1202 1203 xcb_out.output = output; 1204 1205 xcb_parts[2].iov_base = (char *) &xcb_out; 1206 xcb_parts[2].iov_len = sizeof(xcb_out); 1207 xcb_parts[3].iov_base = 0; 1208 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1209 1210 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1211 return xcb_ret; 1212 } 1213 1214 xcb_atom_t * 1215 xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R /**< */) 1216 { 1217 return (xcb_atom_t *) (R + 1); 1218 } 1219 1220 int 1221 xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R /**< */) 1222 { 1223 return R->num_atoms; 1224 } 1225 1226 xcb_generic_iterator_t 1227 xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R /**< */) 1228 { 1229 xcb_generic_iterator_t i; 1230 i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); 1231 i.rem = 0; 1232 i.index = (char *) i.data - (char *) R; 1233 return i; 1234 } 1235 1236 xcb_randr_list_output_properties_reply_t * 1237 xcb_randr_list_output_properties_reply (xcb_connection_t *c /**< */, 1238 xcb_randr_list_output_properties_cookie_t cookie /**< */, 1239 xcb_generic_error_t **e /**< */) 1240 { 1241 return (xcb_randr_list_output_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1242 } 1243 1244 int 1245 xcb_randr_query_output_property_sizeof (const void *_buffer /**< */) 1246 { 1247 char *xcb_tmp = (char *)_buffer; 1248 const xcb_randr_query_output_property_reply_t *_aux = (xcb_randr_query_output_property_reply_t *)_buffer; 1249 unsigned int xcb_buffer_len = 0; 1250 unsigned int xcb_block_len = 0; 1251 unsigned int xcb_pad = 0; 1252 unsigned int xcb_align_to = 0; 1253 1254 1255 xcb_block_len += sizeof(xcb_randr_query_output_property_reply_t); 1256 xcb_tmp += xcb_block_len; 1257 xcb_buffer_len += xcb_block_len; 1258 xcb_block_len = 0; 1259 /* validValues */ 1260 xcb_block_len += _aux->length * sizeof(int32_t); 1261 xcb_tmp += xcb_block_len; 1262 xcb_align_to = ALIGNOF(int32_t); 1263 /* insert padding */ 1264 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1265 xcb_buffer_len += xcb_block_len + xcb_pad; 1266 if (0 != xcb_pad) { 1267 xcb_tmp += xcb_pad; 1268 xcb_pad = 0; 1269 } 1270 xcb_block_len = 0; 1271 1272 return xcb_buffer_len; 1273 } 1274 1275 xcb_randr_query_output_property_cookie_t 1276 xcb_randr_query_output_property (xcb_connection_t *c /**< */, 1277 xcb_randr_output_t output /**< */, 1278 xcb_atom_t property /**< */) 1279 { 1280 static const xcb_protocol_request_t xcb_req = { 1281 /* count */ 2, 1282 /* ext */ &xcb_randr_id, 1283 /* opcode */ XCB_RANDR_QUERY_OUTPUT_PROPERTY, 1284 /* isvoid */ 0 1285 }; 1286 1287 struct iovec xcb_parts[4]; 1288 xcb_randr_query_output_property_cookie_t xcb_ret; 1289 xcb_randr_query_output_property_request_t xcb_out; 1290 1291 xcb_out.output = output; 1292 xcb_out.property = property; 1293 1294 xcb_parts[2].iov_base = (char *) &xcb_out; 1295 xcb_parts[2].iov_len = sizeof(xcb_out); 1296 xcb_parts[3].iov_base = 0; 1297 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1298 1299 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1300 return xcb_ret; 1301 } 1302 1303 xcb_randr_query_output_property_cookie_t 1304 xcb_randr_query_output_property_unchecked (xcb_connection_t *c /**< */, 1305 xcb_randr_output_t output /**< */, 1306 xcb_atom_t property /**< */) 1307 { 1308 static const xcb_protocol_request_t xcb_req = { 1309 /* count */ 2, 1310 /* ext */ &xcb_randr_id, 1311 /* opcode */ XCB_RANDR_QUERY_OUTPUT_PROPERTY, 1312 /* isvoid */ 0 1313 }; 1314 1315 struct iovec xcb_parts[4]; 1316 xcb_randr_query_output_property_cookie_t xcb_ret; 1317 xcb_randr_query_output_property_request_t xcb_out; 1318 1319 xcb_out.output = output; 1320 xcb_out.property = property; 1321 1322 xcb_parts[2].iov_base = (char *) &xcb_out; 1323 xcb_parts[2].iov_len = sizeof(xcb_out); 1324 xcb_parts[3].iov_base = 0; 1325 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1326 1327 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1328 return xcb_ret; 1329 } 1330 1331 int32_t * 1332 xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R /**< */) 1333 { 1334 return (int32_t *) (R + 1); 1335 } 1336 1337 int 1338 xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R /**< */) 1339 { 1340 return R->length; 1341 } 1342 1343 xcb_generic_iterator_t 1344 xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R /**< */) 1345 { 1346 xcb_generic_iterator_t i; 1347 i.data = ((int32_t *) (R + 1)) + (R->length); 1348 i.rem = 0; 1349 i.index = (char *) i.data - (char *) R; 1350 return i; 1351 } 1352 1353 xcb_randr_query_output_property_reply_t * 1354 xcb_randr_query_output_property_reply (xcb_connection_t *c /**< */, 1355 xcb_randr_query_output_property_cookie_t cookie /**< */, 1356 xcb_generic_error_t **e /**< */) 1357 { 1358 return (xcb_randr_query_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1359 } 1360 1361 int 1362 xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, 1363 uint32_t values_len /**< */) 1364 { 1365 char *xcb_tmp = (char *)_buffer; 1366 unsigned int xcb_buffer_len = 0; 1367 unsigned int xcb_block_len = 0; 1368 unsigned int xcb_pad = 0; 1369 unsigned int xcb_align_to = 0; 1370 1371 1372 xcb_block_len += sizeof(xcb_randr_configure_output_property_request_t); 1373 xcb_tmp += xcb_block_len; 1374 xcb_buffer_len += xcb_block_len; 1375 xcb_block_len = 0; 1376 /* values */ 1377 xcb_block_len += values_len * sizeof(int32_t); 1378 xcb_tmp += xcb_block_len; 1379 xcb_align_to = ALIGNOF(int32_t); 1380 /* insert padding */ 1381 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1382 xcb_buffer_len += xcb_block_len + xcb_pad; 1383 if (0 != xcb_pad) { 1384 xcb_tmp += xcb_pad; 1385 xcb_pad = 0; 1386 } 1387 xcb_block_len = 0; 1388 1389 return xcb_buffer_len; 1390 } 1391 1392 xcb_void_cookie_t 1393 xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, 1394 xcb_randr_output_t output /**< */, 1395 xcb_atom_t property /**< */, 1396 uint8_t pending /**< */, 1397 uint8_t range /**< */, 1398 uint32_t values_len /**< */, 1399 const int32_t *values /**< */) 1400 { 1401 static const xcb_protocol_request_t xcb_req = { 1402 /* count */ 4, 1403 /* ext */ &xcb_randr_id, 1404 /* opcode */ XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, 1405 /* isvoid */ 1 1406 }; 1407 1408 struct iovec xcb_parts[6]; 1409 xcb_void_cookie_t xcb_ret; 1410 xcb_randr_configure_output_property_request_t xcb_out; 1411 1412 xcb_out.output = output; 1413 xcb_out.property = property; 1414 xcb_out.pending = pending; 1415 xcb_out.range = range; 1416 memset(xcb_out.pad0, 0, 2); 1417 1418 xcb_parts[2].iov_base = (char *) &xcb_out; 1419 xcb_parts[2].iov_len = sizeof(xcb_out); 1420 xcb_parts[3].iov_base = 0; 1421 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1422 /* int32_t values */ 1423 xcb_parts[4].iov_base = (char *) values; 1424 xcb_parts[4].iov_len = values_len * sizeof(int32_t); 1425 xcb_parts[5].iov_base = 0; 1426 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1427 1428 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1429 return xcb_ret; 1430 } 1431 1432 xcb_void_cookie_t 1433 xcb_randr_configure_output_property (xcb_connection_t *c /**< */, 1434 xcb_randr_output_t output /**< */, 1435 xcb_atom_t property /**< */, 1436 uint8_t pending /**< */, 1437 uint8_t range /**< */, 1438 uint32_t values_len /**< */, 1439 const int32_t *values /**< */) 1440 { 1441 static const xcb_protocol_request_t xcb_req = { 1442 /* count */ 4, 1443 /* ext */ &xcb_randr_id, 1444 /* opcode */ XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, 1445 /* isvoid */ 1 1446 }; 1447 1448 struct iovec xcb_parts[6]; 1449 xcb_void_cookie_t xcb_ret; 1450 xcb_randr_configure_output_property_request_t xcb_out; 1451 1452 xcb_out.output = output; 1453 xcb_out.property = property; 1454 xcb_out.pending = pending; 1455 xcb_out.range = range; 1456 memset(xcb_out.pad0, 0, 2); 1457 1458 xcb_parts[2].iov_base = (char *) &xcb_out; 1459 xcb_parts[2].iov_len = sizeof(xcb_out); 1460 xcb_parts[3].iov_base = 0; 1461 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1462 /* int32_t values */ 1463 xcb_parts[4].iov_base = (char *) values; 1464 xcb_parts[4].iov_len = values_len * sizeof(int32_t); 1465 xcb_parts[5].iov_base = 0; 1466 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1467 1468 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1469 return xcb_ret; 1470 } 1471 1472 int 1473 xcb_randr_change_output_property_sizeof (const void *_buffer /**< */) 1474 { 1475 char *xcb_tmp = (char *)_buffer; 1476 const xcb_randr_change_output_property_request_t *_aux = (xcb_randr_change_output_property_request_t *)_buffer; 1477 unsigned int xcb_buffer_len = 0; 1478 unsigned int xcb_block_len = 0; 1479 unsigned int xcb_pad = 0; 1480 unsigned int xcb_align_to = 0; 1481 1482 1483 xcb_block_len += sizeof(xcb_randr_change_output_property_request_t); 1484 xcb_tmp += xcb_block_len; 1485 xcb_buffer_len += xcb_block_len; 1486 xcb_block_len = 0; 1487 /* data */ 1488 xcb_block_len += ((_aux->num_units * _aux->format) / 8) * sizeof(char); 1489 xcb_tmp += xcb_block_len; 1490 xcb_align_to = ALIGNOF(char); 1491 /* insert padding */ 1492 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1493 xcb_buffer_len += xcb_block_len + xcb_pad; 1494 if (0 != xcb_pad) { 1495 xcb_tmp += xcb_pad; 1496 xcb_pad = 0; 1497 } 1498 xcb_block_len = 0; 1499 1500 return xcb_buffer_len; 1501 } 1502 1503 xcb_void_cookie_t 1504 xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, 1505 xcb_randr_output_t output /**< */, 1506 xcb_atom_t property /**< */, 1507 xcb_atom_t type /**< */, 1508 uint8_t format /**< */, 1509 uint8_t mode /**< */, 1510 uint32_t num_units /**< */, 1511 const void *data /**< */) 1512 { 1513 static const xcb_protocol_request_t xcb_req = { 1514 /* count */ 4, 1515 /* ext */ &xcb_randr_id, 1516 /* opcode */ XCB_RANDR_CHANGE_OUTPUT_PROPERTY, 1517 /* isvoid */ 1 1518 }; 1519 1520 struct iovec xcb_parts[6]; 1521 xcb_void_cookie_t xcb_ret; 1522 xcb_randr_change_output_property_request_t xcb_out; 1523 1524 xcb_out.output = output; 1525 xcb_out.property = property; 1526 xcb_out.type = type; 1527 xcb_out.format = format; 1528 xcb_out.mode = mode; 1529 memset(xcb_out.pad0, 0, 2); 1530 xcb_out.num_units = num_units; 1531 1532 xcb_parts[2].iov_base = (char *) &xcb_out; 1533 xcb_parts[2].iov_len = sizeof(xcb_out); 1534 xcb_parts[3].iov_base = 0; 1535 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1536 /* void data */ 1537 xcb_parts[4].iov_base = (char *) data; 1538 xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char); 1539 xcb_parts[5].iov_base = 0; 1540 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1541 1542 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1543 return xcb_ret; 1544 } 1545 1546 xcb_void_cookie_t 1547 xcb_randr_change_output_property (xcb_connection_t *c /**< */, 1548 xcb_randr_output_t output /**< */, 1549 xcb_atom_t property /**< */, 1550 xcb_atom_t type /**< */, 1551 uint8_t format /**< */, 1552 uint8_t mode /**< */, 1553 uint32_t num_units /**< */, 1554 const void *data /**< */) 1555 { 1556 static const xcb_protocol_request_t xcb_req = { 1557 /* count */ 4, 1558 /* ext */ &xcb_randr_id, 1559 /* opcode */ XCB_RANDR_CHANGE_OUTPUT_PROPERTY, 1560 /* isvoid */ 1 1561 }; 1562 1563 struct iovec xcb_parts[6]; 1564 xcb_void_cookie_t xcb_ret; 1565 xcb_randr_change_output_property_request_t xcb_out; 1566 1567 xcb_out.output = output; 1568 xcb_out.property = property; 1569 xcb_out.type = type; 1570 xcb_out.format = format; 1571 xcb_out.mode = mode; 1572 memset(xcb_out.pad0, 0, 2); 1573 xcb_out.num_units = num_units; 1574 1575 xcb_parts[2].iov_base = (char *) &xcb_out; 1576 xcb_parts[2].iov_len = sizeof(xcb_out); 1577 xcb_parts[3].iov_base = 0; 1578 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1579 /* void data */ 1580 xcb_parts[4].iov_base = (char *) data; 1581 xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char); 1582 xcb_parts[5].iov_base = 0; 1583 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1584 1585 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1586 return xcb_ret; 1587 } 1588 1589 xcb_void_cookie_t 1590 xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, 1591 xcb_randr_output_t output /**< */, 1592 xcb_atom_t property /**< */) 1593 { 1594 static const xcb_protocol_request_t xcb_req = { 1595 /* count */ 2, 1596 /* ext */ &xcb_randr_id, 1597 /* opcode */ XCB_RANDR_DELETE_OUTPUT_PROPERTY, 1598 /* isvoid */ 1 1599 }; 1600 1601 struct iovec xcb_parts[4]; 1602 xcb_void_cookie_t xcb_ret; 1603 xcb_randr_delete_output_property_request_t xcb_out; 1604 1605 xcb_out.output = output; 1606 xcb_out.property = property; 1607 1608 xcb_parts[2].iov_base = (char *) &xcb_out; 1609 xcb_parts[2].iov_len = sizeof(xcb_out); 1610 xcb_parts[3].iov_base = 0; 1611 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1612 1613 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1614 return xcb_ret; 1615 } 1616 1617 xcb_void_cookie_t 1618 xcb_randr_delete_output_property (xcb_connection_t *c /**< */, 1619 xcb_randr_output_t output /**< */, 1620 xcb_atom_t property /**< */) 1621 { 1622 static const xcb_protocol_request_t xcb_req = { 1623 /* count */ 2, 1624 /* ext */ &xcb_randr_id, 1625 /* opcode */ XCB_RANDR_DELETE_OUTPUT_PROPERTY, 1626 /* isvoid */ 1 1627 }; 1628 1629 struct iovec xcb_parts[4]; 1630 xcb_void_cookie_t xcb_ret; 1631 xcb_randr_delete_output_property_request_t xcb_out; 1632 1633 xcb_out.output = output; 1634 xcb_out.property = property; 1635 1636 xcb_parts[2].iov_base = (char *) &xcb_out; 1637 xcb_parts[2].iov_len = sizeof(xcb_out); 1638 xcb_parts[3].iov_base = 0; 1639 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1640 1641 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1642 return xcb_ret; 1643 } 1644 1645 int 1646 xcb_randr_get_output_property_sizeof (const void *_buffer /**< */) 1647 { 1648 char *xcb_tmp = (char *)_buffer; 1649 const xcb_randr_get_output_property_reply_t *_aux = (xcb_randr_get_output_property_reply_t *)_buffer; 1650 unsigned int xcb_buffer_len = 0; 1651 unsigned int xcb_block_len = 0; 1652 unsigned int xcb_pad = 0; 1653 unsigned int xcb_align_to = 0; 1654 1655 1656 xcb_block_len += sizeof(xcb_randr_get_output_property_reply_t); 1657 xcb_tmp += xcb_block_len; 1658 xcb_buffer_len += xcb_block_len; 1659 xcb_block_len = 0; 1660 /* data */ 1661 xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(uint8_t); 1662 xcb_tmp += xcb_block_len; 1663 xcb_align_to = ALIGNOF(uint8_t); 1664 /* insert padding */ 1665 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1666 xcb_buffer_len += xcb_block_len + xcb_pad; 1667 if (0 != xcb_pad) { 1668 xcb_tmp += xcb_pad; 1669 xcb_pad = 0; 1670 } 1671 xcb_block_len = 0; 1672 1673 return xcb_buffer_len; 1674 } 1675 1676 xcb_randr_get_output_property_cookie_t 1677 xcb_randr_get_output_property (xcb_connection_t *c /**< */, 1678 xcb_randr_output_t output /**< */, 1679 xcb_atom_t property /**< */, 1680 xcb_atom_t type /**< */, 1681 uint32_t long_offset /**< */, 1682 uint32_t long_length /**< */, 1683 uint8_t _delete /**< */, 1684 uint8_t pending /**< */) 1685 { 1686 static const xcb_protocol_request_t xcb_req = { 1687 /* count */ 2, 1688 /* ext */ &xcb_randr_id, 1689 /* opcode */ XCB_RANDR_GET_OUTPUT_PROPERTY, 1690 /* isvoid */ 0 1691 }; 1692 1693 struct iovec xcb_parts[4]; 1694 xcb_randr_get_output_property_cookie_t xcb_ret; 1695 xcb_randr_get_output_property_request_t xcb_out; 1696 1697 xcb_out.output = output; 1698 xcb_out.property = property; 1699 xcb_out.type = type; 1700 xcb_out.long_offset = long_offset; 1701 xcb_out.long_length = long_length; 1702 xcb_out._delete = _delete; 1703 xcb_out.pending = pending; 1704 memset(xcb_out.pad0, 0, 2); 1705 1706 xcb_parts[2].iov_base = (char *) &xcb_out; 1707 xcb_parts[2].iov_len = sizeof(xcb_out); 1708 xcb_parts[3].iov_base = 0; 1709 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1710 1711 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1712 return xcb_ret; 1713 } 1714 1715 xcb_randr_get_output_property_cookie_t 1716 xcb_randr_get_output_property_unchecked (xcb_connection_t *c /**< */, 1717 xcb_randr_output_t output /**< */, 1718 xcb_atom_t property /**< */, 1719 xcb_atom_t type /**< */, 1720 uint32_t long_offset /**< */, 1721 uint32_t long_length /**< */, 1722 uint8_t _delete /**< */, 1723 uint8_t pending /**< */) 1724 { 1725 static const xcb_protocol_request_t xcb_req = { 1726 /* count */ 2, 1727 /* ext */ &xcb_randr_id, 1728 /* opcode */ XCB_RANDR_GET_OUTPUT_PROPERTY, 1729 /* isvoid */ 0 1730 }; 1731 1732 struct iovec xcb_parts[4]; 1733 xcb_randr_get_output_property_cookie_t xcb_ret; 1734 xcb_randr_get_output_property_request_t xcb_out; 1735 1736 xcb_out.output = output; 1737 xcb_out.property = property; 1738 xcb_out.type = type; 1739 xcb_out.long_offset = long_offset; 1740 xcb_out.long_length = long_length; 1741 xcb_out._delete = _delete; 1742 xcb_out.pending = pending; 1743 memset(xcb_out.pad0, 0, 2); 1744 1745 xcb_parts[2].iov_base = (char *) &xcb_out; 1746 xcb_parts[2].iov_len = sizeof(xcb_out); 1747 xcb_parts[3].iov_base = 0; 1748 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1749 1750 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1751 return xcb_ret; 1752 } 1753 1754 uint8_t * 1755 xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R /**< */) 1756 { 1757 return (uint8_t *) (R + 1); 1758 } 1759 1760 int 1761 xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R /**< */) 1762 { 1763 return (R->num_items * (R->format / 8)); 1764 } 1765 1766 xcb_generic_iterator_t 1767 xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R /**< */) 1768 { 1769 xcb_generic_iterator_t i; 1770 i.data = ((uint8_t *) (R + 1)) + ((R->num_items * (R->format / 8))); 1771 i.rem = 0; 1772 i.index = (char *) i.data - (char *) R; 1773 return i; 1774 } 1775 1776 xcb_randr_get_output_property_reply_t * 1777 xcb_randr_get_output_property_reply (xcb_connection_t *c /**< */, 1778 xcb_randr_get_output_property_cookie_t cookie /**< */, 1779 xcb_generic_error_t **e /**< */) 1780 { 1781 return (xcb_randr_get_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1782 } 1783 1784 int 1785 xcb_randr_create_mode_sizeof (const void *_buffer /**< */, 1786 uint32_t name_len /**< */) 1787 { 1788 char *xcb_tmp = (char *)_buffer; 1789 unsigned int xcb_buffer_len = 0; 1790 unsigned int xcb_block_len = 0; 1791 unsigned int xcb_pad = 0; 1792 unsigned int xcb_align_to = 0; 1793 1794 1795 xcb_block_len += sizeof(xcb_randr_create_mode_request_t); 1796 xcb_tmp += xcb_block_len; 1797 xcb_buffer_len += xcb_block_len; 1798 xcb_block_len = 0; 1799 /* name */ 1800 xcb_block_len += name_len * sizeof(char); 1801 xcb_tmp += xcb_block_len; 1802 xcb_align_to = ALIGNOF(char); 1803 /* insert padding */ 1804 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1805 xcb_buffer_len += xcb_block_len + xcb_pad; 1806 if (0 != xcb_pad) { 1807 xcb_tmp += xcb_pad; 1808 xcb_pad = 0; 1809 } 1810 xcb_block_len = 0; 1811 1812 return xcb_buffer_len; 1813 } 1814 1815 xcb_randr_create_mode_cookie_t 1816 xcb_randr_create_mode (xcb_connection_t *c /**< */, 1817 xcb_window_t window /**< */, 1818 xcb_randr_mode_info_t mode_info /**< */, 1819 uint32_t name_len /**< */, 1820 const char *name /**< */) 1821 { 1822 static const xcb_protocol_request_t xcb_req = { 1823 /* count */ 4, 1824 /* ext */ &xcb_randr_id, 1825 /* opcode */ XCB_RANDR_CREATE_MODE, 1826 /* isvoid */ 0 1827 }; 1828 1829 struct iovec xcb_parts[6]; 1830 xcb_randr_create_mode_cookie_t xcb_ret; 1831 xcb_randr_create_mode_request_t xcb_out; 1832 1833 xcb_out.window = window; 1834 xcb_out.mode_info = mode_info; 1835 1836 xcb_parts[2].iov_base = (char *) &xcb_out; 1837 xcb_parts[2].iov_len = sizeof(xcb_out); 1838 xcb_parts[3].iov_base = 0; 1839 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1840 /* char name */ 1841 xcb_parts[4].iov_base = (char *) name; 1842 xcb_parts[4].iov_len = name_len * sizeof(char); 1843 xcb_parts[5].iov_base = 0; 1844 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1845 1846 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1847 return xcb_ret; 1848 } 1849 1850 xcb_randr_create_mode_cookie_t 1851 xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, 1852 xcb_window_t window /**< */, 1853 xcb_randr_mode_info_t mode_info /**< */, 1854 uint32_t name_len /**< */, 1855 const char *name /**< */) 1856 { 1857 static const xcb_protocol_request_t xcb_req = { 1858 /* count */ 4, 1859 /* ext */ &xcb_randr_id, 1860 /* opcode */ XCB_RANDR_CREATE_MODE, 1861 /* isvoid */ 0 1862 }; 1863 1864 struct iovec xcb_parts[6]; 1865 xcb_randr_create_mode_cookie_t xcb_ret; 1866 xcb_randr_create_mode_request_t xcb_out; 1867 1868 xcb_out.window = window; 1869 xcb_out.mode_info = mode_info; 1870 1871 xcb_parts[2].iov_base = (char *) &xcb_out; 1872 xcb_parts[2].iov_len = sizeof(xcb_out); 1873 xcb_parts[3].iov_base = 0; 1874 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1875 /* char name */ 1876 xcb_parts[4].iov_base = (char *) name; 1877 xcb_parts[4].iov_len = name_len * sizeof(char); 1878 xcb_parts[5].iov_base = 0; 1879 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1880 1881 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1882 return xcb_ret; 1883 } 1884 1885 xcb_randr_create_mode_reply_t * 1886 xcb_randr_create_mode_reply (xcb_connection_t *c /**< */, 1887 xcb_randr_create_mode_cookie_t cookie /**< */, 1888 xcb_generic_error_t **e /**< */) 1889 { 1890 return (xcb_randr_create_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1891 } 1892 1893 xcb_void_cookie_t 1894 xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, 1895 xcb_randr_mode_t mode /**< */) 1896 { 1897 static const xcb_protocol_request_t xcb_req = { 1898 /* count */ 2, 1899 /* ext */ &xcb_randr_id, 1900 /* opcode */ XCB_RANDR_DESTROY_MODE, 1901 /* isvoid */ 1 1902 }; 1903 1904 struct iovec xcb_parts[4]; 1905 xcb_void_cookie_t xcb_ret; 1906 xcb_randr_destroy_mode_request_t xcb_out; 1907 1908 xcb_out.mode = mode; 1909 1910 xcb_parts[2].iov_base = (char *) &xcb_out; 1911 xcb_parts[2].iov_len = sizeof(xcb_out); 1912 xcb_parts[3].iov_base = 0; 1913 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1914 1915 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1916 return xcb_ret; 1917 } 1918 1919 xcb_void_cookie_t 1920 xcb_randr_destroy_mode (xcb_connection_t *c /**< */, 1921 xcb_randr_mode_t mode /**< */) 1922 { 1923 static const xcb_protocol_request_t xcb_req = { 1924 /* count */ 2, 1925 /* ext */ &xcb_randr_id, 1926 /* opcode */ XCB_RANDR_DESTROY_MODE, 1927 /* isvoid */ 1 1928 }; 1929 1930 struct iovec xcb_parts[4]; 1931 xcb_void_cookie_t xcb_ret; 1932 xcb_randr_destroy_mode_request_t xcb_out; 1933 1934 xcb_out.mode = mode; 1935 1936 xcb_parts[2].iov_base = (char *) &xcb_out; 1937 xcb_parts[2].iov_len = sizeof(xcb_out); 1938 xcb_parts[3].iov_base = 0; 1939 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1940 1941 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1942 return xcb_ret; 1943 } 1944 1945 xcb_void_cookie_t 1946 xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, 1947 xcb_randr_output_t output /**< */, 1948 xcb_randr_mode_t mode /**< */) 1949 { 1950 static const xcb_protocol_request_t xcb_req = { 1951 /* count */ 2, 1952 /* ext */ &xcb_randr_id, 1953 /* opcode */ XCB_RANDR_ADD_OUTPUT_MODE, 1954 /* isvoid */ 1 1955 }; 1956 1957 struct iovec xcb_parts[4]; 1958 xcb_void_cookie_t xcb_ret; 1959 xcb_randr_add_output_mode_request_t xcb_out; 1960 1961 xcb_out.output = output; 1962 xcb_out.mode = mode; 1963 1964 xcb_parts[2].iov_base = (char *) &xcb_out; 1965 xcb_parts[2].iov_len = sizeof(xcb_out); 1966 xcb_parts[3].iov_base = 0; 1967 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1968 1969 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1970 return xcb_ret; 1971 } 1972 1973 xcb_void_cookie_t 1974 xcb_randr_add_output_mode (xcb_connection_t *c /**< */, 1975 xcb_randr_output_t output /**< */, 1976 xcb_randr_mode_t mode /**< */) 1977 { 1978 static const xcb_protocol_request_t xcb_req = { 1979 /* count */ 2, 1980 /* ext */ &xcb_randr_id, 1981 /* opcode */ XCB_RANDR_ADD_OUTPUT_MODE, 1982 /* isvoid */ 1 1983 }; 1984 1985 struct iovec xcb_parts[4]; 1986 xcb_void_cookie_t xcb_ret; 1987 xcb_randr_add_output_mode_request_t xcb_out; 1988 1989 xcb_out.output = output; 1990 xcb_out.mode = mode; 1991 1992 xcb_parts[2].iov_base = (char *) &xcb_out; 1993 xcb_parts[2].iov_len = sizeof(xcb_out); 1994 xcb_parts[3].iov_base = 0; 1995 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1996 1997 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1998 return xcb_ret; 1999 } 2000 2001 xcb_void_cookie_t 2002 xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, 2003 xcb_randr_output_t output /**< */, 2004 xcb_randr_mode_t mode /**< */) 2005 { 2006 static const xcb_protocol_request_t xcb_req = { 2007 /* count */ 2, 2008 /* ext */ &xcb_randr_id, 2009 /* opcode */ XCB_RANDR_DELETE_OUTPUT_MODE, 2010 /* isvoid */ 1 2011 }; 2012 2013 struct iovec xcb_parts[4]; 2014 xcb_void_cookie_t xcb_ret; 2015 xcb_randr_delete_output_mode_request_t xcb_out; 2016 2017 xcb_out.output = output; 2018 xcb_out.mode = mode; 2019 2020 xcb_parts[2].iov_base = (char *) &xcb_out; 2021 xcb_parts[2].iov_len = sizeof(xcb_out); 2022 xcb_parts[3].iov_base = 0; 2023 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2024 2025 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2026 return xcb_ret; 2027 } 2028 2029 xcb_void_cookie_t 2030 xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, 2031 xcb_randr_output_t output /**< */, 2032 xcb_randr_mode_t mode /**< */) 2033 { 2034 static const xcb_protocol_request_t xcb_req = { 2035 /* count */ 2, 2036 /* ext */ &xcb_randr_id, 2037 /* opcode */ XCB_RANDR_DELETE_OUTPUT_MODE, 2038 /* isvoid */ 1 2039 }; 2040 2041 struct iovec xcb_parts[4]; 2042 xcb_void_cookie_t xcb_ret; 2043 xcb_randr_delete_output_mode_request_t xcb_out; 2044 2045 xcb_out.output = output; 2046 xcb_out.mode = mode; 2047 2048 xcb_parts[2].iov_base = (char *) &xcb_out; 2049 xcb_parts[2].iov_len = sizeof(xcb_out); 2050 xcb_parts[3].iov_base = 0; 2051 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2052 2053 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2054 return xcb_ret; 2055 } 2056 2057 int 2058 xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */) 2059 { 2060 char *xcb_tmp = (char *)_buffer; 2061 const xcb_randr_get_crtc_info_reply_t *_aux = (xcb_randr_get_crtc_info_reply_t *)_buffer; 2062 unsigned int xcb_buffer_len = 0; 2063 unsigned int xcb_block_len = 0; 2064 unsigned int xcb_pad = 0; 2065 unsigned int xcb_align_to = 0; 2066 2067 2068 xcb_block_len += sizeof(xcb_randr_get_crtc_info_reply_t); 2069 xcb_tmp += xcb_block_len; 2070 xcb_buffer_len += xcb_block_len; 2071 xcb_block_len = 0; 2072 /* outputs */ 2073 xcb_block_len += _aux->num_outputs * sizeof(xcb_randr_output_t); 2074 xcb_tmp += xcb_block_len; 2075 xcb_align_to = ALIGNOF(xcb_randr_output_t); 2076 /* insert padding */ 2077 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2078 xcb_buffer_len += xcb_block_len + xcb_pad; 2079 if (0 != xcb_pad) { 2080 xcb_tmp += xcb_pad; 2081 xcb_pad = 0; 2082 } 2083 xcb_block_len = 0; 2084 /* possible */ 2085 xcb_block_len += _aux->num_possible_outputs * sizeof(xcb_randr_output_t); 2086 xcb_tmp += xcb_block_len; 2087 xcb_align_to = ALIGNOF(xcb_randr_output_t); 2088 /* insert padding */ 2089 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2090 xcb_buffer_len += xcb_block_len + xcb_pad; 2091 if (0 != xcb_pad) { 2092 xcb_tmp += xcb_pad; 2093 xcb_pad = 0; 2094 } 2095 xcb_block_len = 0; 2096 2097 return xcb_buffer_len; 2098 } 2099 2100 xcb_randr_get_crtc_info_cookie_t 2101 xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, 2102 xcb_randr_crtc_t crtc /**< */, 2103 xcb_timestamp_t config_timestamp /**< */) 2104 { 2105 static const xcb_protocol_request_t xcb_req = { 2106 /* count */ 2, 2107 /* ext */ &xcb_randr_id, 2108 /* opcode */ XCB_RANDR_GET_CRTC_INFO, 2109 /* isvoid */ 0 2110 }; 2111 2112 struct iovec xcb_parts[4]; 2113 xcb_randr_get_crtc_info_cookie_t xcb_ret; 2114 xcb_randr_get_crtc_info_request_t xcb_out; 2115 2116 xcb_out.crtc = crtc; 2117 xcb_out.config_timestamp = config_timestamp; 2118 2119 xcb_parts[2].iov_base = (char *) &xcb_out; 2120 xcb_parts[2].iov_len = sizeof(xcb_out); 2121 xcb_parts[3].iov_base = 0; 2122 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2123 2124 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2125 return xcb_ret; 2126 } 2127 2128 xcb_randr_get_crtc_info_cookie_t 2129 xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c /**< */, 2130 xcb_randr_crtc_t crtc /**< */, 2131 xcb_timestamp_t config_timestamp /**< */) 2132 { 2133 static const xcb_protocol_request_t xcb_req = { 2134 /* count */ 2, 2135 /* ext */ &xcb_randr_id, 2136 /* opcode */ XCB_RANDR_GET_CRTC_INFO, 2137 /* isvoid */ 0 2138 }; 2139 2140 struct iovec xcb_parts[4]; 2141 xcb_randr_get_crtc_info_cookie_t xcb_ret; 2142 xcb_randr_get_crtc_info_request_t xcb_out; 2143 2144 xcb_out.crtc = crtc; 2145 xcb_out.config_timestamp = config_timestamp; 2146 2147 xcb_parts[2].iov_base = (char *) &xcb_out; 2148 xcb_parts[2].iov_len = sizeof(xcb_out); 2149 xcb_parts[3].iov_base = 0; 2150 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2151 2152 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2153 return xcb_ret; 2154 } 2155 2156 xcb_randr_output_t * 2157 xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2158 { 2159 return (xcb_randr_output_t *) (R + 1); 2160 } 2161 2162 int 2163 xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2164 { 2165 return R->num_outputs; 2166 } 2167 2168 xcb_generic_iterator_t 2169 xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2170 { 2171 xcb_generic_iterator_t i; 2172 i.data = ((xcb_randr_output_t *) (R + 1)) + (R->num_outputs); 2173 i.rem = 0; 2174 i.index = (char *) i.data - (char *) R; 2175 return i; 2176 } 2177 2178 xcb_randr_output_t * 2179 xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2180 { 2181 xcb_generic_iterator_t prev = xcb_randr_get_crtc_info_outputs_end(R); 2182 return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); 2183 } 2184 2185 int 2186 xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2187 { 2188 return R->num_possible_outputs; 2189 } 2190 2191 xcb_generic_iterator_t 2192 xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R /**< */) 2193 { 2194 xcb_generic_iterator_t i; 2195 xcb_generic_iterator_t child = xcb_randr_get_crtc_info_outputs_end(R); 2196 i.data = ((xcb_randr_output_t *) child.data) + (R->num_possible_outputs); 2197 i.rem = 0; 2198 i.index = (char *) i.data - (char *) R; 2199 return i; 2200 } 2201 2202 xcb_randr_get_crtc_info_reply_t * 2203 xcb_randr_get_crtc_info_reply (xcb_connection_t *c /**< */, 2204 xcb_randr_get_crtc_info_cookie_t cookie /**< */, 2205 xcb_generic_error_t **e /**< */) 2206 { 2207 return (xcb_randr_get_crtc_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2208 } 2209 2210 int 2211 xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, 2212 uint32_t outputs_len /**< */) 2213 { 2214 char *xcb_tmp = (char *)_buffer; 2215 unsigned int xcb_buffer_len = 0; 2216 unsigned int xcb_block_len = 0; 2217 unsigned int xcb_pad = 0; 2218 unsigned int xcb_align_to = 0; 2219 2220 2221 xcb_block_len += sizeof(xcb_randr_set_crtc_config_request_t); 2222 xcb_tmp += xcb_block_len; 2223 xcb_buffer_len += xcb_block_len; 2224 xcb_block_len = 0; 2225 /* outputs */ 2226 xcb_block_len += outputs_len * sizeof(xcb_randr_output_t); 2227 xcb_tmp += xcb_block_len; 2228 xcb_align_to = ALIGNOF(xcb_randr_output_t); 2229 /* insert padding */ 2230 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2231 xcb_buffer_len += xcb_block_len + xcb_pad; 2232 if (0 != xcb_pad) { 2233 xcb_tmp += xcb_pad; 2234 xcb_pad = 0; 2235 } 2236 xcb_block_len = 0; 2237 2238 return xcb_buffer_len; 2239 } 2240 2241 xcb_randr_set_crtc_config_cookie_t 2242 xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, 2243 xcb_randr_crtc_t crtc /**< */, 2244 xcb_timestamp_t timestamp /**< */, 2245 xcb_timestamp_t config_timestamp /**< */, 2246 int16_t x /**< */, 2247 int16_t y /**< */, 2248 xcb_randr_mode_t mode /**< */, 2249 uint16_t rotation /**< */, 2250 uint32_t outputs_len /**< */, 2251 const xcb_randr_output_t *outputs /**< */) 2252 { 2253 static const xcb_protocol_request_t xcb_req = { 2254 /* count */ 4, 2255 /* ext */ &xcb_randr_id, 2256 /* opcode */ XCB_RANDR_SET_CRTC_CONFIG, 2257 /* isvoid */ 0 2258 }; 2259 2260 struct iovec xcb_parts[6]; 2261 xcb_randr_set_crtc_config_cookie_t xcb_ret; 2262 xcb_randr_set_crtc_config_request_t xcb_out; 2263 2264 xcb_out.crtc = crtc; 2265 xcb_out.timestamp = timestamp; 2266 xcb_out.config_timestamp = config_timestamp; 2267 xcb_out.x = x; 2268 xcb_out.y = y; 2269 xcb_out.mode = mode; 2270 xcb_out.rotation = rotation; 2271 memset(xcb_out.pad0, 0, 2); 2272 2273 xcb_parts[2].iov_base = (char *) &xcb_out; 2274 xcb_parts[2].iov_len = sizeof(xcb_out); 2275 xcb_parts[3].iov_base = 0; 2276 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2277 /* xcb_randr_output_t outputs */ 2278 xcb_parts[4].iov_base = (char *) outputs; 2279 xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t); 2280 xcb_parts[5].iov_base = 0; 2281 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2282 2283 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2284 return xcb_ret; 2285 } 2286 2287 xcb_randr_set_crtc_config_cookie_t 2288 xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, 2289 xcb_randr_crtc_t crtc /**< */, 2290 xcb_timestamp_t timestamp /**< */, 2291 xcb_timestamp_t config_timestamp /**< */, 2292 int16_t x /**< */, 2293 int16_t y /**< */, 2294 xcb_randr_mode_t mode /**< */, 2295 uint16_t rotation /**< */, 2296 uint32_t outputs_len /**< */, 2297 const xcb_randr_output_t *outputs /**< */) 2298 { 2299 static const xcb_protocol_request_t xcb_req = { 2300 /* count */ 4, 2301 /* ext */ &xcb_randr_id, 2302 /* opcode */ XCB_RANDR_SET_CRTC_CONFIG, 2303 /* isvoid */ 0 2304 }; 2305 2306 struct iovec xcb_parts[6]; 2307 xcb_randr_set_crtc_config_cookie_t xcb_ret; 2308 xcb_randr_set_crtc_config_request_t xcb_out; 2309 2310 xcb_out.crtc = crtc; 2311 xcb_out.timestamp = timestamp; 2312 xcb_out.config_timestamp = config_timestamp; 2313 xcb_out.x = x; 2314 xcb_out.y = y; 2315 xcb_out.mode = mode; 2316 xcb_out.rotation = rotation; 2317 memset(xcb_out.pad0, 0, 2); 2318 2319 xcb_parts[2].iov_base = (char *) &xcb_out; 2320 xcb_parts[2].iov_len = sizeof(xcb_out); 2321 xcb_parts[3].iov_base = 0; 2322 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2323 /* xcb_randr_output_t outputs */ 2324 xcb_parts[4].iov_base = (char *) outputs; 2325 xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t); 2326 xcb_parts[5].iov_base = 0; 2327 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2328 2329 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2330 return xcb_ret; 2331 } 2332 2333 xcb_randr_set_crtc_config_reply_t * 2334 xcb_randr_set_crtc_config_reply (xcb_connection_t *c /**< */, 2335 xcb_randr_set_crtc_config_cookie_t cookie /**< */, 2336 xcb_generic_error_t **e /**< */) 2337 { 2338 return (xcb_randr_set_crtc_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2339 } 2340 2341 xcb_randr_get_crtc_gamma_size_cookie_t 2342 xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, 2343 xcb_randr_crtc_t crtc /**< */) 2344 { 2345 static const xcb_protocol_request_t xcb_req = { 2346 /* count */ 2, 2347 /* ext */ &xcb_randr_id, 2348 /* opcode */ XCB_RANDR_GET_CRTC_GAMMA_SIZE, 2349 /* isvoid */ 0 2350 }; 2351 2352 struct iovec xcb_parts[4]; 2353 xcb_randr_get_crtc_gamma_size_cookie_t xcb_ret; 2354 xcb_randr_get_crtc_gamma_size_request_t xcb_out; 2355 2356 xcb_out.crtc = crtc; 2357 2358 xcb_parts[2].iov_base = (char *) &xcb_out; 2359 xcb_parts[2].iov_len = sizeof(xcb_out); 2360 xcb_parts[3].iov_base = 0; 2361 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2362 2363 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2364 return xcb_ret; 2365 } 2366 2367 xcb_randr_get_crtc_gamma_size_cookie_t 2368 xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, 2369 xcb_randr_crtc_t crtc /**< */) 2370 { 2371 static const xcb_protocol_request_t xcb_req = { 2372 /* count */ 2, 2373 /* ext */ &xcb_randr_id, 2374 /* opcode */ XCB_RANDR_GET_CRTC_GAMMA_SIZE, 2375 /* isvoid */ 0 2376 }; 2377 2378 struct iovec xcb_parts[4]; 2379 xcb_randr_get_crtc_gamma_size_cookie_t xcb_ret; 2380 xcb_randr_get_crtc_gamma_size_request_t xcb_out; 2381 2382 xcb_out.crtc = crtc; 2383 2384 xcb_parts[2].iov_base = (char *) &xcb_out; 2385 xcb_parts[2].iov_len = sizeof(xcb_out); 2386 xcb_parts[3].iov_base = 0; 2387 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2388 2389 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2390 return xcb_ret; 2391 } 2392 2393 xcb_randr_get_crtc_gamma_size_reply_t * 2394 xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c /**< */, 2395 xcb_randr_get_crtc_gamma_size_cookie_t cookie /**< */, 2396 xcb_generic_error_t **e /**< */) 2397 { 2398 return (xcb_randr_get_crtc_gamma_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2399 } 2400 2401 int 2402 xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */) 2403 { 2404 char *xcb_tmp = (char *)_buffer; 2405 const xcb_randr_get_crtc_gamma_reply_t *_aux = (xcb_randr_get_crtc_gamma_reply_t *)_buffer; 2406 unsigned int xcb_buffer_len = 0; 2407 unsigned int xcb_block_len = 0; 2408 unsigned int xcb_pad = 0; 2409 unsigned int xcb_align_to = 0; 2410 2411 2412 xcb_block_len += sizeof(xcb_randr_get_crtc_gamma_reply_t); 2413 xcb_tmp += xcb_block_len; 2414 xcb_buffer_len += xcb_block_len; 2415 xcb_block_len = 0; 2416 /* red */ 2417 xcb_block_len += _aux->size * sizeof(uint16_t); 2418 xcb_tmp += xcb_block_len; 2419 xcb_align_to = ALIGNOF(uint16_t); 2420 /* insert padding */ 2421 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2422 xcb_buffer_len += xcb_block_len + xcb_pad; 2423 if (0 != xcb_pad) { 2424 xcb_tmp += xcb_pad; 2425 xcb_pad = 0; 2426 } 2427 xcb_block_len = 0; 2428 /* green */ 2429 xcb_block_len += _aux->size * sizeof(uint16_t); 2430 xcb_tmp += xcb_block_len; 2431 xcb_align_to = ALIGNOF(uint16_t); 2432 /* insert padding */ 2433 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2434 xcb_buffer_len += xcb_block_len + xcb_pad; 2435 if (0 != xcb_pad) { 2436 xcb_tmp += xcb_pad; 2437 xcb_pad = 0; 2438 } 2439 xcb_block_len = 0; 2440 /* blue */ 2441 xcb_block_len += _aux->size * sizeof(uint16_t); 2442 xcb_tmp += xcb_block_len; 2443 xcb_align_to = ALIGNOF(uint16_t); 2444 /* insert padding */ 2445 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2446 xcb_buffer_len += xcb_block_len + xcb_pad; 2447 if (0 != xcb_pad) { 2448 xcb_tmp += xcb_pad; 2449 xcb_pad = 0; 2450 } 2451 xcb_block_len = 0; 2452 2453 return xcb_buffer_len; 2454 } 2455 2456 xcb_randr_get_crtc_gamma_cookie_t 2457 xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, 2458 xcb_randr_crtc_t crtc /**< */) 2459 { 2460 static const xcb_protocol_request_t xcb_req = { 2461 /* count */ 2, 2462 /* ext */ &xcb_randr_id, 2463 /* opcode */ XCB_RANDR_GET_CRTC_GAMMA, 2464 /* isvoid */ 0 2465 }; 2466 2467 struct iovec xcb_parts[4]; 2468 xcb_randr_get_crtc_gamma_cookie_t xcb_ret; 2469 xcb_randr_get_crtc_gamma_request_t xcb_out; 2470 2471 xcb_out.crtc = crtc; 2472 2473 xcb_parts[2].iov_base = (char *) &xcb_out; 2474 xcb_parts[2].iov_len = sizeof(xcb_out); 2475 xcb_parts[3].iov_base = 0; 2476 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2477 2478 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2479 return xcb_ret; 2480 } 2481 2482 xcb_randr_get_crtc_gamma_cookie_t 2483 xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c /**< */, 2484 xcb_randr_crtc_t crtc /**< */) 2485 { 2486 static const xcb_protocol_request_t xcb_req = { 2487 /* count */ 2, 2488 /* ext */ &xcb_randr_id, 2489 /* opcode */ XCB_RANDR_GET_CRTC_GAMMA, 2490 /* isvoid */ 0 2491 }; 2492 2493 struct iovec xcb_parts[4]; 2494 xcb_randr_get_crtc_gamma_cookie_t xcb_ret; 2495 xcb_randr_get_crtc_gamma_request_t xcb_out; 2496 2497 xcb_out.crtc = crtc; 2498 2499 xcb_parts[2].iov_base = (char *) &xcb_out; 2500 xcb_parts[2].iov_len = sizeof(xcb_out); 2501 xcb_parts[3].iov_base = 0; 2502 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2503 2504 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2505 return xcb_ret; 2506 } 2507 2508 uint16_t * 2509 xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2510 { 2511 return (uint16_t *) (R + 1); 2512 } 2513 2514 int 2515 xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2516 { 2517 return R->size; 2518 } 2519 2520 xcb_generic_iterator_t 2521 xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2522 { 2523 xcb_generic_iterator_t i; 2524 i.data = ((uint16_t *) (R + 1)) + (R->size); 2525 i.rem = 0; 2526 i.index = (char *) i.data - (char *) R; 2527 return i; 2528 } 2529 2530 uint16_t * 2531 xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2532 { 2533 xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_red_end(R); 2534 return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); 2535 } 2536 2537 int 2538 xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2539 { 2540 return R->size; 2541 } 2542 2543 xcb_generic_iterator_t 2544 xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2545 { 2546 xcb_generic_iterator_t i; 2547 xcb_generic_iterator_t child = xcb_randr_get_crtc_gamma_red_end(R); 2548 i.data = ((uint16_t *) child.data) + (R->size); 2549 i.rem = 0; 2550 i.index = (char *) i.data - (char *) R; 2551 return i; 2552 } 2553 2554 uint16_t * 2555 xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2556 { 2557 xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_green_end(R); 2558 return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); 2559 } 2560 2561 int 2562 xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2563 { 2564 return R->size; 2565 } 2566 2567 xcb_generic_iterator_t 2568 xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) 2569 { 2570 xcb_generic_iterator_t i; 2571 xcb_generic_iterator_t child = xcb_randr_get_crtc_gamma_green_end(R); 2572 i.data = ((uint16_t *) child.data) + (R->size); 2573 i.rem = 0; 2574 i.index = (char *) i.data - (char *) R; 2575 return i; 2576 } 2577 2578 xcb_randr_get_crtc_gamma_reply_t * 2579 xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c /**< */, 2580 xcb_randr_get_crtc_gamma_cookie_t cookie /**< */, 2581 xcb_generic_error_t **e /**< */) 2582 { 2583 return (xcb_randr_get_crtc_gamma_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2584 } 2585 2586 int 2587 xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */) 2588 { 2589 char *xcb_tmp = (char *)_buffer; 2590 const xcb_randr_set_crtc_gamma_request_t *_aux = (xcb_randr_set_crtc_gamma_request_t *)_buffer; 2591 unsigned int xcb_buffer_len = 0; 2592 unsigned int xcb_block_len = 0; 2593 unsigned int xcb_pad = 0; 2594 unsigned int xcb_align_to = 0; 2595 2596 2597 xcb_block_len += sizeof(xcb_randr_set_crtc_gamma_request_t); 2598 xcb_tmp += xcb_block_len; 2599 xcb_buffer_len += xcb_block_len; 2600 xcb_block_len = 0; 2601 /* red */ 2602 xcb_block_len += _aux->size * sizeof(uint16_t); 2603 xcb_tmp += xcb_block_len; 2604 xcb_align_to = ALIGNOF(uint16_t); 2605 /* insert padding */ 2606 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2607 xcb_buffer_len += xcb_block_len + xcb_pad; 2608 if (0 != xcb_pad) { 2609 xcb_tmp += xcb_pad; 2610 xcb_pad = 0; 2611 } 2612 xcb_block_len = 0; 2613 /* green */ 2614 xcb_block_len += _aux->size * sizeof(uint16_t); 2615 xcb_tmp += xcb_block_len; 2616 xcb_align_to = ALIGNOF(uint16_t); 2617 /* insert padding */ 2618 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2619 xcb_buffer_len += xcb_block_len + xcb_pad; 2620 if (0 != xcb_pad) { 2621 xcb_tmp += xcb_pad; 2622 xcb_pad = 0; 2623 } 2624 xcb_block_len = 0; 2625 /* blue */ 2626 xcb_block_len += _aux->size * sizeof(uint16_t); 2627 xcb_tmp += xcb_block_len; 2628 xcb_align_to = ALIGNOF(uint16_t); 2629 /* insert padding */ 2630 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2631 xcb_buffer_len += xcb_block_len + xcb_pad; 2632 if (0 != xcb_pad) { 2633 xcb_tmp += xcb_pad; 2634 xcb_pad = 0; 2635 } 2636 xcb_block_len = 0; 2637 2638 return xcb_buffer_len; 2639 } 2640 2641 xcb_void_cookie_t 2642 xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, 2643 xcb_randr_crtc_t crtc /**< */, 2644 uint16_t size /**< */, 2645 const uint16_t *red /**< */, 2646 const uint16_t *green /**< */, 2647 const uint16_t *blue /**< */) 2648 { 2649 static const xcb_protocol_request_t xcb_req = { 2650 /* count */ 8, 2651 /* ext */ &xcb_randr_id, 2652 /* opcode */ XCB_RANDR_SET_CRTC_GAMMA, 2653 /* isvoid */ 1 2654 }; 2655 2656 struct iovec xcb_parts[10]; 2657 xcb_void_cookie_t xcb_ret; 2658 xcb_randr_set_crtc_gamma_request_t xcb_out; 2659 2660 xcb_out.crtc = crtc; 2661 xcb_out.size = size; 2662 memset(xcb_out.pad0, 0, 2); 2663 2664 xcb_parts[2].iov_base = (char *) &xcb_out; 2665 xcb_parts[2].iov_len = sizeof(xcb_out); 2666 xcb_parts[3].iov_base = 0; 2667 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2668 /* uint16_t red */ 2669 xcb_parts[4].iov_base = (char *) red; 2670 xcb_parts[4].iov_len = size * sizeof(uint16_t); 2671 xcb_parts[5].iov_base = 0; 2672 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2673 /* uint16_t green */ 2674 xcb_parts[6].iov_base = (char *) green; 2675 xcb_parts[6].iov_len = size * sizeof(uint16_t); 2676 xcb_parts[7].iov_base = 0; 2677 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 2678 /* uint16_t blue */ 2679 xcb_parts[8].iov_base = (char *) blue; 2680 xcb_parts[8].iov_len = size * sizeof(uint16_t); 2681 xcb_parts[9].iov_base = 0; 2682 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 2683 2684 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2685 return xcb_ret; 2686 } 2687 2688 xcb_void_cookie_t 2689 xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, 2690 xcb_randr_crtc_t crtc /**< */, 2691 uint16_t size /**< */, 2692 const uint16_t *red /**< */, 2693 const uint16_t *green /**< */, 2694 const uint16_t *blue /**< */) 2695 { 2696 static const xcb_protocol_request_t xcb_req = { 2697 /* count */ 8, 2698 /* ext */ &xcb_randr_id, 2699 /* opcode */ XCB_RANDR_SET_CRTC_GAMMA, 2700 /* isvoid */ 1 2701 }; 2702 2703 struct iovec xcb_parts[10]; 2704 xcb_void_cookie_t xcb_ret; 2705 xcb_randr_set_crtc_gamma_request_t xcb_out; 2706 2707 xcb_out.crtc = crtc; 2708 xcb_out.size = size; 2709 memset(xcb_out.pad0, 0, 2); 2710 2711 xcb_parts[2].iov_base = (char *) &xcb_out; 2712 xcb_parts[2].iov_len = sizeof(xcb_out); 2713 xcb_parts[3].iov_base = 0; 2714 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2715 /* uint16_t red */ 2716 xcb_parts[4].iov_base = (char *) red; 2717 xcb_parts[4].iov_len = size * sizeof(uint16_t); 2718 xcb_parts[5].iov_base = 0; 2719 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2720 /* uint16_t green */ 2721 xcb_parts[6].iov_base = (char *) green; 2722 xcb_parts[6].iov_len = size * sizeof(uint16_t); 2723 xcb_parts[7].iov_base = 0; 2724 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 2725 /* uint16_t blue */ 2726 xcb_parts[8].iov_base = (char *) blue; 2727 xcb_parts[8].iov_len = size * sizeof(uint16_t); 2728 xcb_parts[9].iov_base = 0; 2729 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 2730 2731 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2732 return xcb_ret; 2733 } 2734 2735 int 2736 xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */) 2737 { 2738 char *xcb_tmp = (char *)_buffer; 2739 const xcb_randr_get_screen_resources_current_reply_t *_aux = (xcb_randr_get_screen_resources_current_reply_t *)_buffer; 2740 unsigned int xcb_buffer_len = 0; 2741 unsigned int xcb_block_len = 0; 2742 unsigned int xcb_pad = 0; 2743 unsigned int xcb_align_to = 0; 2744 2745 2746 xcb_block_len += sizeof(xcb_randr_get_screen_resources_current_reply_t); 2747 xcb_tmp += xcb_block_len; 2748 xcb_buffer_len += xcb_block_len; 2749 xcb_block_len = 0; 2750 /* crtcs */ 2751 xcb_block_len += _aux->num_crtcs * sizeof(uint32_t); 2752 xcb_tmp += xcb_block_len; 2753 xcb_align_to = ALIGNOF(xcb_randr_crtc_t); 2754 /* insert padding */ 2755 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2756 xcb_buffer_len += xcb_block_len + xcb_pad; 2757 if (0 != xcb_pad) { 2758 xcb_tmp += xcb_pad; 2759 xcb_pad = 0; 2760 } 2761 xcb_block_len = 0; 2762 /* outputs */ 2763 xcb_block_len += _aux->num_outputs * sizeof(uint32_t); 2764 xcb_tmp += xcb_block_len; 2765 xcb_align_to = ALIGNOF(xcb_randr_output_t); 2766 /* insert padding */ 2767 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2768 xcb_buffer_len += xcb_block_len + xcb_pad; 2769 if (0 != xcb_pad) { 2770 xcb_tmp += xcb_pad; 2771 xcb_pad = 0; 2772 } 2773 xcb_block_len = 0; 2774 /* modes */ 2775 xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t); 2776 xcb_tmp += xcb_block_len; 2777 xcb_align_to = ALIGNOF(xcb_randr_mode_info_t); 2778 /* insert padding */ 2779 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2780 xcb_buffer_len += xcb_block_len + xcb_pad; 2781 if (0 != xcb_pad) { 2782 xcb_tmp += xcb_pad; 2783 xcb_pad = 0; 2784 } 2785 xcb_block_len = 0; 2786 /* names */ 2787 xcb_block_len += _aux->names_len * sizeof(uint8_t); 2788 xcb_tmp += xcb_block_len; 2789 xcb_align_to = ALIGNOF(uint8_t); 2790 /* insert padding */ 2791 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2792 xcb_buffer_len += xcb_block_len + xcb_pad; 2793 if (0 != xcb_pad) { 2794 xcb_tmp += xcb_pad; 2795 xcb_pad = 0; 2796 } 2797 xcb_block_len = 0; 2798 2799 return xcb_buffer_len; 2800 } 2801 2802 xcb_randr_get_screen_resources_current_cookie_t 2803 xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, 2804 xcb_window_t window /**< */) 2805 { 2806 static const xcb_protocol_request_t xcb_req = { 2807 /* count */ 2, 2808 /* ext */ &xcb_randr_id, 2809 /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, 2810 /* isvoid */ 0 2811 }; 2812 2813 struct iovec xcb_parts[4]; 2814 xcb_randr_get_screen_resources_current_cookie_t xcb_ret; 2815 xcb_randr_get_screen_resources_current_request_t xcb_out; 2816 2817 xcb_out.window = window; 2818 2819 xcb_parts[2].iov_base = (char *) &xcb_out; 2820 xcb_parts[2].iov_len = sizeof(xcb_out); 2821 xcb_parts[3].iov_base = 0; 2822 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2823 2824 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2825 return xcb_ret; 2826 } 2827 2828 xcb_randr_get_screen_resources_current_cookie_t 2829 xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c /**< */, 2830 xcb_window_t window /**< */) 2831 { 2832 static const xcb_protocol_request_t xcb_req = { 2833 /* count */ 2, 2834 /* ext */ &xcb_randr_id, 2835 /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, 2836 /* isvoid */ 0 2837 }; 2838 2839 struct iovec xcb_parts[4]; 2840 xcb_randr_get_screen_resources_current_cookie_t xcb_ret; 2841 xcb_randr_get_screen_resources_current_request_t xcb_out; 2842 2843 xcb_out.window = window; 2844 2845 xcb_parts[2].iov_base = (char *) &xcb_out; 2846 xcb_parts[2].iov_len = sizeof(xcb_out); 2847 xcb_parts[3].iov_base = 0; 2848 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2849 2850 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2851 return xcb_ret; 2852 } 2853 2854 xcb_randr_crtc_t * 2855 xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2856 { 2857 return (xcb_randr_crtc_t *) (R + 1); 2858 } 2859 2860 int 2861 xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2862 { 2863 return R->num_crtcs; 2864 } 2865 2866 xcb_generic_iterator_t 2867 xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2868 { 2869 xcb_generic_iterator_t i; 2870 i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); 2871 i.rem = 0; 2872 i.index = (char *) i.data - (char *) R; 2873 return i; 2874 } 2875 2876 xcb_randr_output_t * 2877 xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2878 { 2879 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_crtcs_end(R); 2880 return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); 2881 } 2882 2883 int 2884 xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2885 { 2886 return R->num_outputs; 2887 } 2888 2889 xcb_generic_iterator_t 2890 xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2891 { 2892 xcb_generic_iterator_t i; 2893 xcb_generic_iterator_t child = xcb_randr_get_screen_resources_current_crtcs_end(R); 2894 i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); 2895 i.rem = 0; 2896 i.index = (char *) i.data - (char *) R; 2897 return i; 2898 } 2899 2900 xcb_randr_mode_info_t * 2901 xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2902 { 2903 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R); 2904 return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0); 2905 } 2906 2907 int 2908 xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2909 { 2910 return R->num_modes; 2911 } 2912 2913 xcb_randr_mode_info_iterator_t 2914 xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2915 { 2916 xcb_randr_mode_info_iterator_t i; 2917 xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R); 2918 i.data = (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index)); 2919 i.rem = R->num_modes; 2920 i.index = (char *) i.data - (char *) R; 2921 return i; 2922 } 2923 2924 uint8_t * 2925 xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2926 { 2927 xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R)); 2928 return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); 2929 } 2930 2931 int 2932 xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2933 { 2934 return R->names_len; 2935 } 2936 2937 xcb_generic_iterator_t 2938 xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) 2939 { 2940 xcb_generic_iterator_t i; 2941 xcb_generic_iterator_t child = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R)); 2942 i.data = ((uint8_t *) child.data) + (R->names_len); 2943 i.rem = 0; 2944 i.index = (char *) i.data - (char *) R; 2945 return i; 2946 } 2947 2948 xcb_randr_get_screen_resources_current_reply_t * 2949 xcb_randr_get_screen_resources_current_reply (xcb_connection_t *c /**< */, 2950 xcb_randr_get_screen_resources_current_cookie_t cookie /**< */, 2951 xcb_generic_error_t **e /**< */) 2952 { 2953 return (xcb_randr_get_screen_resources_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2954 } 2955 2956 int 2957 xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, 2958 uint32_t filter_params_len /**< */) 2959 { 2960 char *xcb_tmp = (char *)_buffer; 2961 const xcb_randr_set_crtc_transform_request_t *_aux = (xcb_randr_set_crtc_transform_request_t *)_buffer; 2962 unsigned int xcb_buffer_len = 0; 2963 unsigned int xcb_block_len = 0; 2964 unsigned int xcb_pad = 0; 2965 unsigned int xcb_align_to = 0; 2966 2967 2968 xcb_block_len += sizeof(xcb_randr_set_crtc_transform_request_t); 2969 xcb_tmp += xcb_block_len; 2970 xcb_buffer_len += xcb_block_len; 2971 xcb_block_len = 0; 2972 /* filter_name */ 2973 xcb_block_len += _aux->filter_len * sizeof(char); 2974 xcb_tmp += xcb_block_len; 2975 xcb_align_to = ALIGNOF(char); 2976 /* insert padding */ 2977 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2978 xcb_buffer_len += xcb_block_len + xcb_pad; 2979 if (0 != xcb_pad) { 2980 xcb_tmp += xcb_pad; 2981 xcb_pad = 0; 2982 } 2983 xcb_block_len = 0; 2984 /* filter_params */ 2985 xcb_block_len += filter_params_len * sizeof(xcb_render_fixed_t); 2986 xcb_tmp += xcb_block_len; 2987 xcb_align_to = ALIGNOF(xcb_render_fixed_t); 2988 /* insert padding */ 2989 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2990 xcb_buffer_len += xcb_block_len + xcb_pad; 2991 if (0 != xcb_pad) { 2992 xcb_tmp += xcb_pad; 2993 xcb_pad = 0; 2994 } 2995 xcb_block_len = 0; 2996 2997 return xcb_buffer_len; 2998 } 2999 3000 xcb_void_cookie_t 3001 xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, 3002 xcb_randr_crtc_t crtc /**< */, 3003 xcb_render_transform_t transform /**< */, 3004 uint16_t filter_len /**< */, 3005 const char *filter_name /**< */, 3006 uint32_t filter_params_len /**< */, 3007 const xcb_render_fixed_t *filter_params /**< */) 3008 { 3009 static const xcb_protocol_request_t xcb_req = { 3010 /* count */ 6, 3011 /* ext */ &xcb_randr_id, 3012 /* opcode */ XCB_RANDR_SET_CRTC_TRANSFORM, 3013 /* isvoid */ 1 3014 }; 3015 3016 struct iovec xcb_parts[8]; 3017 xcb_void_cookie_t xcb_ret; 3018 xcb_randr_set_crtc_transform_request_t xcb_out; 3019 3020 xcb_out.crtc = crtc; 3021 xcb_out.transform = transform; 3022 xcb_out.filter_len = filter_len; 3023 memset(xcb_out.pad0, 0, 2); 3024 3025 xcb_parts[2].iov_base = (char *) &xcb_out; 3026 xcb_parts[2].iov_len = sizeof(xcb_out); 3027 xcb_parts[3].iov_base = 0; 3028 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3029 /* char filter_name */ 3030 xcb_parts[4].iov_base = (char *) filter_name; 3031 xcb_parts[4].iov_len = filter_len * sizeof(char); 3032 xcb_parts[5].iov_base = 0; 3033 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3034 /* xcb_render_fixed_t filter_params */ 3035 xcb_parts[6].iov_base = (char *) filter_params; 3036 xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t); 3037 xcb_parts[7].iov_base = 0; 3038 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3039 3040 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3041 return xcb_ret; 3042 } 3043 3044 xcb_void_cookie_t 3045 xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, 3046 xcb_randr_crtc_t crtc /**< */, 3047 xcb_render_transform_t transform /**< */, 3048 uint16_t filter_len /**< */, 3049 const char *filter_name /**< */, 3050 uint32_t filter_params_len /**< */, 3051 const xcb_render_fixed_t *filter_params /**< */) 3052 { 3053 static const xcb_protocol_request_t xcb_req = { 3054 /* count */ 6, 3055 /* ext */ &xcb_randr_id, 3056 /* opcode */ XCB_RANDR_SET_CRTC_TRANSFORM, 3057 /* isvoid */ 1 3058 }; 3059 3060 struct iovec xcb_parts[8]; 3061 xcb_void_cookie_t xcb_ret; 3062 xcb_randr_set_crtc_transform_request_t xcb_out; 3063 3064 xcb_out.crtc = crtc; 3065 xcb_out.transform = transform; 3066 xcb_out.filter_len = filter_len; 3067 memset(xcb_out.pad0, 0, 2); 3068 3069 xcb_parts[2].iov_base = (char *) &xcb_out; 3070 xcb_parts[2].iov_len = sizeof(xcb_out); 3071 xcb_parts[3].iov_base = 0; 3072 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3073 /* char filter_name */ 3074 xcb_parts[4].iov_base = (char *) filter_name; 3075 xcb_parts[4].iov_len = filter_len * sizeof(char); 3076 xcb_parts[5].iov_base = 0; 3077 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3078 /* xcb_render_fixed_t filter_params */ 3079 xcb_parts[6].iov_base = (char *) filter_params; 3080 xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t); 3081 xcb_parts[7].iov_base = 0; 3082 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3083 3084 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3085 return xcb_ret; 3086 } 3087 3088 int 3089 xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) 3090 { 3091 char *xcb_tmp = (char *)_buffer; 3092 const xcb_randr_get_crtc_transform_reply_t *_aux = (xcb_randr_get_crtc_transform_reply_t *)_buffer; 3093 unsigned int xcb_buffer_len = 0; 3094 unsigned int xcb_block_len = 0; 3095 unsigned int xcb_pad = 0; 3096 unsigned int xcb_align_to = 0; 3097 3098 3099 xcb_block_len += sizeof(xcb_randr_get_crtc_transform_reply_t); 3100 xcb_tmp += xcb_block_len; 3101 xcb_buffer_len += xcb_block_len; 3102 xcb_block_len = 0; 3103 /* pending_filter_name */ 3104 xcb_block_len += _aux->pending_len * sizeof(char); 3105 xcb_tmp += xcb_block_len; 3106 xcb_align_to = ALIGNOF(char); 3107 /* insert padding */ 3108 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3109 xcb_buffer_len += xcb_block_len + xcb_pad; 3110 if (0 != xcb_pad) { 3111 xcb_tmp += xcb_pad; 3112 xcb_pad = 0; 3113 } 3114 xcb_block_len = 0; 3115 /* pending_params */ 3116 xcb_block_len += _aux->pending_nparams * sizeof(xcb_render_fixed_t); 3117 xcb_tmp += xcb_block_len; 3118 xcb_align_to = ALIGNOF(xcb_render_fixed_t); 3119 /* insert padding */ 3120 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3121 xcb_buffer_len += xcb_block_len + xcb_pad; 3122 if (0 != xcb_pad) { 3123 xcb_tmp += xcb_pad; 3124 xcb_pad = 0; 3125 } 3126 xcb_block_len = 0; 3127 /* current_filter_name */ 3128 xcb_block_len += _aux->current_len * sizeof(char); 3129 xcb_tmp += xcb_block_len; 3130 xcb_align_to = ALIGNOF(char); 3131 /* insert padding */ 3132 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3133 xcb_buffer_len += xcb_block_len + xcb_pad; 3134 if (0 != xcb_pad) { 3135 xcb_tmp += xcb_pad; 3136 xcb_pad = 0; 3137 } 3138 xcb_block_len = 0; 3139 /* current_params */ 3140 xcb_block_len += _aux->current_nparams * sizeof(xcb_render_fixed_t); 3141 xcb_tmp += xcb_block_len; 3142 xcb_align_to = ALIGNOF(xcb_render_fixed_t); 3143 /* insert padding */ 3144 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3145 xcb_buffer_len += xcb_block_len + xcb_pad; 3146 if (0 != xcb_pad) { 3147 xcb_tmp += xcb_pad; 3148 xcb_pad = 0; 3149 } 3150 xcb_block_len = 0; 3151 3152 return xcb_buffer_len; 3153 } 3154 3155 xcb_randr_get_crtc_transform_cookie_t 3156 xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, 3157 xcb_randr_crtc_t crtc /**< */) 3158 { 3159 static const xcb_protocol_request_t xcb_req = { 3160 /* count */ 2, 3161 /* ext */ &xcb_randr_id, 3162 /* opcode */ XCB_RANDR_GET_CRTC_TRANSFORM, 3163 /* isvoid */ 0 3164 }; 3165 3166 struct iovec xcb_parts[4]; 3167 xcb_randr_get_crtc_transform_cookie_t xcb_ret; 3168 xcb_randr_get_crtc_transform_request_t xcb_out; 3169 3170 xcb_out.crtc = crtc; 3171 3172 xcb_parts[2].iov_base = (char *) &xcb_out; 3173 xcb_parts[2].iov_len = sizeof(xcb_out); 3174 xcb_parts[3].iov_base = 0; 3175 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3176 3177 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3178 return xcb_ret; 3179 } 3180 3181 xcb_randr_get_crtc_transform_cookie_t 3182 xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c /**< */, 3183 xcb_randr_crtc_t crtc /**< */) 3184 { 3185 static const xcb_protocol_request_t xcb_req = { 3186 /* count */ 2, 3187 /* ext */ &xcb_randr_id, 3188 /* opcode */ XCB_RANDR_GET_CRTC_TRANSFORM, 3189 /* isvoid */ 0 3190 }; 3191 3192 struct iovec xcb_parts[4]; 3193 xcb_randr_get_crtc_transform_cookie_t xcb_ret; 3194 xcb_randr_get_crtc_transform_request_t xcb_out; 3195 3196 xcb_out.crtc = crtc; 3197 3198 xcb_parts[2].iov_base = (char *) &xcb_out; 3199 xcb_parts[2].iov_len = sizeof(xcb_out); 3200 xcb_parts[3].iov_base = 0; 3201 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3202 3203 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3204 return xcb_ret; 3205 } 3206 3207 char * 3208 xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3209 { 3210 return (char *) (R + 1); 3211 } 3212 3213 int 3214 xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3215 { 3216 return R->pending_len; 3217 } 3218 3219 xcb_generic_iterator_t 3220 xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3221 { 3222 xcb_generic_iterator_t i; 3223 i.data = ((char *) (R + 1)) + (R->pending_len); 3224 i.rem = 0; 3225 i.index = (char *) i.data - (char *) R; 3226 return i; 3227 } 3228 3229 xcb_render_fixed_t * 3230 xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3231 { 3232 xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_filter_name_end(R); 3233 return (xcb_render_fixed_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_fixed_t, prev.index) + 0); 3234 } 3235 3236 int 3237 xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3238 { 3239 return R->pending_nparams; 3240 } 3241 3242 xcb_generic_iterator_t 3243 xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3244 { 3245 xcb_generic_iterator_t i; 3246 xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_pending_filter_name_end(R); 3247 i.data = ((xcb_render_fixed_t *) child.data) + (R->pending_nparams); 3248 i.rem = 0; 3249 i.index = (char *) i.data - (char *) R; 3250 return i; 3251 } 3252 3253 char * 3254 xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3255 { 3256 xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_params_end(R); 3257 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3258 } 3259 3260 int 3261 xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3262 { 3263 return R->current_len; 3264 } 3265 3266 xcb_generic_iterator_t 3267 xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3268 { 3269 xcb_generic_iterator_t i; 3270 xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_pending_params_end(R); 3271 i.data = ((char *) child.data) + (R->current_len); 3272 i.rem = 0; 3273 i.index = (char *) i.data - (char *) R; 3274 return i; 3275 } 3276 3277 xcb_render_fixed_t * 3278 xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3279 { 3280 xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_current_filter_name_end(R); 3281 return (xcb_render_fixed_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_fixed_t, prev.index) + 0); 3282 } 3283 3284 int 3285 xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3286 { 3287 return R->current_nparams; 3288 } 3289 3290 xcb_generic_iterator_t 3291 xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) 3292 { 3293 xcb_generic_iterator_t i; 3294 xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_current_filter_name_end(R); 3295 i.data = ((xcb_render_fixed_t *) child.data) + (R->current_nparams); 3296 i.rem = 0; 3297 i.index = (char *) i.data - (char *) R; 3298 return i; 3299 } 3300 3301 xcb_randr_get_crtc_transform_reply_t * 3302 xcb_randr_get_crtc_transform_reply (xcb_connection_t *c /**< */, 3303 xcb_randr_get_crtc_transform_cookie_t cookie /**< */, 3304 xcb_generic_error_t **e /**< */) 3305 { 3306 return (xcb_randr_get_crtc_transform_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3307 } 3308 3309 xcb_randr_get_panning_cookie_t 3310 xcb_randr_get_panning (xcb_connection_t *c /**< */, 3311 xcb_randr_crtc_t crtc /**< */) 3312 { 3313 static const xcb_protocol_request_t xcb_req = { 3314 /* count */ 2, 3315 /* ext */ &xcb_randr_id, 3316 /* opcode */ XCB_RANDR_GET_PANNING, 3317 /* isvoid */ 0 3318 }; 3319 3320 struct iovec xcb_parts[4]; 3321 xcb_randr_get_panning_cookie_t xcb_ret; 3322 xcb_randr_get_panning_request_t xcb_out; 3323 3324 xcb_out.crtc = crtc; 3325 3326 xcb_parts[2].iov_base = (char *) &xcb_out; 3327 xcb_parts[2].iov_len = sizeof(xcb_out); 3328 xcb_parts[3].iov_base = 0; 3329 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3330 3331 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3332 return xcb_ret; 3333 } 3334 3335 xcb_randr_get_panning_cookie_t 3336 xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, 3337 xcb_randr_crtc_t crtc /**< */) 3338 { 3339 static const xcb_protocol_request_t xcb_req = { 3340 /* count */ 2, 3341 /* ext */ &xcb_randr_id, 3342 /* opcode */ XCB_RANDR_GET_PANNING, 3343 /* isvoid */ 0 3344 }; 3345 3346 struct iovec xcb_parts[4]; 3347 xcb_randr_get_panning_cookie_t xcb_ret; 3348 xcb_randr_get_panning_request_t xcb_out; 3349 3350 xcb_out.crtc = crtc; 3351 3352 xcb_parts[2].iov_base = (char *) &xcb_out; 3353 xcb_parts[2].iov_len = sizeof(xcb_out); 3354 xcb_parts[3].iov_base = 0; 3355 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3356 3357 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3358 return xcb_ret; 3359 } 3360 3361 xcb_randr_get_panning_reply_t * 3362 xcb_randr_get_panning_reply (xcb_connection_t *c /**< */, 3363 xcb_randr_get_panning_cookie_t cookie /**< */, 3364 xcb_generic_error_t **e /**< */) 3365 { 3366 return (xcb_randr_get_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3367 } 3368 3369 xcb_randr_set_panning_cookie_t 3370 xcb_randr_set_panning (xcb_connection_t *c /**< */, 3371 xcb_randr_crtc_t crtc /**< */, 3372 xcb_timestamp_t timestamp /**< */, 3373 uint16_t left /**< */, 3374 uint16_t top /**< */, 3375 uint16_t width /**< */, 3376 uint16_t height /**< */, 3377 uint16_t track_left /**< */, 3378 uint16_t track_top /**< */, 3379 uint16_t track_width /**< */, 3380 uint16_t track_height /**< */, 3381 int16_t border_left /**< */, 3382 int16_t border_top /**< */, 3383 int16_t border_right /**< */, 3384 int16_t border_bottom /**< */) 3385 { 3386 static const xcb_protocol_request_t xcb_req = { 3387 /* count */ 2, 3388 /* ext */ &xcb_randr_id, 3389 /* opcode */ XCB_RANDR_SET_PANNING, 3390 /* isvoid */ 0 3391 }; 3392 3393 struct iovec xcb_parts[4]; 3394 xcb_randr_set_panning_cookie_t xcb_ret; 3395 xcb_randr_set_panning_request_t xcb_out; 3396 3397 xcb_out.crtc = crtc; 3398 xcb_out.timestamp = timestamp; 3399 xcb_out.left = left; 3400 xcb_out.top = top; 3401 xcb_out.width = width; 3402 xcb_out.height = height; 3403 xcb_out.track_left = track_left; 3404 xcb_out.track_top = track_top; 3405 xcb_out.track_width = track_width; 3406 xcb_out.track_height = track_height; 3407 xcb_out.border_left = border_left; 3408 xcb_out.border_top = border_top; 3409 xcb_out.border_right = border_right; 3410 xcb_out.border_bottom = border_bottom; 3411 3412 xcb_parts[2].iov_base = (char *) &xcb_out; 3413 xcb_parts[2].iov_len = sizeof(xcb_out); 3414 xcb_parts[3].iov_base = 0; 3415 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3416 3417 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3418 return xcb_ret; 3419 } 3420 3421 xcb_randr_set_panning_cookie_t 3422 xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, 3423 xcb_randr_crtc_t crtc /**< */, 3424 xcb_timestamp_t timestamp /**< */, 3425 uint16_t left /**< */, 3426 uint16_t top /**< */, 3427 uint16_t width /**< */, 3428 uint16_t height /**< */, 3429 uint16_t track_left /**< */, 3430 uint16_t track_top /**< */, 3431 uint16_t track_width /**< */, 3432 uint16_t track_height /**< */, 3433 int16_t border_left /**< */, 3434 int16_t border_top /**< */, 3435 int16_t border_right /**< */, 3436 int16_t border_bottom /**< */) 3437 { 3438 static const xcb_protocol_request_t xcb_req = { 3439 /* count */ 2, 3440 /* ext */ &xcb_randr_id, 3441 /* opcode */ XCB_RANDR_SET_PANNING, 3442 /* isvoid */ 0 3443 }; 3444 3445 struct iovec xcb_parts[4]; 3446 xcb_randr_set_panning_cookie_t xcb_ret; 3447 xcb_randr_set_panning_request_t xcb_out; 3448 3449 xcb_out.crtc = crtc; 3450 xcb_out.timestamp = timestamp; 3451 xcb_out.left = left; 3452 xcb_out.top = top; 3453 xcb_out.width = width; 3454 xcb_out.height = height; 3455 xcb_out.track_left = track_left; 3456 xcb_out.track_top = track_top; 3457 xcb_out.track_width = track_width; 3458 xcb_out.track_height = track_height; 3459 xcb_out.border_left = border_left; 3460 xcb_out.border_top = border_top; 3461 xcb_out.border_right = border_right; 3462 xcb_out.border_bottom = border_bottom; 3463 3464 xcb_parts[2].iov_base = (char *) &xcb_out; 3465 xcb_parts[2].iov_len = sizeof(xcb_out); 3466 xcb_parts[3].iov_base = 0; 3467 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3468 3469 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3470 return xcb_ret; 3471 } 3472 3473 xcb_randr_set_panning_reply_t * 3474 xcb_randr_set_panning_reply (xcb_connection_t *c /**< */, 3475 xcb_randr_set_panning_cookie_t cookie /**< */, 3476 xcb_generic_error_t **e /**< */) 3477 { 3478 return (xcb_randr_set_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3479 } 3480 3481 xcb_void_cookie_t 3482 xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, 3483 xcb_window_t window /**< */, 3484 xcb_randr_output_t output /**< */) 3485 { 3486 static const xcb_protocol_request_t xcb_req = { 3487 /* count */ 2, 3488 /* ext */ &xcb_randr_id, 3489 /* opcode */ XCB_RANDR_SET_OUTPUT_PRIMARY, 3490 /* isvoid */ 1 3491 }; 3492 3493 struct iovec xcb_parts[4]; 3494 xcb_void_cookie_t xcb_ret; 3495 xcb_randr_set_output_primary_request_t xcb_out; 3496 3497 xcb_out.window = window; 3498 xcb_out.output = output; 3499 3500 xcb_parts[2].iov_base = (char *) &xcb_out; 3501 xcb_parts[2].iov_len = sizeof(xcb_out); 3502 xcb_parts[3].iov_base = 0; 3503 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3504 3505 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3506 return xcb_ret; 3507 } 3508 3509 xcb_void_cookie_t 3510 xcb_randr_set_output_primary (xcb_connection_t *c /**< */, 3511 xcb_window_t window /**< */, 3512 xcb_randr_output_t output /**< */) 3513 { 3514 static const xcb_protocol_request_t xcb_req = { 3515 /* count */ 2, 3516 /* ext */ &xcb_randr_id, 3517 /* opcode */ XCB_RANDR_SET_OUTPUT_PRIMARY, 3518 /* isvoid */ 1 3519 }; 3520 3521 struct iovec xcb_parts[4]; 3522 xcb_void_cookie_t xcb_ret; 3523 xcb_randr_set_output_primary_request_t xcb_out; 3524 3525 xcb_out.window = window; 3526 xcb_out.output = output; 3527 3528 xcb_parts[2].iov_base = (char *) &xcb_out; 3529 xcb_parts[2].iov_len = sizeof(xcb_out); 3530 xcb_parts[3].iov_base = 0; 3531 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3532 3533 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3534 return xcb_ret; 3535 } 3536 3537 xcb_randr_get_output_primary_cookie_t 3538 xcb_randr_get_output_primary (xcb_connection_t *c /**< */, 3539 xcb_window_t window /**< */) 3540 { 3541 static const xcb_protocol_request_t xcb_req = { 3542 /* count */ 2, 3543 /* ext */ &xcb_randr_id, 3544 /* opcode */ XCB_RANDR_GET_OUTPUT_PRIMARY, 3545 /* isvoid */ 0 3546 }; 3547 3548 struct iovec xcb_parts[4]; 3549 xcb_randr_get_output_primary_cookie_t xcb_ret; 3550 xcb_randr_get_output_primary_request_t xcb_out; 3551 3552 xcb_out.window = window; 3553 3554 xcb_parts[2].iov_base = (char *) &xcb_out; 3555 xcb_parts[2].iov_len = sizeof(xcb_out); 3556 xcb_parts[3].iov_base = 0; 3557 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3558 3559 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3560 return xcb_ret; 3561 } 3562 3563 xcb_randr_get_output_primary_cookie_t 3564 xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, 3565 xcb_window_t window /**< */) 3566 { 3567 static const xcb_protocol_request_t xcb_req = { 3568 /* count */ 2, 3569 /* ext */ &xcb_randr_id, 3570 /* opcode */ XCB_RANDR_GET_OUTPUT_PRIMARY, 3571 /* isvoid */ 0 3572 }; 3573 3574 struct iovec xcb_parts[4]; 3575 xcb_randr_get_output_primary_cookie_t xcb_ret; 3576 xcb_randr_get_output_primary_request_t xcb_out; 3577 3578 xcb_out.window = window; 3579 3580 xcb_parts[2].iov_base = (char *) &xcb_out; 3581 xcb_parts[2].iov_len = sizeof(xcb_out); 3582 xcb_parts[3].iov_base = 0; 3583 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3584 3585 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3586 return xcb_ret; 3587 } 3588 3589 xcb_randr_get_output_primary_reply_t * 3590 xcb_randr_get_output_primary_reply (xcb_connection_t *c /**< */, 3591 xcb_randr_get_output_primary_cookie_t cookie /**< */, 3592 xcb_generic_error_t **e /**< */) 3593 { 3594 return (xcb_randr_get_output_primary_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3595 } 3596 3597 int 3598 xcb_randr_get_providers_sizeof (const void *_buffer /**< */) 3599 { 3600 char *xcb_tmp = (char *)_buffer; 3601 const xcb_randr_get_providers_reply_t *_aux = (xcb_randr_get_providers_reply_t *)_buffer; 3602 unsigned int xcb_buffer_len = 0; 3603 unsigned int xcb_block_len = 0; 3604 unsigned int xcb_pad = 0; 3605 unsigned int xcb_align_to = 0; 3606 3607 3608 xcb_block_len += sizeof(xcb_randr_get_providers_reply_t); 3609 xcb_tmp += xcb_block_len; 3610 xcb_buffer_len += xcb_block_len; 3611 xcb_block_len = 0; 3612 /* providers */ 3613 xcb_block_len += _aux->num_providers * sizeof(xcb_randr_provider_t); 3614 xcb_tmp += xcb_block_len; 3615 xcb_align_to = ALIGNOF(xcb_randr_provider_t); 3616 /* insert padding */ 3617 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3618 xcb_buffer_len += xcb_block_len + xcb_pad; 3619 if (0 != xcb_pad) { 3620 xcb_tmp += xcb_pad; 3621 xcb_pad = 0; 3622 } 3623 xcb_block_len = 0; 3624 3625 return xcb_buffer_len; 3626 } 3627 3628 xcb_randr_get_providers_cookie_t 3629 xcb_randr_get_providers (xcb_connection_t *c /**< */, 3630 xcb_window_t window /**< */) 3631 { 3632 static const xcb_protocol_request_t xcb_req = { 3633 /* count */ 2, 3634 /* ext */ &xcb_randr_id, 3635 /* opcode */ XCB_RANDR_GET_PROVIDERS, 3636 /* isvoid */ 0 3637 }; 3638 3639 struct iovec xcb_parts[4]; 3640 xcb_randr_get_providers_cookie_t xcb_ret; 3641 xcb_randr_get_providers_request_t xcb_out; 3642 3643 xcb_out.window = window; 3644 3645 xcb_parts[2].iov_base = (char *) &xcb_out; 3646 xcb_parts[2].iov_len = sizeof(xcb_out); 3647 xcb_parts[3].iov_base = 0; 3648 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3649 3650 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3651 return xcb_ret; 3652 } 3653 3654 xcb_randr_get_providers_cookie_t 3655 xcb_randr_get_providers_unchecked (xcb_connection_t *c /**< */, 3656 xcb_window_t window /**< */) 3657 { 3658 static const xcb_protocol_request_t xcb_req = { 3659 /* count */ 2, 3660 /* ext */ &xcb_randr_id, 3661 /* opcode */ XCB_RANDR_GET_PROVIDERS, 3662 /* isvoid */ 0 3663 }; 3664 3665 struct iovec xcb_parts[4]; 3666 xcb_randr_get_providers_cookie_t xcb_ret; 3667 xcb_randr_get_providers_request_t xcb_out; 3668 3669 xcb_out.window = window; 3670 3671 xcb_parts[2].iov_base = (char *) &xcb_out; 3672 xcb_parts[2].iov_len = sizeof(xcb_out); 3673 xcb_parts[3].iov_base = 0; 3674 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3675 3676 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3677 return xcb_ret; 3678 } 3679 3680 xcb_randr_provider_t * 3681 xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R /**< */) 3682 { 3683 return (xcb_randr_provider_t *) (R + 1); 3684 } 3685 3686 int 3687 xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R /**< */) 3688 { 3689 return R->num_providers; 3690 } 3691 3692 xcb_generic_iterator_t 3693 xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R /**< */) 3694 { 3695 xcb_generic_iterator_t i; 3696 i.data = ((xcb_randr_provider_t *) (R + 1)) + (R->num_providers); 3697 i.rem = 0; 3698 i.index = (char *) i.data - (char *) R; 3699 return i; 3700 } 3701 3702 xcb_randr_get_providers_reply_t * 3703 xcb_randr_get_providers_reply (xcb_connection_t *c /**< */, 3704 xcb_randr_get_providers_cookie_t cookie /**< */, 3705 xcb_generic_error_t **e /**< */) 3706 { 3707 return (xcb_randr_get_providers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3708 } 3709 3710 int 3711 xcb_randr_get_provider_info_sizeof (const void *_buffer /**< */) 3712 { 3713 char *xcb_tmp = (char *)_buffer; 3714 const xcb_randr_get_provider_info_reply_t *_aux = (xcb_randr_get_provider_info_reply_t *)_buffer; 3715 unsigned int xcb_buffer_len = 0; 3716 unsigned int xcb_block_len = 0; 3717 unsigned int xcb_pad = 0; 3718 unsigned int xcb_align_to = 0; 3719 3720 3721 xcb_block_len += sizeof(xcb_randr_get_provider_info_reply_t); 3722 xcb_tmp += xcb_block_len; 3723 xcb_buffer_len += xcb_block_len; 3724 xcb_block_len = 0; 3725 /* crtcs */ 3726 xcb_block_len += _aux->num_crtcs * sizeof(uint32_t); 3727 xcb_tmp += xcb_block_len; 3728 xcb_align_to = ALIGNOF(xcb_randr_crtc_t); 3729 /* insert padding */ 3730 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3731 xcb_buffer_len += xcb_block_len + xcb_pad; 3732 if (0 != xcb_pad) { 3733 xcb_tmp += xcb_pad; 3734 xcb_pad = 0; 3735 } 3736 xcb_block_len = 0; 3737 /* outputs */ 3738 xcb_block_len += _aux->num_outputs * sizeof(uint32_t); 3739 xcb_tmp += xcb_block_len; 3740 xcb_align_to = ALIGNOF(xcb_randr_output_t); 3741 /* insert padding */ 3742 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3743 xcb_buffer_len += xcb_block_len + xcb_pad; 3744 if (0 != xcb_pad) { 3745 xcb_tmp += xcb_pad; 3746 xcb_pad = 0; 3747 } 3748 xcb_block_len = 0; 3749 /* associated_providers */ 3750 xcb_block_len += _aux->num_associated_providers * sizeof(uint32_t); 3751 xcb_tmp += xcb_block_len; 3752 xcb_align_to = ALIGNOF(xcb_randr_provider_t); 3753 /* insert padding */ 3754 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3755 xcb_buffer_len += xcb_block_len + xcb_pad; 3756 if (0 != xcb_pad) { 3757 xcb_tmp += xcb_pad; 3758 xcb_pad = 0; 3759 } 3760 xcb_block_len = 0; 3761 /* associated_capability */ 3762 xcb_block_len += _aux->num_associated_providers * sizeof(uint32_t); 3763 xcb_tmp += xcb_block_len; 3764 xcb_align_to = ALIGNOF(uint32_t); 3765 /* insert padding */ 3766 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3767 xcb_buffer_len += xcb_block_len + xcb_pad; 3768 if (0 != xcb_pad) { 3769 xcb_tmp += xcb_pad; 3770 xcb_pad = 0; 3771 } 3772 xcb_block_len = 0; 3773 /* name */ 3774 xcb_block_len += _aux->name_len * sizeof(char); 3775 xcb_tmp += xcb_block_len; 3776 xcb_align_to = ALIGNOF(char); 3777 /* insert padding */ 3778 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3779 xcb_buffer_len += xcb_block_len + xcb_pad; 3780 if (0 != xcb_pad) { 3781 xcb_tmp += xcb_pad; 3782 xcb_pad = 0; 3783 } 3784 xcb_block_len = 0; 3785 3786 return xcb_buffer_len; 3787 } 3788 3789 xcb_randr_get_provider_info_cookie_t 3790 xcb_randr_get_provider_info (xcb_connection_t *c /**< */, 3791 xcb_randr_provider_t provider /**< */, 3792 xcb_timestamp_t config_timestamp /**< */) 3793 { 3794 static const xcb_protocol_request_t xcb_req = { 3795 /* count */ 2, 3796 /* ext */ &xcb_randr_id, 3797 /* opcode */ XCB_RANDR_GET_PROVIDER_INFO, 3798 /* isvoid */ 0 3799 }; 3800 3801 struct iovec xcb_parts[4]; 3802 xcb_randr_get_provider_info_cookie_t xcb_ret; 3803 xcb_randr_get_provider_info_request_t xcb_out; 3804 3805 xcb_out.provider = provider; 3806 xcb_out.config_timestamp = config_timestamp; 3807 3808 xcb_parts[2].iov_base = (char *) &xcb_out; 3809 xcb_parts[2].iov_len = sizeof(xcb_out); 3810 xcb_parts[3].iov_base = 0; 3811 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3812 3813 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3814 return xcb_ret; 3815 } 3816 3817 xcb_randr_get_provider_info_cookie_t 3818 xcb_randr_get_provider_info_unchecked (xcb_connection_t *c /**< */, 3819 xcb_randr_provider_t provider /**< */, 3820 xcb_timestamp_t config_timestamp /**< */) 3821 { 3822 static const xcb_protocol_request_t xcb_req = { 3823 /* count */ 2, 3824 /* ext */ &xcb_randr_id, 3825 /* opcode */ XCB_RANDR_GET_PROVIDER_INFO, 3826 /* isvoid */ 0 3827 }; 3828 3829 struct iovec xcb_parts[4]; 3830 xcb_randr_get_provider_info_cookie_t xcb_ret; 3831 xcb_randr_get_provider_info_request_t xcb_out; 3832 3833 xcb_out.provider = provider; 3834 xcb_out.config_timestamp = config_timestamp; 3835 3836 xcb_parts[2].iov_base = (char *) &xcb_out; 3837 xcb_parts[2].iov_len = sizeof(xcb_out); 3838 xcb_parts[3].iov_base = 0; 3839 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3840 3841 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3842 return xcb_ret; 3843 } 3844 3845 xcb_randr_crtc_t * 3846 xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R /**< */) 3847 { 3848 return (xcb_randr_crtc_t *) (R + 1); 3849 } 3850 3851 int 3852 xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R /**< */) 3853 { 3854 return R->num_crtcs; 3855 } 3856 3857 xcb_generic_iterator_t 3858 xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R /**< */) 3859 { 3860 xcb_generic_iterator_t i; 3861 i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); 3862 i.rem = 0; 3863 i.index = (char *) i.data - (char *) R; 3864 return i; 3865 } 3866 3867 xcb_randr_output_t * 3868 xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R /**< */) 3869 { 3870 xcb_generic_iterator_t prev = xcb_randr_get_provider_info_crtcs_end(R); 3871 return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); 3872 } 3873 3874 int 3875 xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R /**< */) 3876 { 3877 return R->num_outputs; 3878 } 3879 3880 xcb_generic_iterator_t 3881 xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R /**< */) 3882 { 3883 xcb_generic_iterator_t i; 3884 xcb_generic_iterator_t child = xcb_randr_get_provider_info_crtcs_end(R); 3885 i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); 3886 i.rem = 0; 3887 i.index = (char *) i.data - (char *) R; 3888 return i; 3889 } 3890 3891 xcb_randr_provider_t * 3892 xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R /**< */) 3893 { 3894 xcb_generic_iterator_t prev = xcb_randr_get_provider_info_outputs_end(R); 3895 return (xcb_randr_provider_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_provider_t, prev.index) + 0); 3896 } 3897 3898 int 3899 xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R /**< */) 3900 { 3901 return R->num_associated_providers; 3902 } 3903 3904 xcb_generic_iterator_t 3905 xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R /**< */) 3906 { 3907 xcb_generic_iterator_t i; 3908 xcb_generic_iterator_t child = xcb_randr_get_provider_info_outputs_end(R); 3909 i.data = ((xcb_randr_provider_t *) child.data) + (R->num_associated_providers); 3910 i.rem = 0; 3911 i.index = (char *) i.data - (char *) R; 3912 return i; 3913 } 3914 3915 uint32_t * 3916 xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R /**< */) 3917 { 3918 xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_providers_end(R); 3919 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); 3920 } 3921 3922 int 3923 xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R /**< */) 3924 { 3925 return R->num_associated_providers; 3926 } 3927 3928 xcb_generic_iterator_t 3929 xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R /**< */) 3930 { 3931 xcb_generic_iterator_t i; 3932 xcb_generic_iterator_t child = xcb_randr_get_provider_info_associated_providers_end(R); 3933 i.data = ((uint32_t *) child.data) + (R->num_associated_providers); 3934 i.rem = 0; 3935 i.index = (char *) i.data - (char *) R; 3936 return i; 3937 } 3938 3939 char * 3940 xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R /**< */) 3941 { 3942 xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_capability_end(R); 3943 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3944 } 3945 3946 int 3947 xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R /**< */) 3948 { 3949 return R->name_len; 3950 } 3951 3952 xcb_generic_iterator_t 3953 xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R /**< */) 3954 { 3955 xcb_generic_iterator_t i; 3956 xcb_generic_iterator_t child = xcb_randr_get_provider_info_associated_capability_end(R); 3957 i.data = ((char *) child.data) + (R->name_len); 3958 i.rem = 0; 3959 i.index = (char *) i.data - (char *) R; 3960 return i; 3961 } 3962 3963 xcb_randr_get_provider_info_reply_t * 3964 xcb_randr_get_provider_info_reply (xcb_connection_t *c /**< */, 3965 xcb_randr_get_provider_info_cookie_t cookie /**< */, 3966 xcb_generic_error_t **e /**< */) 3967 { 3968 return (xcb_randr_get_provider_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3969 } 3970 3971 xcb_void_cookie_t 3972 xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c /**< */, 3973 xcb_randr_provider_t provider /**< */, 3974 xcb_randr_provider_t sink_provider /**< */, 3975 xcb_timestamp_t config_timestamp /**< */) 3976 { 3977 static const xcb_protocol_request_t xcb_req = { 3978 /* count */ 2, 3979 /* ext */ &xcb_randr_id, 3980 /* opcode */ XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, 3981 /* isvoid */ 1 3982 }; 3983 3984 struct iovec xcb_parts[4]; 3985 xcb_void_cookie_t xcb_ret; 3986 xcb_randr_set_provider_offload_sink_request_t xcb_out; 3987 3988 xcb_out.provider = provider; 3989 xcb_out.sink_provider = sink_provider; 3990 xcb_out.config_timestamp = config_timestamp; 3991 3992 xcb_parts[2].iov_base = (char *) &xcb_out; 3993 xcb_parts[2].iov_len = sizeof(xcb_out); 3994 xcb_parts[3].iov_base = 0; 3995 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3996 3997 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3998 return xcb_ret; 3999 } 4000 4001 xcb_void_cookie_t 4002 xcb_randr_set_provider_offload_sink (xcb_connection_t *c /**< */, 4003 xcb_randr_provider_t provider /**< */, 4004 xcb_randr_provider_t sink_provider /**< */, 4005 xcb_timestamp_t config_timestamp /**< */) 4006 { 4007 static const xcb_protocol_request_t xcb_req = { 4008 /* count */ 2, 4009 /* ext */ &xcb_randr_id, 4010 /* opcode */ XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, 4011 /* isvoid */ 1 4012 }; 4013 4014 struct iovec xcb_parts[4]; 4015 xcb_void_cookie_t xcb_ret; 4016 xcb_randr_set_provider_offload_sink_request_t xcb_out; 4017 4018 xcb_out.provider = provider; 4019 xcb_out.sink_provider = sink_provider; 4020 xcb_out.config_timestamp = config_timestamp; 4021 4022 xcb_parts[2].iov_base = (char *) &xcb_out; 4023 xcb_parts[2].iov_len = sizeof(xcb_out); 4024 xcb_parts[3].iov_base = 0; 4025 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4026 4027 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4028 return xcb_ret; 4029 } 4030 4031 xcb_void_cookie_t 4032 xcb_randr_set_provider_output_source_checked (xcb_connection_t *c /**< */, 4033 xcb_randr_provider_t provider /**< */, 4034 xcb_randr_provider_t source_provider /**< */, 4035 xcb_timestamp_t config_timestamp /**< */) 4036 { 4037 static const xcb_protocol_request_t xcb_req = { 4038 /* count */ 2, 4039 /* ext */ &xcb_randr_id, 4040 /* opcode */ XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, 4041 /* isvoid */ 1 4042 }; 4043 4044 struct iovec xcb_parts[4]; 4045 xcb_void_cookie_t xcb_ret; 4046 xcb_randr_set_provider_output_source_request_t xcb_out; 4047 4048 xcb_out.provider = provider; 4049 xcb_out.source_provider = source_provider; 4050 xcb_out.config_timestamp = config_timestamp; 4051 4052 xcb_parts[2].iov_base = (char *) &xcb_out; 4053 xcb_parts[2].iov_len = sizeof(xcb_out); 4054 xcb_parts[3].iov_base = 0; 4055 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4056 4057 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4058 return xcb_ret; 4059 } 4060 4061 xcb_void_cookie_t 4062 xcb_randr_set_provider_output_source (xcb_connection_t *c /**< */, 4063 xcb_randr_provider_t provider /**< */, 4064 xcb_randr_provider_t source_provider /**< */, 4065 xcb_timestamp_t config_timestamp /**< */) 4066 { 4067 static const xcb_protocol_request_t xcb_req = { 4068 /* count */ 2, 4069 /* ext */ &xcb_randr_id, 4070 /* opcode */ XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, 4071 /* isvoid */ 1 4072 }; 4073 4074 struct iovec xcb_parts[4]; 4075 xcb_void_cookie_t xcb_ret; 4076 xcb_randr_set_provider_output_source_request_t xcb_out; 4077 4078 xcb_out.provider = provider; 4079 xcb_out.source_provider = source_provider; 4080 xcb_out.config_timestamp = config_timestamp; 4081 4082 xcb_parts[2].iov_base = (char *) &xcb_out; 4083 xcb_parts[2].iov_len = sizeof(xcb_out); 4084 xcb_parts[3].iov_base = 0; 4085 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4086 4087 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4088 return xcb_ret; 4089 } 4090 4091 int 4092 xcb_randr_list_provider_properties_sizeof (const void *_buffer /**< */) 4093 { 4094 char *xcb_tmp = (char *)_buffer; 4095 const xcb_randr_list_provider_properties_reply_t *_aux = (xcb_randr_list_provider_properties_reply_t *)_buffer; 4096 unsigned int xcb_buffer_len = 0; 4097 unsigned int xcb_block_len = 0; 4098 unsigned int xcb_pad = 0; 4099 unsigned int xcb_align_to = 0; 4100 4101 4102 xcb_block_len += sizeof(xcb_randr_list_provider_properties_reply_t); 4103 xcb_tmp += xcb_block_len; 4104 xcb_buffer_len += xcb_block_len; 4105 xcb_block_len = 0; 4106 /* atoms */ 4107 xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t); 4108 xcb_tmp += xcb_block_len; 4109 xcb_align_to = ALIGNOF(xcb_atom_t); 4110 /* insert padding */ 4111 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4112 xcb_buffer_len += xcb_block_len + xcb_pad; 4113 if (0 != xcb_pad) { 4114 xcb_tmp += xcb_pad; 4115 xcb_pad = 0; 4116 } 4117 xcb_block_len = 0; 4118 4119 return xcb_buffer_len; 4120 } 4121 4122 xcb_randr_list_provider_properties_cookie_t 4123 xcb_randr_list_provider_properties (xcb_connection_t *c /**< */, 4124 xcb_randr_provider_t provider /**< */) 4125 { 4126 static const xcb_protocol_request_t xcb_req = { 4127 /* count */ 2, 4128 /* ext */ &xcb_randr_id, 4129 /* opcode */ XCB_RANDR_LIST_PROVIDER_PROPERTIES, 4130 /* isvoid */ 0 4131 }; 4132 4133 struct iovec xcb_parts[4]; 4134 xcb_randr_list_provider_properties_cookie_t xcb_ret; 4135 xcb_randr_list_provider_properties_request_t xcb_out; 4136 4137 xcb_out.provider = provider; 4138 4139 xcb_parts[2].iov_base = (char *) &xcb_out; 4140 xcb_parts[2].iov_len = sizeof(xcb_out); 4141 xcb_parts[3].iov_base = 0; 4142 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4143 4144 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4145 return xcb_ret; 4146 } 4147 4148 xcb_randr_list_provider_properties_cookie_t 4149 xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c /**< */, 4150 xcb_randr_provider_t provider /**< */) 4151 { 4152 static const xcb_protocol_request_t xcb_req = { 4153 /* count */ 2, 4154 /* ext */ &xcb_randr_id, 4155 /* opcode */ XCB_RANDR_LIST_PROVIDER_PROPERTIES, 4156 /* isvoid */ 0 4157 }; 4158 4159 struct iovec xcb_parts[4]; 4160 xcb_randr_list_provider_properties_cookie_t xcb_ret; 4161 xcb_randr_list_provider_properties_request_t xcb_out; 4162 4163 xcb_out.provider = provider; 4164 4165 xcb_parts[2].iov_base = (char *) &xcb_out; 4166 xcb_parts[2].iov_len = sizeof(xcb_out); 4167 xcb_parts[3].iov_base = 0; 4168 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4169 4170 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4171 return xcb_ret; 4172 } 4173 4174 xcb_atom_t * 4175 xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R /**< */) 4176 { 4177 return (xcb_atom_t *) (R + 1); 4178 } 4179 4180 int 4181 xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R /**< */) 4182 { 4183 return R->num_atoms; 4184 } 4185 4186 xcb_generic_iterator_t 4187 xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R /**< */) 4188 { 4189 xcb_generic_iterator_t i; 4190 i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); 4191 i.rem = 0; 4192 i.index = (char *) i.data - (char *) R; 4193 return i; 4194 } 4195 4196 xcb_randr_list_provider_properties_reply_t * 4197 xcb_randr_list_provider_properties_reply (xcb_connection_t *c /**< */, 4198 xcb_randr_list_provider_properties_cookie_t cookie /**< */, 4199 xcb_generic_error_t **e /**< */) 4200 { 4201 return (xcb_randr_list_provider_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4202 } 4203 4204 int 4205 xcb_randr_query_provider_property_sizeof (const void *_buffer /**< */) 4206 { 4207 char *xcb_tmp = (char *)_buffer; 4208 const xcb_randr_query_provider_property_reply_t *_aux = (xcb_randr_query_provider_property_reply_t *)_buffer; 4209 unsigned int xcb_buffer_len = 0; 4210 unsigned int xcb_block_len = 0; 4211 unsigned int xcb_pad = 0; 4212 unsigned int xcb_align_to = 0; 4213 4214 4215 xcb_block_len += sizeof(xcb_randr_query_provider_property_reply_t); 4216 xcb_tmp += xcb_block_len; 4217 xcb_buffer_len += xcb_block_len; 4218 xcb_block_len = 0; 4219 /* valid_values */ 4220 xcb_block_len += _aux->length * sizeof(int32_t); 4221 xcb_tmp += xcb_block_len; 4222 xcb_align_to = ALIGNOF(int32_t); 4223 /* insert padding */ 4224 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4225 xcb_buffer_len += xcb_block_len + xcb_pad; 4226 if (0 != xcb_pad) { 4227 xcb_tmp += xcb_pad; 4228 xcb_pad = 0; 4229 } 4230 xcb_block_len = 0; 4231 4232 return xcb_buffer_len; 4233 } 4234 4235 xcb_randr_query_provider_property_cookie_t 4236 xcb_randr_query_provider_property (xcb_connection_t *c /**< */, 4237 xcb_randr_provider_t provider /**< */, 4238 xcb_atom_t property /**< */) 4239 { 4240 static const xcb_protocol_request_t xcb_req = { 4241 /* count */ 2, 4242 /* ext */ &xcb_randr_id, 4243 /* opcode */ XCB_RANDR_QUERY_PROVIDER_PROPERTY, 4244 /* isvoid */ 0 4245 }; 4246 4247 struct iovec xcb_parts[4]; 4248 xcb_randr_query_provider_property_cookie_t xcb_ret; 4249 xcb_randr_query_provider_property_request_t xcb_out; 4250 4251 xcb_out.provider = provider; 4252 xcb_out.property = property; 4253 4254 xcb_parts[2].iov_base = (char *) &xcb_out; 4255 xcb_parts[2].iov_len = sizeof(xcb_out); 4256 xcb_parts[3].iov_base = 0; 4257 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4258 4259 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4260 return xcb_ret; 4261 } 4262 4263 xcb_randr_query_provider_property_cookie_t 4264 xcb_randr_query_provider_property_unchecked (xcb_connection_t *c /**< */, 4265 xcb_randr_provider_t provider /**< */, 4266 xcb_atom_t property /**< */) 4267 { 4268 static const xcb_protocol_request_t xcb_req = { 4269 /* count */ 2, 4270 /* ext */ &xcb_randr_id, 4271 /* opcode */ XCB_RANDR_QUERY_PROVIDER_PROPERTY, 4272 /* isvoid */ 0 4273 }; 4274 4275 struct iovec xcb_parts[4]; 4276 xcb_randr_query_provider_property_cookie_t xcb_ret; 4277 xcb_randr_query_provider_property_request_t xcb_out; 4278 4279 xcb_out.provider = provider; 4280 xcb_out.property = property; 4281 4282 xcb_parts[2].iov_base = (char *) &xcb_out; 4283 xcb_parts[2].iov_len = sizeof(xcb_out); 4284 xcb_parts[3].iov_base = 0; 4285 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4286 4287 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4288 return xcb_ret; 4289 } 4290 4291 int32_t * 4292 xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R /**< */) 4293 { 4294 return (int32_t *) (R + 1); 4295 } 4296 4297 int 4298 xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R /**< */) 4299 { 4300 return R->length; 4301 } 4302 4303 xcb_generic_iterator_t 4304 xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R /**< */) 4305 { 4306 xcb_generic_iterator_t i; 4307 i.data = ((int32_t *) (R + 1)) + (R->length); 4308 i.rem = 0; 4309 i.index = (char *) i.data - (char *) R; 4310 return i; 4311 } 4312 4313 xcb_randr_query_provider_property_reply_t * 4314 xcb_randr_query_provider_property_reply (xcb_connection_t *c /**< */, 4315 xcb_randr_query_provider_property_cookie_t cookie /**< */, 4316 xcb_generic_error_t **e /**< */) 4317 { 4318 return (xcb_randr_query_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4319 } 4320 4321 int 4322 xcb_randr_configure_provider_property_sizeof (const void *_buffer /**< */, 4323 uint32_t values_len /**< */) 4324 { 4325 char *xcb_tmp = (char *)_buffer; 4326 unsigned int xcb_buffer_len = 0; 4327 unsigned int xcb_block_len = 0; 4328 unsigned int xcb_pad = 0; 4329 unsigned int xcb_align_to = 0; 4330 4331 4332 xcb_block_len += sizeof(xcb_randr_configure_provider_property_request_t); 4333 xcb_tmp += xcb_block_len; 4334 xcb_buffer_len += xcb_block_len; 4335 xcb_block_len = 0; 4336 /* values */ 4337 xcb_block_len += values_len * sizeof(int32_t); 4338 xcb_tmp += xcb_block_len; 4339 xcb_align_to = ALIGNOF(int32_t); 4340 /* insert padding */ 4341 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4342 xcb_buffer_len += xcb_block_len + xcb_pad; 4343 if (0 != xcb_pad) { 4344 xcb_tmp += xcb_pad; 4345 xcb_pad = 0; 4346 } 4347 xcb_block_len = 0; 4348 4349 return xcb_buffer_len; 4350 } 4351 4352 xcb_void_cookie_t 4353 xcb_randr_configure_provider_property_checked (xcb_connection_t *c /**< */, 4354 xcb_randr_provider_t provider /**< */, 4355 xcb_atom_t property /**< */, 4356 uint8_t pending /**< */, 4357 uint8_t range /**< */, 4358 uint32_t values_len /**< */, 4359 const int32_t *values /**< */) 4360 { 4361 static const xcb_protocol_request_t xcb_req = { 4362 /* count */ 4, 4363 /* ext */ &xcb_randr_id, 4364 /* opcode */ XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, 4365 /* isvoid */ 1 4366 }; 4367 4368 struct iovec xcb_parts[6]; 4369 xcb_void_cookie_t xcb_ret; 4370 xcb_randr_configure_provider_property_request_t xcb_out; 4371 4372 xcb_out.provider = provider; 4373 xcb_out.property = property; 4374 xcb_out.pending = pending; 4375 xcb_out.range = range; 4376 memset(xcb_out.pad0, 0, 2); 4377 4378 xcb_parts[2].iov_base = (char *) &xcb_out; 4379 xcb_parts[2].iov_len = sizeof(xcb_out); 4380 xcb_parts[3].iov_base = 0; 4381 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4382 /* int32_t values */ 4383 xcb_parts[4].iov_base = (char *) values; 4384 xcb_parts[4].iov_len = values_len * sizeof(int32_t); 4385 xcb_parts[5].iov_base = 0; 4386 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4387 4388 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4389 return xcb_ret; 4390 } 4391 4392 xcb_void_cookie_t 4393 xcb_randr_configure_provider_property (xcb_connection_t *c /**< */, 4394 xcb_randr_provider_t provider /**< */, 4395 xcb_atom_t property /**< */, 4396 uint8_t pending /**< */, 4397 uint8_t range /**< */, 4398 uint32_t values_len /**< */, 4399 const int32_t *values /**< */) 4400 { 4401 static const xcb_protocol_request_t xcb_req = { 4402 /* count */ 4, 4403 /* ext */ &xcb_randr_id, 4404 /* opcode */ XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, 4405 /* isvoid */ 1 4406 }; 4407 4408 struct iovec xcb_parts[6]; 4409 xcb_void_cookie_t xcb_ret; 4410 xcb_randr_configure_provider_property_request_t xcb_out; 4411 4412 xcb_out.provider = provider; 4413 xcb_out.property = property; 4414 xcb_out.pending = pending; 4415 xcb_out.range = range; 4416 memset(xcb_out.pad0, 0, 2); 4417 4418 xcb_parts[2].iov_base = (char *) &xcb_out; 4419 xcb_parts[2].iov_len = sizeof(xcb_out); 4420 xcb_parts[3].iov_base = 0; 4421 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4422 /* int32_t values */ 4423 xcb_parts[4].iov_base = (char *) values; 4424 xcb_parts[4].iov_len = values_len * sizeof(int32_t); 4425 xcb_parts[5].iov_base = 0; 4426 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4427 4428 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4429 return xcb_ret; 4430 } 4431 4432 int 4433 xcb_randr_change_provider_property_sizeof (const void *_buffer /**< */) 4434 { 4435 char *xcb_tmp = (char *)_buffer; 4436 const xcb_randr_change_provider_property_request_t *_aux = (xcb_randr_change_provider_property_request_t *)_buffer; 4437 unsigned int xcb_buffer_len = 0; 4438 unsigned int xcb_block_len = 0; 4439 unsigned int xcb_pad = 0; 4440 unsigned int xcb_align_to = 0; 4441 4442 4443 xcb_block_len += sizeof(xcb_randr_change_provider_property_request_t); 4444 xcb_tmp += xcb_block_len; 4445 xcb_buffer_len += xcb_block_len; 4446 xcb_block_len = 0; 4447 /* data */ 4448 xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(char); 4449 xcb_tmp += xcb_block_len; 4450 xcb_align_to = ALIGNOF(char); 4451 /* insert padding */ 4452 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4453 xcb_buffer_len += xcb_block_len + xcb_pad; 4454 if (0 != xcb_pad) { 4455 xcb_tmp += xcb_pad; 4456 xcb_pad = 0; 4457 } 4458 xcb_block_len = 0; 4459 4460 return xcb_buffer_len; 4461 } 4462 4463 xcb_void_cookie_t 4464 xcb_randr_change_provider_property_checked (xcb_connection_t *c /**< */, 4465 xcb_randr_provider_t provider /**< */, 4466 xcb_atom_t property /**< */, 4467 xcb_atom_t type /**< */, 4468 uint8_t format /**< */, 4469 uint8_t mode /**< */, 4470 uint32_t num_items /**< */, 4471 const void *data /**< */) 4472 { 4473 static const xcb_protocol_request_t xcb_req = { 4474 /* count */ 4, 4475 /* ext */ &xcb_randr_id, 4476 /* opcode */ XCB_RANDR_CHANGE_PROVIDER_PROPERTY, 4477 /* isvoid */ 1 4478 }; 4479 4480 struct iovec xcb_parts[6]; 4481 xcb_void_cookie_t xcb_ret; 4482 xcb_randr_change_provider_property_request_t xcb_out; 4483 4484 xcb_out.provider = provider; 4485 xcb_out.property = property; 4486 xcb_out.type = type; 4487 xcb_out.format = format; 4488 xcb_out.mode = mode; 4489 memset(xcb_out.pad0, 0, 2); 4490 xcb_out.num_items = num_items; 4491 4492 xcb_parts[2].iov_base = (char *) &xcb_out; 4493 xcb_parts[2].iov_len = sizeof(xcb_out); 4494 xcb_parts[3].iov_base = 0; 4495 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4496 /* void data */ 4497 xcb_parts[4].iov_base = (char *) data; 4498 xcb_parts[4].iov_len = (num_items * (format / 8)) * sizeof(char); 4499 xcb_parts[5].iov_base = 0; 4500 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4501 4502 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4503 return xcb_ret; 4504 } 4505 4506 xcb_void_cookie_t 4507 xcb_randr_change_provider_property (xcb_connection_t *c /**< */, 4508 xcb_randr_provider_t provider /**< */, 4509 xcb_atom_t property /**< */, 4510 xcb_atom_t type /**< */, 4511 uint8_t format /**< */, 4512 uint8_t mode /**< */, 4513 uint32_t num_items /**< */, 4514 const void *data /**< */) 4515 { 4516 static const xcb_protocol_request_t xcb_req = { 4517 /* count */ 4, 4518 /* ext */ &xcb_randr_id, 4519 /* opcode */ XCB_RANDR_CHANGE_PROVIDER_PROPERTY, 4520 /* isvoid */ 1 4521 }; 4522 4523 struct iovec xcb_parts[6]; 4524 xcb_void_cookie_t xcb_ret; 4525 xcb_randr_change_provider_property_request_t xcb_out; 4526 4527 xcb_out.provider = provider; 4528 xcb_out.property = property; 4529 xcb_out.type = type; 4530 xcb_out.format = format; 4531 xcb_out.mode = mode; 4532 memset(xcb_out.pad0, 0, 2); 4533 xcb_out.num_items = num_items; 4534 4535 xcb_parts[2].iov_base = (char *) &xcb_out; 4536 xcb_parts[2].iov_len = sizeof(xcb_out); 4537 xcb_parts[3].iov_base = 0; 4538 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4539 /* void data */ 4540 xcb_parts[4].iov_base = (char *) data; 4541 xcb_parts[4].iov_len = (num_items * (format / 8)) * sizeof(char); 4542 xcb_parts[5].iov_base = 0; 4543 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4544 4545 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4546 return xcb_ret; 4547 } 4548 4549 xcb_void_cookie_t 4550 xcb_randr_delete_provider_property_checked (xcb_connection_t *c /**< */, 4551 xcb_randr_provider_t provider /**< */, 4552 xcb_atom_t property /**< */) 4553 { 4554 static const xcb_protocol_request_t xcb_req = { 4555 /* count */ 2, 4556 /* ext */ &xcb_randr_id, 4557 /* opcode */ XCB_RANDR_DELETE_PROVIDER_PROPERTY, 4558 /* isvoid */ 1 4559 }; 4560 4561 struct iovec xcb_parts[4]; 4562 xcb_void_cookie_t xcb_ret; 4563 xcb_randr_delete_provider_property_request_t xcb_out; 4564 4565 xcb_out.provider = provider; 4566 xcb_out.property = property; 4567 4568 xcb_parts[2].iov_base = (char *) &xcb_out; 4569 xcb_parts[2].iov_len = sizeof(xcb_out); 4570 xcb_parts[3].iov_base = 0; 4571 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4572 4573 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4574 return xcb_ret; 4575 } 4576 4577 xcb_void_cookie_t 4578 xcb_randr_delete_provider_property (xcb_connection_t *c /**< */, 4579 xcb_randr_provider_t provider /**< */, 4580 xcb_atom_t property /**< */) 4581 { 4582 static const xcb_protocol_request_t xcb_req = { 4583 /* count */ 2, 4584 /* ext */ &xcb_randr_id, 4585 /* opcode */ XCB_RANDR_DELETE_PROVIDER_PROPERTY, 4586 /* isvoid */ 1 4587 }; 4588 4589 struct iovec xcb_parts[4]; 4590 xcb_void_cookie_t xcb_ret; 4591 xcb_randr_delete_provider_property_request_t xcb_out; 4592 4593 xcb_out.provider = provider; 4594 xcb_out.property = property; 4595 4596 xcb_parts[2].iov_base = (char *) &xcb_out; 4597 xcb_parts[2].iov_len = sizeof(xcb_out); 4598 xcb_parts[3].iov_base = 0; 4599 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4600 4601 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4602 return xcb_ret; 4603 } 4604 4605 int 4606 xcb_randr_get_provider_property_sizeof (const void *_buffer /**< */) 4607 { 4608 char *xcb_tmp = (char *)_buffer; 4609 const xcb_randr_get_provider_property_reply_t *_aux = (xcb_randr_get_provider_property_reply_t *)_buffer; 4610 unsigned int xcb_buffer_len = 0; 4611 unsigned int xcb_block_len = 0; 4612 unsigned int xcb_pad = 0; 4613 unsigned int xcb_align_to = 0; 4614 4615 4616 xcb_block_len += sizeof(xcb_randr_get_provider_property_reply_t); 4617 xcb_tmp += xcb_block_len; 4618 xcb_buffer_len += xcb_block_len; 4619 xcb_block_len = 0; 4620 /* data */ 4621 xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(char); 4622 xcb_tmp += xcb_block_len; 4623 xcb_align_to = ALIGNOF(char); 4624 /* insert padding */ 4625 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4626 xcb_buffer_len += xcb_block_len + xcb_pad; 4627 if (0 != xcb_pad) { 4628 xcb_tmp += xcb_pad; 4629 xcb_pad = 0; 4630 } 4631 xcb_block_len = 0; 4632 4633 return xcb_buffer_len; 4634 } 4635 4636 xcb_randr_get_provider_property_cookie_t 4637 xcb_randr_get_provider_property (xcb_connection_t *c /**< */, 4638 xcb_randr_provider_t provider /**< */, 4639 xcb_atom_t property /**< */, 4640 xcb_atom_t type /**< */, 4641 uint32_t long_offset /**< */, 4642 uint32_t long_length /**< */, 4643 uint8_t _delete /**< */, 4644 uint8_t pending /**< */) 4645 { 4646 static const xcb_protocol_request_t xcb_req = { 4647 /* count */ 2, 4648 /* ext */ &xcb_randr_id, 4649 /* opcode */ XCB_RANDR_GET_PROVIDER_PROPERTY, 4650 /* isvoid */ 0 4651 }; 4652 4653 struct iovec xcb_parts[4]; 4654 xcb_randr_get_provider_property_cookie_t xcb_ret; 4655 xcb_randr_get_provider_property_request_t xcb_out; 4656 4657 xcb_out.provider = provider; 4658 xcb_out.property = property; 4659 xcb_out.type = type; 4660 xcb_out.long_offset = long_offset; 4661 xcb_out.long_length = long_length; 4662 xcb_out._delete = _delete; 4663 xcb_out.pending = pending; 4664 memset(xcb_out.pad0, 0, 2); 4665 4666 xcb_parts[2].iov_base = (char *) &xcb_out; 4667 xcb_parts[2].iov_len = sizeof(xcb_out); 4668 xcb_parts[3].iov_base = 0; 4669 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4670 4671 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4672 return xcb_ret; 4673 } 4674 4675 xcb_randr_get_provider_property_cookie_t 4676 xcb_randr_get_provider_property_unchecked (xcb_connection_t *c /**< */, 4677 xcb_randr_provider_t provider /**< */, 4678 xcb_atom_t property /**< */, 4679 xcb_atom_t type /**< */, 4680 uint32_t long_offset /**< */, 4681 uint32_t long_length /**< */, 4682 uint8_t _delete /**< */, 4683 uint8_t pending /**< */) 4684 { 4685 static const xcb_protocol_request_t xcb_req = { 4686 /* count */ 2, 4687 /* ext */ &xcb_randr_id, 4688 /* opcode */ XCB_RANDR_GET_PROVIDER_PROPERTY, 4689 /* isvoid */ 0 4690 }; 4691 4692 struct iovec xcb_parts[4]; 4693 xcb_randr_get_provider_property_cookie_t xcb_ret; 4694 xcb_randr_get_provider_property_request_t xcb_out; 4695 4696 xcb_out.provider = provider; 4697 xcb_out.property = property; 4698 xcb_out.type = type; 4699 xcb_out.long_offset = long_offset; 4700 xcb_out.long_length = long_length; 4701 xcb_out._delete = _delete; 4702 xcb_out.pending = pending; 4703 memset(xcb_out.pad0, 0, 2); 4704 4705 xcb_parts[2].iov_base = (char *) &xcb_out; 4706 xcb_parts[2].iov_len = sizeof(xcb_out); 4707 xcb_parts[3].iov_base = 0; 4708 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4709 4710 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4711 return xcb_ret; 4712 } 4713 4714 void * 4715 xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R /**< */) 4716 { 4717 return (void *) (R + 1); 4718 } 4719 4720 int 4721 xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R /**< */) 4722 { 4723 return (R->num_items * (R->format / 8)); 4724 } 4725 4726 xcb_generic_iterator_t 4727 xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R /**< */) 4728 { 4729 xcb_generic_iterator_t i; 4730 i.data = ((char *) (R + 1)) + ((R->num_items * (R->format / 8))); 4731 i.rem = 0; 4732 i.index = (char *) i.data - (char *) R; 4733 return i; 4734 } 4735 4736 xcb_randr_get_provider_property_reply_t * 4737 xcb_randr_get_provider_property_reply (xcb_connection_t *c /**< */, 4738 xcb_randr_get_provider_property_cookie_t cookie /**< */, 4739 xcb_generic_error_t **e /**< */) 4740 { 4741 return (xcb_randr_get_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4742 } 4743 4744 void 4745 xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i /**< */) 4746 { 4747 --i->rem; 4748 ++i->data; 4749 i->index += sizeof(xcb_randr_crtc_change_t); 4750 } 4751 4752 xcb_generic_iterator_t 4753 xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i /**< */) 4754 { 4755 xcb_generic_iterator_t ret; 4756 ret.data = i.data + i.rem; 4757 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4758 ret.rem = 0; 4759 return ret; 4760 } 4761 4762 void 4763 xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i /**< */) 4764 { 4765 --i->rem; 4766 ++i->data; 4767 i->index += sizeof(xcb_randr_output_change_t); 4768 } 4769 4770 xcb_generic_iterator_t 4771 xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i /**< */) 4772 { 4773 xcb_generic_iterator_t ret; 4774 ret.data = i.data + i.rem; 4775 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4776 ret.rem = 0; 4777 return ret; 4778 } 4779 4780 void 4781 xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i /**< */) 4782 { 4783 --i->rem; 4784 ++i->data; 4785 i->index += sizeof(xcb_randr_output_property_t); 4786 } 4787 4788 xcb_generic_iterator_t 4789 xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i /**< */) 4790 { 4791 xcb_generic_iterator_t ret; 4792 ret.data = i.data + i.rem; 4793 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4794 ret.rem = 0; 4795 return ret; 4796 } 4797 4798 void 4799 xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i /**< */) 4800 { 4801 --i->rem; 4802 ++i->data; 4803 i->index += sizeof(xcb_randr_provider_change_t); 4804 } 4805 4806 xcb_generic_iterator_t 4807 xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i /**< */) 4808 { 4809 xcb_generic_iterator_t ret; 4810 ret.data = i.data + i.rem; 4811 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4812 ret.rem = 0; 4813 return ret; 4814 } 4815 4816 void 4817 xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i /**< */) 4818 { 4819 --i->rem; 4820 ++i->data; 4821 i->index += sizeof(xcb_randr_provider_property_t); 4822 } 4823 4824 xcb_generic_iterator_t 4825 xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i /**< */) 4826 { 4827 xcb_generic_iterator_t ret; 4828 ret.data = i.data + i.rem; 4829 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4830 ret.rem = 0; 4831 return ret; 4832 } 4833 4834 void 4835 xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i /**< */) 4836 { 4837 --i->rem; 4838 ++i->data; 4839 i->index += sizeof(xcb_randr_resource_change_t); 4840 } 4841 4842 xcb_generic_iterator_t 4843 xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i /**< */) 4844 { 4845 xcb_generic_iterator_t ret; 4846 ret.data = i.data + i.rem; 4847 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4848 ret.rem = 0; 4849 return ret; 4850 } 4851 4852 void 4853 xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i /**< */) 4854 { 4855 --i->rem; 4856 ++i->data; 4857 i->index += sizeof(xcb_randr_notify_data_t); 4858 } 4859 4860 xcb_generic_iterator_t 4861 xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i /**< */) 4862 { 4863 xcb_generic_iterator_t ret; 4864 ret.data = i.data + i.rem; 4865 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4866 ret.rem = 0; 4867 return ret; 4868 } 4869 4870