1 /* 2 * This file generated automatically from glx.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 "glx.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_glx_id = { "GLX", 0 }; 20 21 22 /***************************************************************************** 23 ** 24 ** void xcb_glx_pixmap_next 25 ** 26 ** @param xcb_glx_pixmap_iterator_t *i 27 ** @returns void 28 ** 29 *****************************************************************************/ 30 31 void 32 xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i /**< */) 33 { 34 --i->rem; 35 ++i->data; 36 i->index += sizeof(xcb_glx_pixmap_t); 37 } 38 39 40 /***************************************************************************** 41 ** 42 ** xcb_generic_iterator_t xcb_glx_pixmap_end 43 ** 44 ** @param xcb_glx_pixmap_iterator_t i 45 ** @returns xcb_generic_iterator_t 46 ** 47 *****************************************************************************/ 48 49 xcb_generic_iterator_t 50 xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i /**< */) 51 { 52 xcb_generic_iterator_t ret; 53 ret.data = i.data + i.rem; 54 ret.index = i.index + ((char *) ret.data - (char *) i.data); 55 ret.rem = 0; 56 return ret; 57 } 58 59 60 /***************************************************************************** 61 ** 62 ** void xcb_glx_context_next 63 ** 64 ** @param xcb_glx_context_iterator_t *i 65 ** @returns void 66 ** 67 *****************************************************************************/ 68 69 void 70 xcb_glx_context_next (xcb_glx_context_iterator_t *i /**< */) 71 { 72 --i->rem; 73 ++i->data; 74 i->index += sizeof(xcb_glx_context_t); 75 } 76 77 78 /***************************************************************************** 79 ** 80 ** xcb_generic_iterator_t xcb_glx_context_end 81 ** 82 ** @param xcb_glx_context_iterator_t i 83 ** @returns xcb_generic_iterator_t 84 ** 85 *****************************************************************************/ 86 87 xcb_generic_iterator_t 88 xcb_glx_context_end (xcb_glx_context_iterator_t i /**< */) 89 { 90 xcb_generic_iterator_t ret; 91 ret.data = i.data + i.rem; 92 ret.index = i.index + ((char *) ret.data - (char *) i.data); 93 ret.rem = 0; 94 return ret; 95 } 96 97 98 /***************************************************************************** 99 ** 100 ** void xcb_glx_pbuffer_next 101 ** 102 ** @param xcb_glx_pbuffer_iterator_t *i 103 ** @returns void 104 ** 105 *****************************************************************************/ 106 107 void 108 xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i /**< */) 109 { 110 --i->rem; 111 ++i->data; 112 i->index += sizeof(xcb_glx_pbuffer_t); 113 } 114 115 116 /***************************************************************************** 117 ** 118 ** xcb_generic_iterator_t xcb_glx_pbuffer_end 119 ** 120 ** @param xcb_glx_pbuffer_iterator_t i 121 ** @returns xcb_generic_iterator_t 122 ** 123 *****************************************************************************/ 124 125 xcb_generic_iterator_t 126 xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i /**< */) 127 { 128 xcb_generic_iterator_t ret; 129 ret.data = i.data + i.rem; 130 ret.index = i.index + ((char *) ret.data - (char *) i.data); 131 ret.rem = 0; 132 return ret; 133 } 134 135 136 /***************************************************************************** 137 ** 138 ** void xcb_glx_window_next 139 ** 140 ** @param xcb_glx_window_iterator_t *i 141 ** @returns void 142 ** 143 *****************************************************************************/ 144 145 void 146 xcb_glx_window_next (xcb_glx_window_iterator_t *i /**< */) 147 { 148 --i->rem; 149 ++i->data; 150 i->index += sizeof(xcb_glx_window_t); 151 } 152 153 154 /***************************************************************************** 155 ** 156 ** xcb_generic_iterator_t xcb_glx_window_end 157 ** 158 ** @param xcb_glx_window_iterator_t i 159 ** @returns xcb_generic_iterator_t 160 ** 161 *****************************************************************************/ 162 163 xcb_generic_iterator_t 164 xcb_glx_window_end (xcb_glx_window_iterator_t i /**< */) 165 { 166 xcb_generic_iterator_t ret; 167 ret.data = i.data + i.rem; 168 ret.index = i.index + ((char *) ret.data - (char *) i.data); 169 ret.rem = 0; 170 return ret; 171 } 172 173 174 /***************************************************************************** 175 ** 176 ** void xcb_glx_fbconfig_next 177 ** 178 ** @param xcb_glx_fbconfig_iterator_t *i 179 ** @returns void 180 ** 181 *****************************************************************************/ 182 183 void 184 xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i /**< */) 185 { 186 --i->rem; 187 ++i->data; 188 i->index += sizeof(xcb_glx_fbconfig_t); 189 } 190 191 192 /***************************************************************************** 193 ** 194 ** xcb_generic_iterator_t xcb_glx_fbconfig_end 195 ** 196 ** @param xcb_glx_fbconfig_iterator_t i 197 ** @returns xcb_generic_iterator_t 198 ** 199 *****************************************************************************/ 200 201 xcb_generic_iterator_t 202 xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i /**< */) 203 { 204 xcb_generic_iterator_t ret; 205 ret.data = i.data + i.rem; 206 ret.index = i.index + ((char *) ret.data - (char *) i.data); 207 ret.rem = 0; 208 return ret; 209 } 210 211 212 /***************************************************************************** 213 ** 214 ** void xcb_glx_drawable_next 215 ** 216 ** @param xcb_glx_drawable_iterator_t *i 217 ** @returns void 218 ** 219 *****************************************************************************/ 220 221 void 222 xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i /**< */) 223 { 224 --i->rem; 225 ++i->data; 226 i->index += sizeof(xcb_glx_drawable_t); 227 } 228 229 230 /***************************************************************************** 231 ** 232 ** xcb_generic_iterator_t xcb_glx_drawable_end 233 ** 234 ** @param xcb_glx_drawable_iterator_t i 235 ** @returns xcb_generic_iterator_t 236 ** 237 *****************************************************************************/ 238 239 xcb_generic_iterator_t 240 xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i /**< */) 241 { 242 xcb_generic_iterator_t ret; 243 ret.data = i.data + i.rem; 244 ret.index = i.index + ((char *) ret.data - (char *) i.data); 245 ret.rem = 0; 246 return ret; 247 } 248 249 250 /***************************************************************************** 251 ** 252 ** void xcb_glx_float32_next 253 ** 254 ** @param xcb_glx_float32_iterator_t *i 255 ** @returns void 256 ** 257 *****************************************************************************/ 258 259 void 260 xcb_glx_float32_next (xcb_glx_float32_iterator_t *i /**< */) 261 { 262 --i->rem; 263 ++i->data; 264 i->index += sizeof(xcb_glx_float32_t); 265 } 266 267 268 /***************************************************************************** 269 ** 270 ** xcb_generic_iterator_t xcb_glx_float32_end 271 ** 272 ** @param xcb_glx_float32_iterator_t i 273 ** @returns xcb_generic_iterator_t 274 ** 275 *****************************************************************************/ 276 277 xcb_generic_iterator_t 278 xcb_glx_float32_end (xcb_glx_float32_iterator_t i /**< */) 279 { 280 xcb_generic_iterator_t ret; 281 ret.data = i.data + i.rem; 282 ret.index = i.index + ((char *) ret.data - (char *) i.data); 283 ret.rem = 0; 284 return ret; 285 } 286 287 288 /***************************************************************************** 289 ** 290 ** void xcb_glx_float64_next 291 ** 292 ** @param xcb_glx_float64_iterator_t *i 293 ** @returns void 294 ** 295 *****************************************************************************/ 296 297 void 298 xcb_glx_float64_next (xcb_glx_float64_iterator_t *i /**< */) 299 { 300 --i->rem; 301 ++i->data; 302 i->index += sizeof(xcb_glx_float64_t); 303 } 304 305 306 /***************************************************************************** 307 ** 308 ** xcb_generic_iterator_t xcb_glx_float64_end 309 ** 310 ** @param xcb_glx_float64_iterator_t i 311 ** @returns xcb_generic_iterator_t 312 ** 313 *****************************************************************************/ 314 315 xcb_generic_iterator_t 316 xcb_glx_float64_end (xcb_glx_float64_iterator_t i /**< */) 317 { 318 xcb_generic_iterator_t ret; 319 ret.data = i.data + i.rem; 320 ret.index = i.index + ((char *) ret.data - (char *) i.data); 321 ret.rem = 0; 322 return ret; 323 } 324 325 326 /***************************************************************************** 327 ** 328 ** void xcb_glx_bool32_next 329 ** 330 ** @param xcb_glx_bool32_iterator_t *i 331 ** @returns void 332 ** 333 *****************************************************************************/ 334 335 void 336 xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i /**< */) 337 { 338 --i->rem; 339 ++i->data; 340 i->index += sizeof(xcb_glx_bool32_t); 341 } 342 343 344 /***************************************************************************** 345 ** 346 ** xcb_generic_iterator_t xcb_glx_bool32_end 347 ** 348 ** @param xcb_glx_bool32_iterator_t i 349 ** @returns xcb_generic_iterator_t 350 ** 351 *****************************************************************************/ 352 353 xcb_generic_iterator_t 354 xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i /**< */) 355 { 356 xcb_generic_iterator_t ret; 357 ret.data = i.data + i.rem; 358 ret.index = i.index + ((char *) ret.data - (char *) i.data); 359 ret.rem = 0; 360 return ret; 361 } 362 363 364 /***************************************************************************** 365 ** 366 ** void xcb_glx_context_tag_next 367 ** 368 ** @param xcb_glx_context_tag_iterator_t *i 369 ** @returns void 370 ** 371 *****************************************************************************/ 372 373 void 374 xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i /**< */) 375 { 376 --i->rem; 377 ++i->data; 378 i->index += sizeof(xcb_glx_context_tag_t); 379 } 380 381 382 /***************************************************************************** 383 ** 384 ** xcb_generic_iterator_t xcb_glx_context_tag_end 385 ** 386 ** @param xcb_glx_context_tag_iterator_t i 387 ** @returns xcb_generic_iterator_t 388 ** 389 *****************************************************************************/ 390 391 xcb_generic_iterator_t 392 xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i /**< */) 393 { 394 xcb_generic_iterator_t ret; 395 ret.data = i.data + i.rem; 396 ret.index = i.index + ((char *) ret.data - (char *) i.data); 397 ret.rem = 0; 398 return ret; 399 } 400 401 int 402 xcb_glx_render_sizeof (const void *_buffer /**< */, 403 uint32_t data_len /**< */) 404 { 405 char *xcb_tmp = (char *)_buffer; 406 unsigned int xcb_buffer_len = 0; 407 unsigned int xcb_block_len = 0; 408 unsigned int xcb_pad = 0; 409 unsigned int xcb_align_to; 410 411 412 xcb_block_len += sizeof(xcb_glx_render_request_t); 413 xcb_tmp += xcb_block_len; 414 /* data */ 415 xcb_block_len += data_len * sizeof(uint8_t); 416 xcb_tmp += xcb_block_len; 417 xcb_align_to = ALIGNOF(uint8_t); 418 /* insert padding */ 419 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 420 xcb_buffer_len += xcb_block_len + xcb_pad; 421 if (0 != xcb_pad) { 422 xcb_tmp += xcb_pad; 423 xcb_pad = 0; 424 } 425 xcb_block_len = 0; 426 427 return xcb_buffer_len; 428 } 429 430 431 /***************************************************************************** 432 ** 433 ** xcb_void_cookie_t xcb_glx_render_checked 434 ** 435 ** @param xcb_connection_t *c 436 ** @param xcb_glx_context_tag_t context_tag 437 ** @param uint32_t data_len 438 ** @param const uint8_t *data 439 ** @returns xcb_void_cookie_t 440 ** 441 *****************************************************************************/ 442 443 xcb_void_cookie_t 444 xcb_glx_render_checked (xcb_connection_t *c /**< */, 445 xcb_glx_context_tag_t context_tag /**< */, 446 uint32_t data_len /**< */, 447 const uint8_t *data /**< */) 448 { 449 static const xcb_protocol_request_t xcb_req = { 450 /* count */ 4, 451 /* ext */ &xcb_glx_id, 452 /* opcode */ XCB_GLX_RENDER, 453 /* isvoid */ 1 454 }; 455 456 struct iovec xcb_parts[6]; 457 xcb_void_cookie_t xcb_ret; 458 xcb_glx_render_request_t xcb_out; 459 460 xcb_out.context_tag = context_tag; 461 462 xcb_parts[2].iov_base = (char *) &xcb_out; 463 xcb_parts[2].iov_len = sizeof(xcb_out); 464 xcb_parts[3].iov_base = 0; 465 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 466 /* uint8_t data */ 467 xcb_parts[4].iov_base = (char *) data; 468 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 469 xcb_parts[5].iov_base = 0; 470 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 471 472 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 473 return xcb_ret; 474 } 475 476 477 /***************************************************************************** 478 ** 479 ** xcb_void_cookie_t xcb_glx_render 480 ** 481 ** @param xcb_connection_t *c 482 ** @param xcb_glx_context_tag_t context_tag 483 ** @param uint32_t data_len 484 ** @param const uint8_t *data 485 ** @returns xcb_void_cookie_t 486 ** 487 *****************************************************************************/ 488 489 xcb_void_cookie_t 490 xcb_glx_render (xcb_connection_t *c /**< */, 491 xcb_glx_context_tag_t context_tag /**< */, 492 uint32_t data_len /**< */, 493 const uint8_t *data /**< */) 494 { 495 static const xcb_protocol_request_t xcb_req = { 496 /* count */ 4, 497 /* ext */ &xcb_glx_id, 498 /* opcode */ XCB_GLX_RENDER, 499 /* isvoid */ 1 500 }; 501 502 struct iovec xcb_parts[6]; 503 xcb_void_cookie_t xcb_ret; 504 xcb_glx_render_request_t xcb_out; 505 506 xcb_out.context_tag = context_tag; 507 508 xcb_parts[2].iov_base = (char *) &xcb_out; 509 xcb_parts[2].iov_len = sizeof(xcb_out); 510 xcb_parts[3].iov_base = 0; 511 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 512 /* uint8_t data */ 513 xcb_parts[4].iov_base = (char *) data; 514 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 515 xcb_parts[5].iov_base = 0; 516 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 517 518 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 519 return xcb_ret; 520 } 521 522 int 523 xcb_glx_render_large_sizeof (const void *_buffer /**< */) 524 { 525 char *xcb_tmp = (char *)_buffer; 526 const xcb_glx_render_large_request_t *_aux = (xcb_glx_render_large_request_t *)_buffer; 527 unsigned int xcb_buffer_len = 0; 528 unsigned int xcb_block_len = 0; 529 unsigned int xcb_pad = 0; 530 unsigned int xcb_align_to; 531 532 533 xcb_block_len += sizeof(xcb_glx_render_large_request_t); 534 xcb_tmp += xcb_block_len; 535 /* data */ 536 xcb_block_len += _aux->data_len * sizeof(uint8_t); 537 xcb_tmp += xcb_block_len; 538 xcb_align_to = ALIGNOF(uint8_t); 539 /* insert padding */ 540 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 541 xcb_buffer_len += xcb_block_len + xcb_pad; 542 if (0 != xcb_pad) { 543 xcb_tmp += xcb_pad; 544 xcb_pad = 0; 545 } 546 xcb_block_len = 0; 547 548 return xcb_buffer_len; 549 } 550 551 552 /***************************************************************************** 553 ** 554 ** xcb_void_cookie_t xcb_glx_render_large_checked 555 ** 556 ** @param xcb_connection_t *c 557 ** @param xcb_glx_context_tag_t context_tag 558 ** @param uint16_t request_num 559 ** @param uint16_t request_total 560 ** @param uint32_t data_len 561 ** @param const uint8_t *data 562 ** @returns xcb_void_cookie_t 563 ** 564 *****************************************************************************/ 565 566 xcb_void_cookie_t 567 xcb_glx_render_large_checked (xcb_connection_t *c /**< */, 568 xcb_glx_context_tag_t context_tag /**< */, 569 uint16_t request_num /**< */, 570 uint16_t request_total /**< */, 571 uint32_t data_len /**< */, 572 const uint8_t *data /**< */) 573 { 574 static const xcb_protocol_request_t xcb_req = { 575 /* count */ 4, 576 /* ext */ &xcb_glx_id, 577 /* opcode */ XCB_GLX_RENDER_LARGE, 578 /* isvoid */ 1 579 }; 580 581 struct iovec xcb_parts[6]; 582 xcb_void_cookie_t xcb_ret; 583 xcb_glx_render_large_request_t xcb_out; 584 585 xcb_out.context_tag = context_tag; 586 xcb_out.request_num = request_num; 587 xcb_out.request_total = request_total; 588 xcb_out.data_len = data_len; 589 590 xcb_parts[2].iov_base = (char *) &xcb_out; 591 xcb_parts[2].iov_len = sizeof(xcb_out); 592 xcb_parts[3].iov_base = 0; 593 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 594 /* uint8_t data */ 595 xcb_parts[4].iov_base = (char *) data; 596 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 597 xcb_parts[5].iov_base = 0; 598 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 599 600 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 601 return xcb_ret; 602 } 603 604 605 /***************************************************************************** 606 ** 607 ** xcb_void_cookie_t xcb_glx_render_large 608 ** 609 ** @param xcb_connection_t *c 610 ** @param xcb_glx_context_tag_t context_tag 611 ** @param uint16_t request_num 612 ** @param uint16_t request_total 613 ** @param uint32_t data_len 614 ** @param const uint8_t *data 615 ** @returns xcb_void_cookie_t 616 ** 617 *****************************************************************************/ 618 619 xcb_void_cookie_t 620 xcb_glx_render_large (xcb_connection_t *c /**< */, 621 xcb_glx_context_tag_t context_tag /**< */, 622 uint16_t request_num /**< */, 623 uint16_t request_total /**< */, 624 uint32_t data_len /**< */, 625 const uint8_t *data /**< */) 626 { 627 static const xcb_protocol_request_t xcb_req = { 628 /* count */ 4, 629 /* ext */ &xcb_glx_id, 630 /* opcode */ XCB_GLX_RENDER_LARGE, 631 /* isvoid */ 1 632 }; 633 634 struct iovec xcb_parts[6]; 635 xcb_void_cookie_t xcb_ret; 636 xcb_glx_render_large_request_t xcb_out; 637 638 xcb_out.context_tag = context_tag; 639 xcb_out.request_num = request_num; 640 xcb_out.request_total = request_total; 641 xcb_out.data_len = data_len; 642 643 xcb_parts[2].iov_base = (char *) &xcb_out; 644 xcb_parts[2].iov_len = sizeof(xcb_out); 645 xcb_parts[3].iov_base = 0; 646 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 647 /* uint8_t data */ 648 xcb_parts[4].iov_base = (char *) data; 649 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 650 xcb_parts[5].iov_base = 0; 651 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 652 653 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 654 return xcb_ret; 655 } 656 657 658 /***************************************************************************** 659 ** 660 ** xcb_void_cookie_t xcb_glx_create_context_checked 661 ** 662 ** @param xcb_connection_t *c 663 ** @param xcb_glx_context_t context 664 ** @param xcb_visualid_t visual 665 ** @param uint32_t screen 666 ** @param xcb_glx_context_t share_list 667 ** @param uint8_t is_direct 668 ** @returns xcb_void_cookie_t 669 ** 670 *****************************************************************************/ 671 672 xcb_void_cookie_t 673 xcb_glx_create_context_checked (xcb_connection_t *c /**< */, 674 xcb_glx_context_t context /**< */, 675 xcb_visualid_t visual /**< */, 676 uint32_t screen /**< */, 677 xcb_glx_context_t share_list /**< */, 678 uint8_t is_direct /**< */) 679 { 680 static const xcb_protocol_request_t xcb_req = { 681 /* count */ 2, 682 /* ext */ &xcb_glx_id, 683 /* opcode */ XCB_GLX_CREATE_CONTEXT, 684 /* isvoid */ 1 685 }; 686 687 struct iovec xcb_parts[4]; 688 xcb_void_cookie_t xcb_ret; 689 xcb_glx_create_context_request_t xcb_out; 690 691 xcb_out.context = context; 692 xcb_out.visual = visual; 693 xcb_out.screen = screen; 694 xcb_out.share_list = share_list; 695 xcb_out.is_direct = is_direct; 696 memset(xcb_out.pad0, 0, 3); 697 698 xcb_parts[2].iov_base = (char *) &xcb_out; 699 xcb_parts[2].iov_len = sizeof(xcb_out); 700 xcb_parts[3].iov_base = 0; 701 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 702 703 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 704 return xcb_ret; 705 } 706 707 708 /***************************************************************************** 709 ** 710 ** xcb_void_cookie_t xcb_glx_create_context 711 ** 712 ** @param xcb_connection_t *c 713 ** @param xcb_glx_context_t context 714 ** @param xcb_visualid_t visual 715 ** @param uint32_t screen 716 ** @param xcb_glx_context_t share_list 717 ** @param uint8_t is_direct 718 ** @returns xcb_void_cookie_t 719 ** 720 *****************************************************************************/ 721 722 xcb_void_cookie_t 723 xcb_glx_create_context (xcb_connection_t *c /**< */, 724 xcb_glx_context_t context /**< */, 725 xcb_visualid_t visual /**< */, 726 uint32_t screen /**< */, 727 xcb_glx_context_t share_list /**< */, 728 uint8_t is_direct /**< */) 729 { 730 static const xcb_protocol_request_t xcb_req = { 731 /* count */ 2, 732 /* ext */ &xcb_glx_id, 733 /* opcode */ XCB_GLX_CREATE_CONTEXT, 734 /* isvoid */ 1 735 }; 736 737 struct iovec xcb_parts[4]; 738 xcb_void_cookie_t xcb_ret; 739 xcb_glx_create_context_request_t xcb_out; 740 741 xcb_out.context = context; 742 xcb_out.visual = visual; 743 xcb_out.screen = screen; 744 xcb_out.share_list = share_list; 745 xcb_out.is_direct = is_direct; 746 memset(xcb_out.pad0, 0, 3); 747 748 xcb_parts[2].iov_base = (char *) &xcb_out; 749 xcb_parts[2].iov_len = sizeof(xcb_out); 750 xcb_parts[3].iov_base = 0; 751 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 752 753 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 754 return xcb_ret; 755 } 756 757 758 /***************************************************************************** 759 ** 760 ** xcb_void_cookie_t xcb_glx_destroy_context_checked 761 ** 762 ** @param xcb_connection_t *c 763 ** @param xcb_glx_context_t context 764 ** @returns xcb_void_cookie_t 765 ** 766 *****************************************************************************/ 767 768 xcb_void_cookie_t 769 xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, 770 xcb_glx_context_t context /**< */) 771 { 772 static const xcb_protocol_request_t xcb_req = { 773 /* count */ 2, 774 /* ext */ &xcb_glx_id, 775 /* opcode */ XCB_GLX_DESTROY_CONTEXT, 776 /* isvoid */ 1 777 }; 778 779 struct iovec xcb_parts[4]; 780 xcb_void_cookie_t xcb_ret; 781 xcb_glx_destroy_context_request_t xcb_out; 782 783 xcb_out.context = context; 784 785 xcb_parts[2].iov_base = (char *) &xcb_out; 786 xcb_parts[2].iov_len = sizeof(xcb_out); 787 xcb_parts[3].iov_base = 0; 788 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 789 790 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 791 return xcb_ret; 792 } 793 794 795 /***************************************************************************** 796 ** 797 ** xcb_void_cookie_t xcb_glx_destroy_context 798 ** 799 ** @param xcb_connection_t *c 800 ** @param xcb_glx_context_t context 801 ** @returns xcb_void_cookie_t 802 ** 803 *****************************************************************************/ 804 805 xcb_void_cookie_t 806 xcb_glx_destroy_context (xcb_connection_t *c /**< */, 807 xcb_glx_context_t context /**< */) 808 { 809 static const xcb_protocol_request_t xcb_req = { 810 /* count */ 2, 811 /* ext */ &xcb_glx_id, 812 /* opcode */ XCB_GLX_DESTROY_CONTEXT, 813 /* isvoid */ 1 814 }; 815 816 struct iovec xcb_parts[4]; 817 xcb_void_cookie_t xcb_ret; 818 xcb_glx_destroy_context_request_t xcb_out; 819 820 xcb_out.context = context; 821 822 xcb_parts[2].iov_base = (char *) &xcb_out; 823 xcb_parts[2].iov_len = sizeof(xcb_out); 824 xcb_parts[3].iov_base = 0; 825 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 826 827 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 828 return xcb_ret; 829 } 830 831 832 /***************************************************************************** 833 ** 834 ** xcb_glx_make_current_cookie_t xcb_glx_make_current 835 ** 836 ** @param xcb_connection_t *c 837 ** @param xcb_glx_drawable_t drawable 838 ** @param xcb_glx_context_t context 839 ** @param xcb_glx_context_tag_t old_context_tag 840 ** @returns xcb_glx_make_current_cookie_t 841 ** 842 *****************************************************************************/ 843 844 xcb_glx_make_current_cookie_t 845 xcb_glx_make_current (xcb_connection_t *c /**< */, 846 xcb_glx_drawable_t drawable /**< */, 847 xcb_glx_context_t context /**< */, 848 xcb_glx_context_tag_t old_context_tag /**< */) 849 { 850 static const xcb_protocol_request_t xcb_req = { 851 /* count */ 2, 852 /* ext */ &xcb_glx_id, 853 /* opcode */ XCB_GLX_MAKE_CURRENT, 854 /* isvoid */ 0 855 }; 856 857 struct iovec xcb_parts[4]; 858 xcb_glx_make_current_cookie_t xcb_ret; 859 xcb_glx_make_current_request_t xcb_out; 860 861 xcb_out.drawable = drawable; 862 xcb_out.context = context; 863 xcb_out.old_context_tag = old_context_tag; 864 865 xcb_parts[2].iov_base = (char *) &xcb_out; 866 xcb_parts[2].iov_len = sizeof(xcb_out); 867 xcb_parts[3].iov_base = 0; 868 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 869 870 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 871 return xcb_ret; 872 } 873 874 875 /***************************************************************************** 876 ** 877 ** xcb_glx_make_current_cookie_t xcb_glx_make_current_unchecked 878 ** 879 ** @param xcb_connection_t *c 880 ** @param xcb_glx_drawable_t drawable 881 ** @param xcb_glx_context_t context 882 ** @param xcb_glx_context_tag_t old_context_tag 883 ** @returns xcb_glx_make_current_cookie_t 884 ** 885 *****************************************************************************/ 886 887 xcb_glx_make_current_cookie_t 888 xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, 889 xcb_glx_drawable_t drawable /**< */, 890 xcb_glx_context_t context /**< */, 891 xcb_glx_context_tag_t old_context_tag /**< */) 892 { 893 static const xcb_protocol_request_t xcb_req = { 894 /* count */ 2, 895 /* ext */ &xcb_glx_id, 896 /* opcode */ XCB_GLX_MAKE_CURRENT, 897 /* isvoid */ 0 898 }; 899 900 struct iovec xcb_parts[4]; 901 xcb_glx_make_current_cookie_t xcb_ret; 902 xcb_glx_make_current_request_t xcb_out; 903 904 xcb_out.drawable = drawable; 905 xcb_out.context = context; 906 xcb_out.old_context_tag = old_context_tag; 907 908 xcb_parts[2].iov_base = (char *) &xcb_out; 909 xcb_parts[2].iov_len = sizeof(xcb_out); 910 xcb_parts[3].iov_base = 0; 911 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 912 913 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 914 return xcb_ret; 915 } 916 917 918 /***************************************************************************** 919 ** 920 ** xcb_glx_make_current_reply_t * xcb_glx_make_current_reply 921 ** 922 ** @param xcb_connection_t *c 923 ** @param xcb_glx_make_current_cookie_t cookie 924 ** @param xcb_generic_error_t **e 925 ** @returns xcb_glx_make_current_reply_t * 926 ** 927 *****************************************************************************/ 928 929 xcb_glx_make_current_reply_t * 930 xcb_glx_make_current_reply (xcb_connection_t *c /**< */, 931 xcb_glx_make_current_cookie_t cookie /**< */, 932 xcb_generic_error_t **e /**< */) 933 { 934 return (xcb_glx_make_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 935 } 936 937 938 /***************************************************************************** 939 ** 940 ** xcb_glx_is_direct_cookie_t xcb_glx_is_direct 941 ** 942 ** @param xcb_connection_t *c 943 ** @param xcb_glx_context_t context 944 ** @returns xcb_glx_is_direct_cookie_t 945 ** 946 *****************************************************************************/ 947 948 xcb_glx_is_direct_cookie_t 949 xcb_glx_is_direct (xcb_connection_t *c /**< */, 950 xcb_glx_context_t context /**< */) 951 { 952 static const xcb_protocol_request_t xcb_req = { 953 /* count */ 2, 954 /* ext */ &xcb_glx_id, 955 /* opcode */ XCB_GLX_IS_DIRECT, 956 /* isvoid */ 0 957 }; 958 959 struct iovec xcb_parts[4]; 960 xcb_glx_is_direct_cookie_t xcb_ret; 961 xcb_glx_is_direct_request_t xcb_out; 962 963 xcb_out.context = context; 964 965 xcb_parts[2].iov_base = (char *) &xcb_out; 966 xcb_parts[2].iov_len = sizeof(xcb_out); 967 xcb_parts[3].iov_base = 0; 968 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 969 970 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 971 return xcb_ret; 972 } 973 974 975 /***************************************************************************** 976 ** 977 ** xcb_glx_is_direct_cookie_t xcb_glx_is_direct_unchecked 978 ** 979 ** @param xcb_connection_t *c 980 ** @param xcb_glx_context_t context 981 ** @returns xcb_glx_is_direct_cookie_t 982 ** 983 *****************************************************************************/ 984 985 xcb_glx_is_direct_cookie_t 986 xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, 987 xcb_glx_context_t context /**< */) 988 { 989 static const xcb_protocol_request_t xcb_req = { 990 /* count */ 2, 991 /* ext */ &xcb_glx_id, 992 /* opcode */ XCB_GLX_IS_DIRECT, 993 /* isvoid */ 0 994 }; 995 996 struct iovec xcb_parts[4]; 997 xcb_glx_is_direct_cookie_t xcb_ret; 998 xcb_glx_is_direct_request_t xcb_out; 999 1000 xcb_out.context = context; 1001 1002 xcb_parts[2].iov_base = (char *) &xcb_out; 1003 xcb_parts[2].iov_len = sizeof(xcb_out); 1004 xcb_parts[3].iov_base = 0; 1005 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1006 1007 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1008 return xcb_ret; 1009 } 1010 1011 1012 /***************************************************************************** 1013 ** 1014 ** xcb_glx_is_direct_reply_t * xcb_glx_is_direct_reply 1015 ** 1016 ** @param xcb_connection_t *c 1017 ** @param xcb_glx_is_direct_cookie_t cookie 1018 ** @param xcb_generic_error_t **e 1019 ** @returns xcb_glx_is_direct_reply_t * 1020 ** 1021 *****************************************************************************/ 1022 1023 xcb_glx_is_direct_reply_t * 1024 xcb_glx_is_direct_reply (xcb_connection_t *c /**< */, 1025 xcb_glx_is_direct_cookie_t cookie /**< */, 1026 xcb_generic_error_t **e /**< */) 1027 { 1028 return (xcb_glx_is_direct_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1029 } 1030 1031 1032 /***************************************************************************** 1033 ** 1034 ** xcb_glx_query_version_cookie_t xcb_glx_query_version 1035 ** 1036 ** @param xcb_connection_t *c 1037 ** @param uint32_t major_version 1038 ** @param uint32_t minor_version 1039 ** @returns xcb_glx_query_version_cookie_t 1040 ** 1041 *****************************************************************************/ 1042 1043 xcb_glx_query_version_cookie_t 1044 xcb_glx_query_version (xcb_connection_t *c /**< */, 1045 uint32_t major_version /**< */, 1046 uint32_t minor_version /**< */) 1047 { 1048 static const xcb_protocol_request_t xcb_req = { 1049 /* count */ 2, 1050 /* ext */ &xcb_glx_id, 1051 /* opcode */ XCB_GLX_QUERY_VERSION, 1052 /* isvoid */ 0 1053 }; 1054 1055 struct iovec xcb_parts[4]; 1056 xcb_glx_query_version_cookie_t xcb_ret; 1057 xcb_glx_query_version_request_t xcb_out; 1058 1059 xcb_out.major_version = major_version; 1060 xcb_out.minor_version = minor_version; 1061 1062 xcb_parts[2].iov_base = (char *) &xcb_out; 1063 xcb_parts[2].iov_len = sizeof(xcb_out); 1064 xcb_parts[3].iov_base = 0; 1065 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1066 1067 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1068 return xcb_ret; 1069 } 1070 1071 1072 /***************************************************************************** 1073 ** 1074 ** xcb_glx_query_version_cookie_t xcb_glx_query_version_unchecked 1075 ** 1076 ** @param xcb_connection_t *c 1077 ** @param uint32_t major_version 1078 ** @param uint32_t minor_version 1079 ** @returns xcb_glx_query_version_cookie_t 1080 ** 1081 *****************************************************************************/ 1082 1083 xcb_glx_query_version_cookie_t 1084 xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, 1085 uint32_t major_version /**< */, 1086 uint32_t minor_version /**< */) 1087 { 1088 static const xcb_protocol_request_t xcb_req = { 1089 /* count */ 2, 1090 /* ext */ &xcb_glx_id, 1091 /* opcode */ XCB_GLX_QUERY_VERSION, 1092 /* isvoid */ 0 1093 }; 1094 1095 struct iovec xcb_parts[4]; 1096 xcb_glx_query_version_cookie_t xcb_ret; 1097 xcb_glx_query_version_request_t xcb_out; 1098 1099 xcb_out.major_version = major_version; 1100 xcb_out.minor_version = minor_version; 1101 1102 xcb_parts[2].iov_base = (char *) &xcb_out; 1103 xcb_parts[2].iov_len = sizeof(xcb_out); 1104 xcb_parts[3].iov_base = 0; 1105 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1106 1107 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1108 return xcb_ret; 1109 } 1110 1111 1112 /***************************************************************************** 1113 ** 1114 ** xcb_glx_query_version_reply_t * xcb_glx_query_version_reply 1115 ** 1116 ** @param xcb_connection_t *c 1117 ** @param xcb_glx_query_version_cookie_t cookie 1118 ** @param xcb_generic_error_t **e 1119 ** @returns xcb_glx_query_version_reply_t * 1120 ** 1121 *****************************************************************************/ 1122 1123 xcb_glx_query_version_reply_t * 1124 xcb_glx_query_version_reply (xcb_connection_t *c /**< */, 1125 xcb_glx_query_version_cookie_t cookie /**< */, 1126 xcb_generic_error_t **e /**< */) 1127 { 1128 return (xcb_glx_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1129 } 1130 1131 1132 /***************************************************************************** 1133 ** 1134 ** xcb_void_cookie_t xcb_glx_wait_gl_checked 1135 ** 1136 ** @param xcb_connection_t *c 1137 ** @param xcb_glx_context_tag_t context_tag 1138 ** @returns xcb_void_cookie_t 1139 ** 1140 *****************************************************************************/ 1141 1142 xcb_void_cookie_t 1143 xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, 1144 xcb_glx_context_tag_t context_tag /**< */) 1145 { 1146 static const xcb_protocol_request_t xcb_req = { 1147 /* count */ 2, 1148 /* ext */ &xcb_glx_id, 1149 /* opcode */ XCB_GLX_WAIT_GL, 1150 /* isvoid */ 1 1151 }; 1152 1153 struct iovec xcb_parts[4]; 1154 xcb_void_cookie_t xcb_ret; 1155 xcb_glx_wait_gl_request_t xcb_out; 1156 1157 xcb_out.context_tag = context_tag; 1158 1159 xcb_parts[2].iov_base = (char *) &xcb_out; 1160 xcb_parts[2].iov_len = sizeof(xcb_out); 1161 xcb_parts[3].iov_base = 0; 1162 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1163 1164 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1165 return xcb_ret; 1166 } 1167 1168 1169 /***************************************************************************** 1170 ** 1171 ** xcb_void_cookie_t xcb_glx_wait_gl 1172 ** 1173 ** @param xcb_connection_t *c 1174 ** @param xcb_glx_context_tag_t context_tag 1175 ** @returns xcb_void_cookie_t 1176 ** 1177 *****************************************************************************/ 1178 1179 xcb_void_cookie_t 1180 xcb_glx_wait_gl (xcb_connection_t *c /**< */, 1181 xcb_glx_context_tag_t context_tag /**< */) 1182 { 1183 static const xcb_protocol_request_t xcb_req = { 1184 /* count */ 2, 1185 /* ext */ &xcb_glx_id, 1186 /* opcode */ XCB_GLX_WAIT_GL, 1187 /* isvoid */ 1 1188 }; 1189 1190 struct iovec xcb_parts[4]; 1191 xcb_void_cookie_t xcb_ret; 1192 xcb_glx_wait_gl_request_t xcb_out; 1193 1194 xcb_out.context_tag = context_tag; 1195 1196 xcb_parts[2].iov_base = (char *) &xcb_out; 1197 xcb_parts[2].iov_len = sizeof(xcb_out); 1198 xcb_parts[3].iov_base = 0; 1199 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1200 1201 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1202 return xcb_ret; 1203 } 1204 1205 1206 /***************************************************************************** 1207 ** 1208 ** xcb_void_cookie_t xcb_glx_wait_x_checked 1209 ** 1210 ** @param xcb_connection_t *c 1211 ** @param xcb_glx_context_tag_t context_tag 1212 ** @returns xcb_void_cookie_t 1213 ** 1214 *****************************************************************************/ 1215 1216 xcb_void_cookie_t 1217 xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, 1218 xcb_glx_context_tag_t context_tag /**< */) 1219 { 1220 static const xcb_protocol_request_t xcb_req = { 1221 /* count */ 2, 1222 /* ext */ &xcb_glx_id, 1223 /* opcode */ XCB_GLX_WAIT_X, 1224 /* isvoid */ 1 1225 }; 1226 1227 struct iovec xcb_parts[4]; 1228 xcb_void_cookie_t xcb_ret; 1229 xcb_glx_wait_x_request_t xcb_out; 1230 1231 xcb_out.context_tag = context_tag; 1232 1233 xcb_parts[2].iov_base = (char *) &xcb_out; 1234 xcb_parts[2].iov_len = sizeof(xcb_out); 1235 xcb_parts[3].iov_base = 0; 1236 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1237 1238 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1239 return xcb_ret; 1240 } 1241 1242 1243 /***************************************************************************** 1244 ** 1245 ** xcb_void_cookie_t xcb_glx_wait_x 1246 ** 1247 ** @param xcb_connection_t *c 1248 ** @param xcb_glx_context_tag_t context_tag 1249 ** @returns xcb_void_cookie_t 1250 ** 1251 *****************************************************************************/ 1252 1253 xcb_void_cookie_t 1254 xcb_glx_wait_x (xcb_connection_t *c /**< */, 1255 xcb_glx_context_tag_t context_tag /**< */) 1256 { 1257 static const xcb_protocol_request_t xcb_req = { 1258 /* count */ 2, 1259 /* ext */ &xcb_glx_id, 1260 /* opcode */ XCB_GLX_WAIT_X, 1261 /* isvoid */ 1 1262 }; 1263 1264 struct iovec xcb_parts[4]; 1265 xcb_void_cookie_t xcb_ret; 1266 xcb_glx_wait_x_request_t xcb_out; 1267 1268 xcb_out.context_tag = context_tag; 1269 1270 xcb_parts[2].iov_base = (char *) &xcb_out; 1271 xcb_parts[2].iov_len = sizeof(xcb_out); 1272 xcb_parts[3].iov_base = 0; 1273 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1274 1275 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1276 return xcb_ret; 1277 } 1278 1279 1280 /***************************************************************************** 1281 ** 1282 ** xcb_void_cookie_t xcb_glx_copy_context_checked 1283 ** 1284 ** @param xcb_connection_t *c 1285 ** @param xcb_glx_context_t src 1286 ** @param xcb_glx_context_t dest 1287 ** @param uint32_t mask 1288 ** @param xcb_glx_context_tag_t src_context_tag 1289 ** @returns xcb_void_cookie_t 1290 ** 1291 *****************************************************************************/ 1292 1293 xcb_void_cookie_t 1294 xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, 1295 xcb_glx_context_t src /**< */, 1296 xcb_glx_context_t dest /**< */, 1297 uint32_t mask /**< */, 1298 xcb_glx_context_tag_t src_context_tag /**< */) 1299 { 1300 static const xcb_protocol_request_t xcb_req = { 1301 /* count */ 2, 1302 /* ext */ &xcb_glx_id, 1303 /* opcode */ XCB_GLX_COPY_CONTEXT, 1304 /* isvoid */ 1 1305 }; 1306 1307 struct iovec xcb_parts[4]; 1308 xcb_void_cookie_t xcb_ret; 1309 xcb_glx_copy_context_request_t xcb_out; 1310 1311 xcb_out.src = src; 1312 xcb_out.dest = dest; 1313 xcb_out.mask = mask; 1314 xcb_out.src_context_tag = src_context_tag; 1315 1316 xcb_parts[2].iov_base = (char *) &xcb_out; 1317 xcb_parts[2].iov_len = sizeof(xcb_out); 1318 xcb_parts[3].iov_base = 0; 1319 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1320 1321 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1322 return xcb_ret; 1323 } 1324 1325 1326 /***************************************************************************** 1327 ** 1328 ** xcb_void_cookie_t xcb_glx_copy_context 1329 ** 1330 ** @param xcb_connection_t *c 1331 ** @param xcb_glx_context_t src 1332 ** @param xcb_glx_context_t dest 1333 ** @param uint32_t mask 1334 ** @param xcb_glx_context_tag_t src_context_tag 1335 ** @returns xcb_void_cookie_t 1336 ** 1337 *****************************************************************************/ 1338 1339 xcb_void_cookie_t 1340 xcb_glx_copy_context (xcb_connection_t *c /**< */, 1341 xcb_glx_context_t src /**< */, 1342 xcb_glx_context_t dest /**< */, 1343 uint32_t mask /**< */, 1344 xcb_glx_context_tag_t src_context_tag /**< */) 1345 { 1346 static const xcb_protocol_request_t xcb_req = { 1347 /* count */ 2, 1348 /* ext */ &xcb_glx_id, 1349 /* opcode */ XCB_GLX_COPY_CONTEXT, 1350 /* isvoid */ 1 1351 }; 1352 1353 struct iovec xcb_parts[4]; 1354 xcb_void_cookie_t xcb_ret; 1355 xcb_glx_copy_context_request_t xcb_out; 1356 1357 xcb_out.src = src; 1358 xcb_out.dest = dest; 1359 xcb_out.mask = mask; 1360 xcb_out.src_context_tag = src_context_tag; 1361 1362 xcb_parts[2].iov_base = (char *) &xcb_out; 1363 xcb_parts[2].iov_len = sizeof(xcb_out); 1364 xcb_parts[3].iov_base = 0; 1365 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1366 1367 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1368 return xcb_ret; 1369 } 1370 1371 1372 /***************************************************************************** 1373 ** 1374 ** xcb_void_cookie_t xcb_glx_swap_buffers_checked 1375 ** 1376 ** @param xcb_connection_t *c 1377 ** @param xcb_glx_context_tag_t context_tag 1378 ** @param xcb_glx_drawable_t drawable 1379 ** @returns xcb_void_cookie_t 1380 ** 1381 *****************************************************************************/ 1382 1383 xcb_void_cookie_t 1384 xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, 1385 xcb_glx_context_tag_t context_tag /**< */, 1386 xcb_glx_drawable_t drawable /**< */) 1387 { 1388 static const xcb_protocol_request_t xcb_req = { 1389 /* count */ 2, 1390 /* ext */ &xcb_glx_id, 1391 /* opcode */ XCB_GLX_SWAP_BUFFERS, 1392 /* isvoid */ 1 1393 }; 1394 1395 struct iovec xcb_parts[4]; 1396 xcb_void_cookie_t xcb_ret; 1397 xcb_glx_swap_buffers_request_t xcb_out; 1398 1399 xcb_out.context_tag = context_tag; 1400 xcb_out.drawable = drawable; 1401 1402 xcb_parts[2].iov_base = (char *) &xcb_out; 1403 xcb_parts[2].iov_len = sizeof(xcb_out); 1404 xcb_parts[3].iov_base = 0; 1405 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1406 1407 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1408 return xcb_ret; 1409 } 1410 1411 1412 /***************************************************************************** 1413 ** 1414 ** xcb_void_cookie_t xcb_glx_swap_buffers 1415 ** 1416 ** @param xcb_connection_t *c 1417 ** @param xcb_glx_context_tag_t context_tag 1418 ** @param xcb_glx_drawable_t drawable 1419 ** @returns xcb_void_cookie_t 1420 ** 1421 *****************************************************************************/ 1422 1423 xcb_void_cookie_t 1424 xcb_glx_swap_buffers (xcb_connection_t *c /**< */, 1425 xcb_glx_context_tag_t context_tag /**< */, 1426 xcb_glx_drawable_t drawable /**< */) 1427 { 1428 static const xcb_protocol_request_t xcb_req = { 1429 /* count */ 2, 1430 /* ext */ &xcb_glx_id, 1431 /* opcode */ XCB_GLX_SWAP_BUFFERS, 1432 /* isvoid */ 1 1433 }; 1434 1435 struct iovec xcb_parts[4]; 1436 xcb_void_cookie_t xcb_ret; 1437 xcb_glx_swap_buffers_request_t xcb_out; 1438 1439 xcb_out.context_tag = context_tag; 1440 xcb_out.drawable = drawable; 1441 1442 xcb_parts[2].iov_base = (char *) &xcb_out; 1443 xcb_parts[2].iov_len = sizeof(xcb_out); 1444 xcb_parts[3].iov_base = 0; 1445 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1446 1447 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1448 return xcb_ret; 1449 } 1450 1451 1452 /***************************************************************************** 1453 ** 1454 ** xcb_void_cookie_t xcb_glx_use_x_font_checked 1455 ** 1456 ** @param xcb_connection_t *c 1457 ** @param xcb_glx_context_tag_t context_tag 1458 ** @param xcb_font_t font 1459 ** @param uint32_t first 1460 ** @param uint32_t count 1461 ** @param uint32_t list_base 1462 ** @returns xcb_void_cookie_t 1463 ** 1464 *****************************************************************************/ 1465 1466 xcb_void_cookie_t 1467 xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, 1468 xcb_glx_context_tag_t context_tag /**< */, 1469 xcb_font_t font /**< */, 1470 uint32_t first /**< */, 1471 uint32_t count /**< */, 1472 uint32_t list_base /**< */) 1473 { 1474 static const xcb_protocol_request_t xcb_req = { 1475 /* count */ 2, 1476 /* ext */ &xcb_glx_id, 1477 /* opcode */ XCB_GLX_USE_X_FONT, 1478 /* isvoid */ 1 1479 }; 1480 1481 struct iovec xcb_parts[4]; 1482 xcb_void_cookie_t xcb_ret; 1483 xcb_glx_use_x_font_request_t xcb_out; 1484 1485 xcb_out.context_tag = context_tag; 1486 xcb_out.font = font; 1487 xcb_out.first = first; 1488 xcb_out.count = count; 1489 xcb_out.list_base = list_base; 1490 1491 xcb_parts[2].iov_base = (char *) &xcb_out; 1492 xcb_parts[2].iov_len = sizeof(xcb_out); 1493 xcb_parts[3].iov_base = 0; 1494 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1495 1496 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1497 return xcb_ret; 1498 } 1499 1500 1501 /***************************************************************************** 1502 ** 1503 ** xcb_void_cookie_t xcb_glx_use_x_font 1504 ** 1505 ** @param xcb_connection_t *c 1506 ** @param xcb_glx_context_tag_t context_tag 1507 ** @param xcb_font_t font 1508 ** @param uint32_t first 1509 ** @param uint32_t count 1510 ** @param uint32_t list_base 1511 ** @returns xcb_void_cookie_t 1512 ** 1513 *****************************************************************************/ 1514 1515 xcb_void_cookie_t 1516 xcb_glx_use_x_font (xcb_connection_t *c /**< */, 1517 xcb_glx_context_tag_t context_tag /**< */, 1518 xcb_font_t font /**< */, 1519 uint32_t first /**< */, 1520 uint32_t count /**< */, 1521 uint32_t list_base /**< */) 1522 { 1523 static const xcb_protocol_request_t xcb_req = { 1524 /* count */ 2, 1525 /* ext */ &xcb_glx_id, 1526 /* opcode */ XCB_GLX_USE_X_FONT, 1527 /* isvoid */ 1 1528 }; 1529 1530 struct iovec xcb_parts[4]; 1531 xcb_void_cookie_t xcb_ret; 1532 xcb_glx_use_x_font_request_t xcb_out; 1533 1534 xcb_out.context_tag = context_tag; 1535 xcb_out.font = font; 1536 xcb_out.first = first; 1537 xcb_out.count = count; 1538 xcb_out.list_base = list_base; 1539 1540 xcb_parts[2].iov_base = (char *) &xcb_out; 1541 xcb_parts[2].iov_len = sizeof(xcb_out); 1542 xcb_parts[3].iov_base = 0; 1543 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1544 1545 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1546 return xcb_ret; 1547 } 1548 1549 1550 /***************************************************************************** 1551 ** 1552 ** xcb_void_cookie_t xcb_glx_create_glx_pixmap_checked 1553 ** 1554 ** @param xcb_connection_t *c 1555 ** @param uint32_t screen 1556 ** @param xcb_visualid_t visual 1557 ** @param xcb_pixmap_t pixmap 1558 ** @param xcb_glx_pixmap_t glx_pixmap 1559 ** @returns xcb_void_cookie_t 1560 ** 1561 *****************************************************************************/ 1562 1563 xcb_void_cookie_t 1564 xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, 1565 uint32_t screen /**< */, 1566 xcb_visualid_t visual /**< */, 1567 xcb_pixmap_t pixmap /**< */, 1568 xcb_glx_pixmap_t glx_pixmap /**< */) 1569 { 1570 static const xcb_protocol_request_t xcb_req = { 1571 /* count */ 2, 1572 /* ext */ &xcb_glx_id, 1573 /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, 1574 /* isvoid */ 1 1575 }; 1576 1577 struct iovec xcb_parts[4]; 1578 xcb_void_cookie_t xcb_ret; 1579 xcb_glx_create_glx_pixmap_request_t xcb_out; 1580 1581 xcb_out.screen = screen; 1582 xcb_out.visual = visual; 1583 xcb_out.pixmap = pixmap; 1584 xcb_out.glx_pixmap = glx_pixmap; 1585 1586 xcb_parts[2].iov_base = (char *) &xcb_out; 1587 xcb_parts[2].iov_len = sizeof(xcb_out); 1588 xcb_parts[3].iov_base = 0; 1589 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1590 1591 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1592 return xcb_ret; 1593 } 1594 1595 1596 /***************************************************************************** 1597 ** 1598 ** xcb_void_cookie_t xcb_glx_create_glx_pixmap 1599 ** 1600 ** @param xcb_connection_t *c 1601 ** @param uint32_t screen 1602 ** @param xcb_visualid_t visual 1603 ** @param xcb_pixmap_t pixmap 1604 ** @param xcb_glx_pixmap_t glx_pixmap 1605 ** @returns xcb_void_cookie_t 1606 ** 1607 *****************************************************************************/ 1608 1609 xcb_void_cookie_t 1610 xcb_glx_create_glx_pixmap (xcb_connection_t *c /**< */, 1611 uint32_t screen /**< */, 1612 xcb_visualid_t visual /**< */, 1613 xcb_pixmap_t pixmap /**< */, 1614 xcb_glx_pixmap_t glx_pixmap /**< */) 1615 { 1616 static const xcb_protocol_request_t xcb_req = { 1617 /* count */ 2, 1618 /* ext */ &xcb_glx_id, 1619 /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, 1620 /* isvoid */ 1 1621 }; 1622 1623 struct iovec xcb_parts[4]; 1624 xcb_void_cookie_t xcb_ret; 1625 xcb_glx_create_glx_pixmap_request_t xcb_out; 1626 1627 xcb_out.screen = screen; 1628 xcb_out.visual = visual; 1629 xcb_out.pixmap = pixmap; 1630 xcb_out.glx_pixmap = glx_pixmap; 1631 1632 xcb_parts[2].iov_base = (char *) &xcb_out; 1633 xcb_parts[2].iov_len = sizeof(xcb_out); 1634 xcb_parts[3].iov_base = 0; 1635 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1636 1637 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1638 return xcb_ret; 1639 } 1640 1641 int 1642 xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */) 1643 { 1644 char *xcb_tmp = (char *)_buffer; 1645 const xcb_glx_get_visual_configs_reply_t *_aux = (xcb_glx_get_visual_configs_reply_t *)_buffer; 1646 unsigned int xcb_buffer_len = 0; 1647 unsigned int xcb_block_len = 0; 1648 unsigned int xcb_pad = 0; 1649 unsigned int xcb_align_to; 1650 1651 1652 xcb_block_len += sizeof(xcb_glx_get_visual_configs_reply_t); 1653 xcb_tmp += xcb_block_len; 1654 /* property_list */ 1655 xcb_block_len += _aux->length * sizeof(uint32_t); 1656 xcb_tmp += xcb_block_len; 1657 xcb_align_to = ALIGNOF(uint32_t); 1658 /* insert padding */ 1659 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1660 xcb_buffer_len += xcb_block_len + xcb_pad; 1661 if (0 != xcb_pad) { 1662 xcb_tmp += xcb_pad; 1663 xcb_pad = 0; 1664 } 1665 xcb_block_len = 0; 1666 1667 return xcb_buffer_len; 1668 } 1669 1670 1671 /***************************************************************************** 1672 ** 1673 ** xcb_glx_get_visual_configs_cookie_t xcb_glx_get_visual_configs 1674 ** 1675 ** @param xcb_connection_t *c 1676 ** @param uint32_t screen 1677 ** @returns xcb_glx_get_visual_configs_cookie_t 1678 ** 1679 *****************************************************************************/ 1680 1681 xcb_glx_get_visual_configs_cookie_t 1682 xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, 1683 uint32_t screen /**< */) 1684 { 1685 static const xcb_protocol_request_t xcb_req = { 1686 /* count */ 2, 1687 /* ext */ &xcb_glx_id, 1688 /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, 1689 /* isvoid */ 0 1690 }; 1691 1692 struct iovec xcb_parts[4]; 1693 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1694 xcb_glx_get_visual_configs_request_t xcb_out; 1695 1696 xcb_out.screen = screen; 1697 1698 xcb_parts[2].iov_base = (char *) &xcb_out; 1699 xcb_parts[2].iov_len = sizeof(xcb_out); 1700 xcb_parts[3].iov_base = 0; 1701 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1702 1703 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1704 return xcb_ret; 1705 } 1706 1707 1708 /***************************************************************************** 1709 ** 1710 ** xcb_glx_get_visual_configs_cookie_t xcb_glx_get_visual_configs_unchecked 1711 ** 1712 ** @param xcb_connection_t *c 1713 ** @param uint32_t screen 1714 ** @returns xcb_glx_get_visual_configs_cookie_t 1715 ** 1716 *****************************************************************************/ 1717 1718 xcb_glx_get_visual_configs_cookie_t 1719 xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c /**< */, 1720 uint32_t screen /**< */) 1721 { 1722 static const xcb_protocol_request_t xcb_req = { 1723 /* count */ 2, 1724 /* ext */ &xcb_glx_id, 1725 /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, 1726 /* isvoid */ 0 1727 }; 1728 1729 struct iovec xcb_parts[4]; 1730 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1731 xcb_glx_get_visual_configs_request_t xcb_out; 1732 1733 xcb_out.screen = screen; 1734 1735 xcb_parts[2].iov_base = (char *) &xcb_out; 1736 xcb_parts[2].iov_len = sizeof(xcb_out); 1737 xcb_parts[3].iov_base = 0; 1738 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1739 1740 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1741 return xcb_ret; 1742 } 1743 1744 1745 /***************************************************************************** 1746 ** 1747 ** uint32_t * xcb_glx_get_visual_configs_property_list 1748 ** 1749 ** @param const xcb_glx_get_visual_configs_reply_t *R 1750 ** @returns uint32_t * 1751 ** 1752 *****************************************************************************/ 1753 1754 uint32_t * 1755 xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1756 { 1757 return (uint32_t *) (R + 1); 1758 } 1759 1760 1761 /***************************************************************************** 1762 ** 1763 ** int xcb_glx_get_visual_configs_property_list_length 1764 ** 1765 ** @param const xcb_glx_get_visual_configs_reply_t *R 1766 ** @returns int 1767 ** 1768 *****************************************************************************/ 1769 1770 int 1771 xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1772 { 1773 return R->length; 1774 } 1775 1776 1777 /***************************************************************************** 1778 ** 1779 ** xcb_generic_iterator_t xcb_glx_get_visual_configs_property_list_end 1780 ** 1781 ** @param const xcb_glx_get_visual_configs_reply_t *R 1782 ** @returns xcb_generic_iterator_t 1783 ** 1784 *****************************************************************************/ 1785 1786 xcb_generic_iterator_t 1787 xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1788 { 1789 xcb_generic_iterator_t i; 1790 i.data = ((uint32_t *) (R + 1)) + (R->length); 1791 i.rem = 0; 1792 i.index = (char *) i.data - (char *) R; 1793 return i; 1794 } 1795 1796 1797 /***************************************************************************** 1798 ** 1799 ** xcb_glx_get_visual_configs_reply_t * xcb_glx_get_visual_configs_reply 1800 ** 1801 ** @param xcb_connection_t *c 1802 ** @param xcb_glx_get_visual_configs_cookie_t cookie 1803 ** @param xcb_generic_error_t **e 1804 ** @returns xcb_glx_get_visual_configs_reply_t * 1805 ** 1806 *****************************************************************************/ 1807 1808 xcb_glx_get_visual_configs_reply_t * 1809 xcb_glx_get_visual_configs_reply (xcb_connection_t *c /**< */, 1810 xcb_glx_get_visual_configs_cookie_t cookie /**< */, 1811 xcb_generic_error_t **e /**< */) 1812 { 1813 return (xcb_glx_get_visual_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1814 } 1815 1816 1817 /***************************************************************************** 1818 ** 1819 ** xcb_void_cookie_t xcb_glx_destroy_glx_pixmap_checked 1820 ** 1821 ** @param xcb_connection_t *c 1822 ** @param xcb_glx_pixmap_t glx_pixmap 1823 ** @returns xcb_void_cookie_t 1824 ** 1825 *****************************************************************************/ 1826 1827 xcb_void_cookie_t 1828 xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, 1829 xcb_glx_pixmap_t glx_pixmap /**< */) 1830 { 1831 static const xcb_protocol_request_t xcb_req = { 1832 /* count */ 2, 1833 /* ext */ &xcb_glx_id, 1834 /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, 1835 /* isvoid */ 1 1836 }; 1837 1838 struct iovec xcb_parts[4]; 1839 xcb_void_cookie_t xcb_ret; 1840 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1841 1842 xcb_out.glx_pixmap = glx_pixmap; 1843 1844 xcb_parts[2].iov_base = (char *) &xcb_out; 1845 xcb_parts[2].iov_len = sizeof(xcb_out); 1846 xcb_parts[3].iov_base = 0; 1847 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1848 1849 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1850 return xcb_ret; 1851 } 1852 1853 1854 /***************************************************************************** 1855 ** 1856 ** xcb_void_cookie_t xcb_glx_destroy_glx_pixmap 1857 ** 1858 ** @param xcb_connection_t *c 1859 ** @param xcb_glx_pixmap_t glx_pixmap 1860 ** @returns xcb_void_cookie_t 1861 ** 1862 *****************************************************************************/ 1863 1864 xcb_void_cookie_t 1865 xcb_glx_destroy_glx_pixmap (xcb_connection_t *c /**< */, 1866 xcb_glx_pixmap_t glx_pixmap /**< */) 1867 { 1868 static const xcb_protocol_request_t xcb_req = { 1869 /* count */ 2, 1870 /* ext */ &xcb_glx_id, 1871 /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, 1872 /* isvoid */ 1 1873 }; 1874 1875 struct iovec xcb_parts[4]; 1876 xcb_void_cookie_t xcb_ret; 1877 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1878 1879 xcb_out.glx_pixmap = glx_pixmap; 1880 1881 xcb_parts[2].iov_base = (char *) &xcb_out; 1882 xcb_parts[2].iov_len = sizeof(xcb_out); 1883 xcb_parts[3].iov_base = 0; 1884 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1885 1886 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1887 return xcb_ret; 1888 } 1889 1890 int 1891 xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, 1892 uint32_t data_len /**< */) 1893 { 1894 char *xcb_tmp = (char *)_buffer; 1895 unsigned int xcb_buffer_len = 0; 1896 unsigned int xcb_block_len = 0; 1897 unsigned int xcb_pad = 0; 1898 unsigned int xcb_align_to; 1899 1900 1901 xcb_block_len += sizeof(xcb_glx_vendor_private_request_t); 1902 xcb_tmp += xcb_block_len; 1903 /* data */ 1904 xcb_block_len += data_len * sizeof(uint8_t); 1905 xcb_tmp += xcb_block_len; 1906 xcb_align_to = ALIGNOF(uint8_t); 1907 /* insert padding */ 1908 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1909 xcb_buffer_len += xcb_block_len + xcb_pad; 1910 if (0 != xcb_pad) { 1911 xcb_tmp += xcb_pad; 1912 xcb_pad = 0; 1913 } 1914 xcb_block_len = 0; 1915 1916 return xcb_buffer_len; 1917 } 1918 1919 1920 /***************************************************************************** 1921 ** 1922 ** xcb_void_cookie_t xcb_glx_vendor_private_checked 1923 ** 1924 ** @param xcb_connection_t *c 1925 ** @param uint32_t vendor_code 1926 ** @param xcb_glx_context_tag_t context_tag 1927 ** @param uint32_t data_len 1928 ** @param const uint8_t *data 1929 ** @returns xcb_void_cookie_t 1930 ** 1931 *****************************************************************************/ 1932 1933 xcb_void_cookie_t 1934 xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, 1935 uint32_t vendor_code /**< */, 1936 xcb_glx_context_tag_t context_tag /**< */, 1937 uint32_t data_len /**< */, 1938 const uint8_t *data /**< */) 1939 { 1940 static const xcb_protocol_request_t xcb_req = { 1941 /* count */ 4, 1942 /* ext */ &xcb_glx_id, 1943 /* opcode */ XCB_GLX_VENDOR_PRIVATE, 1944 /* isvoid */ 1 1945 }; 1946 1947 struct iovec xcb_parts[6]; 1948 xcb_void_cookie_t xcb_ret; 1949 xcb_glx_vendor_private_request_t xcb_out; 1950 1951 xcb_out.vendor_code = vendor_code; 1952 xcb_out.context_tag = context_tag; 1953 1954 xcb_parts[2].iov_base = (char *) &xcb_out; 1955 xcb_parts[2].iov_len = sizeof(xcb_out); 1956 xcb_parts[3].iov_base = 0; 1957 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1958 /* uint8_t data */ 1959 xcb_parts[4].iov_base = (char *) data; 1960 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1961 xcb_parts[5].iov_base = 0; 1962 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1963 1964 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1965 return xcb_ret; 1966 } 1967 1968 1969 /***************************************************************************** 1970 ** 1971 ** xcb_void_cookie_t xcb_glx_vendor_private 1972 ** 1973 ** @param xcb_connection_t *c 1974 ** @param uint32_t vendor_code 1975 ** @param xcb_glx_context_tag_t context_tag 1976 ** @param uint32_t data_len 1977 ** @param const uint8_t *data 1978 ** @returns xcb_void_cookie_t 1979 ** 1980 *****************************************************************************/ 1981 1982 xcb_void_cookie_t 1983 xcb_glx_vendor_private (xcb_connection_t *c /**< */, 1984 uint32_t vendor_code /**< */, 1985 xcb_glx_context_tag_t context_tag /**< */, 1986 uint32_t data_len /**< */, 1987 const uint8_t *data /**< */) 1988 { 1989 static const xcb_protocol_request_t xcb_req = { 1990 /* count */ 4, 1991 /* ext */ &xcb_glx_id, 1992 /* opcode */ XCB_GLX_VENDOR_PRIVATE, 1993 /* isvoid */ 1 1994 }; 1995 1996 struct iovec xcb_parts[6]; 1997 xcb_void_cookie_t xcb_ret; 1998 xcb_glx_vendor_private_request_t xcb_out; 1999 2000 xcb_out.vendor_code = vendor_code; 2001 xcb_out.context_tag = context_tag; 2002 2003 xcb_parts[2].iov_base = (char *) &xcb_out; 2004 xcb_parts[2].iov_len = sizeof(xcb_out); 2005 xcb_parts[3].iov_base = 0; 2006 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2007 /* uint8_t data */ 2008 xcb_parts[4].iov_base = (char *) data; 2009 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2010 xcb_parts[5].iov_base = 0; 2011 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2012 2013 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2014 return xcb_ret; 2015 } 2016 2017 int 2018 xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, 2019 uint32_t data_len /**< */) 2020 { 2021 char *xcb_tmp = (char *)_buffer; 2022 unsigned int xcb_buffer_len = 0; 2023 unsigned int xcb_block_len = 0; 2024 unsigned int xcb_pad = 0; 2025 unsigned int xcb_align_to; 2026 2027 2028 xcb_block_len += sizeof(xcb_glx_vendor_private_with_reply_request_t); 2029 xcb_tmp += xcb_block_len; 2030 /* data */ 2031 xcb_block_len += data_len * sizeof(uint8_t); 2032 xcb_tmp += xcb_block_len; 2033 xcb_align_to = ALIGNOF(uint8_t); 2034 /* insert padding */ 2035 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2036 xcb_buffer_len += xcb_block_len + xcb_pad; 2037 if (0 != xcb_pad) { 2038 xcb_tmp += xcb_pad; 2039 xcb_pad = 0; 2040 } 2041 xcb_block_len = 0; 2042 2043 return xcb_buffer_len; 2044 } 2045 2046 2047 /***************************************************************************** 2048 ** 2049 ** xcb_glx_vendor_private_with_reply_cookie_t xcb_glx_vendor_private_with_reply 2050 ** 2051 ** @param xcb_connection_t *c 2052 ** @param uint32_t vendor_code 2053 ** @param xcb_glx_context_tag_t context_tag 2054 ** @param uint32_t data_len 2055 ** @param const uint8_t *data 2056 ** @returns xcb_glx_vendor_private_with_reply_cookie_t 2057 ** 2058 *****************************************************************************/ 2059 2060 xcb_glx_vendor_private_with_reply_cookie_t 2061 xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, 2062 uint32_t vendor_code /**< */, 2063 xcb_glx_context_tag_t context_tag /**< */, 2064 uint32_t data_len /**< */, 2065 const uint8_t *data /**< */) 2066 { 2067 static const xcb_protocol_request_t xcb_req = { 2068 /* count */ 4, 2069 /* ext */ &xcb_glx_id, 2070 /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 2071 /* isvoid */ 0 2072 }; 2073 2074 struct iovec xcb_parts[6]; 2075 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 2076 xcb_glx_vendor_private_with_reply_request_t xcb_out; 2077 2078 xcb_out.vendor_code = vendor_code; 2079 xcb_out.context_tag = context_tag; 2080 2081 xcb_parts[2].iov_base = (char *) &xcb_out; 2082 xcb_parts[2].iov_len = sizeof(xcb_out); 2083 xcb_parts[3].iov_base = 0; 2084 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2085 /* uint8_t data */ 2086 xcb_parts[4].iov_base = (char *) data; 2087 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2088 xcb_parts[5].iov_base = 0; 2089 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2090 2091 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2092 return xcb_ret; 2093 } 2094 2095 2096 /***************************************************************************** 2097 ** 2098 ** xcb_glx_vendor_private_with_reply_cookie_t xcb_glx_vendor_private_with_reply_unchecked 2099 ** 2100 ** @param xcb_connection_t *c 2101 ** @param uint32_t vendor_code 2102 ** @param xcb_glx_context_tag_t context_tag 2103 ** @param uint32_t data_len 2104 ** @param const uint8_t *data 2105 ** @returns xcb_glx_vendor_private_with_reply_cookie_t 2106 ** 2107 *****************************************************************************/ 2108 2109 xcb_glx_vendor_private_with_reply_cookie_t 2110 xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c /**< */, 2111 uint32_t vendor_code /**< */, 2112 xcb_glx_context_tag_t context_tag /**< */, 2113 uint32_t data_len /**< */, 2114 const uint8_t *data /**< */) 2115 { 2116 static const xcb_protocol_request_t xcb_req = { 2117 /* count */ 4, 2118 /* ext */ &xcb_glx_id, 2119 /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 2120 /* isvoid */ 0 2121 }; 2122 2123 struct iovec xcb_parts[6]; 2124 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 2125 xcb_glx_vendor_private_with_reply_request_t xcb_out; 2126 2127 xcb_out.vendor_code = vendor_code; 2128 xcb_out.context_tag = context_tag; 2129 2130 xcb_parts[2].iov_base = (char *) &xcb_out; 2131 xcb_parts[2].iov_len = sizeof(xcb_out); 2132 xcb_parts[3].iov_base = 0; 2133 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2134 /* uint8_t data */ 2135 xcb_parts[4].iov_base = (char *) data; 2136 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2137 xcb_parts[5].iov_base = 0; 2138 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2139 2140 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2141 return xcb_ret; 2142 } 2143 2144 2145 /***************************************************************************** 2146 ** 2147 ** uint8_t * xcb_glx_vendor_private_with_reply_data_2 2148 ** 2149 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2150 ** @returns uint8_t * 2151 ** 2152 *****************************************************************************/ 2153 2154 uint8_t * 2155 xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2156 { 2157 return (uint8_t *) (R + 1); 2158 } 2159 2160 2161 /***************************************************************************** 2162 ** 2163 ** int xcb_glx_vendor_private_with_reply_data_2_length 2164 ** 2165 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2166 ** @returns int 2167 ** 2168 *****************************************************************************/ 2169 2170 int 2171 xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2172 { 2173 return (R->length * 4); 2174 } 2175 2176 2177 /***************************************************************************** 2178 ** 2179 ** xcb_generic_iterator_t xcb_glx_vendor_private_with_reply_data_2_end 2180 ** 2181 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2182 ** @returns xcb_generic_iterator_t 2183 ** 2184 *****************************************************************************/ 2185 2186 xcb_generic_iterator_t 2187 xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2188 { 2189 xcb_generic_iterator_t i; 2190 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 2191 i.rem = 0; 2192 i.index = (char *) i.data - (char *) R; 2193 return i; 2194 } 2195 2196 2197 /***************************************************************************** 2198 ** 2199 ** xcb_glx_vendor_private_with_reply_reply_t * xcb_glx_vendor_private_with_reply_reply 2200 ** 2201 ** @param xcb_connection_t *c 2202 ** @param xcb_glx_vendor_private_with_reply_cookie_t cookie 2203 ** @param xcb_generic_error_t **e 2204 ** @returns xcb_glx_vendor_private_with_reply_reply_t * 2205 ** 2206 *****************************************************************************/ 2207 2208 xcb_glx_vendor_private_with_reply_reply_t * 2209 xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c /**< */, 2210 xcb_glx_vendor_private_with_reply_cookie_t cookie /**< */, 2211 xcb_generic_error_t **e /**< */) 2212 { 2213 return (xcb_glx_vendor_private_with_reply_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2214 } 2215 2216 2217 /***************************************************************************** 2218 ** 2219 ** xcb_glx_query_extensions_string_cookie_t xcb_glx_query_extensions_string 2220 ** 2221 ** @param xcb_connection_t *c 2222 ** @param uint32_t screen 2223 ** @returns xcb_glx_query_extensions_string_cookie_t 2224 ** 2225 *****************************************************************************/ 2226 2227 xcb_glx_query_extensions_string_cookie_t 2228 xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, 2229 uint32_t screen /**< */) 2230 { 2231 static const xcb_protocol_request_t xcb_req = { 2232 /* count */ 2, 2233 /* ext */ &xcb_glx_id, 2234 /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, 2235 /* isvoid */ 0 2236 }; 2237 2238 struct iovec xcb_parts[4]; 2239 xcb_glx_query_extensions_string_cookie_t xcb_ret; 2240 xcb_glx_query_extensions_string_request_t xcb_out; 2241 2242 xcb_out.screen = screen; 2243 2244 xcb_parts[2].iov_base = (char *) &xcb_out; 2245 xcb_parts[2].iov_len = sizeof(xcb_out); 2246 xcb_parts[3].iov_base = 0; 2247 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2248 2249 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2250 return xcb_ret; 2251 } 2252 2253 2254 /***************************************************************************** 2255 ** 2256 ** xcb_glx_query_extensions_string_cookie_t xcb_glx_query_extensions_string_unchecked 2257 ** 2258 ** @param xcb_connection_t *c 2259 ** @param uint32_t screen 2260 ** @returns xcb_glx_query_extensions_string_cookie_t 2261 ** 2262 *****************************************************************************/ 2263 2264 xcb_glx_query_extensions_string_cookie_t 2265 xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, 2266 uint32_t screen /**< */) 2267 { 2268 static const xcb_protocol_request_t xcb_req = { 2269 /* count */ 2, 2270 /* ext */ &xcb_glx_id, 2271 /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, 2272 /* isvoid */ 0 2273 }; 2274 2275 struct iovec xcb_parts[4]; 2276 xcb_glx_query_extensions_string_cookie_t xcb_ret; 2277 xcb_glx_query_extensions_string_request_t xcb_out; 2278 2279 xcb_out.screen = screen; 2280 2281 xcb_parts[2].iov_base = (char *) &xcb_out; 2282 xcb_parts[2].iov_len = sizeof(xcb_out); 2283 xcb_parts[3].iov_base = 0; 2284 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2285 2286 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2287 return xcb_ret; 2288 } 2289 2290 2291 /***************************************************************************** 2292 ** 2293 ** xcb_glx_query_extensions_string_reply_t * xcb_glx_query_extensions_string_reply 2294 ** 2295 ** @param xcb_connection_t *c 2296 ** @param xcb_glx_query_extensions_string_cookie_t cookie 2297 ** @param xcb_generic_error_t **e 2298 ** @returns xcb_glx_query_extensions_string_reply_t * 2299 ** 2300 *****************************************************************************/ 2301 2302 xcb_glx_query_extensions_string_reply_t * 2303 xcb_glx_query_extensions_string_reply (xcb_connection_t *c /**< */, 2304 xcb_glx_query_extensions_string_cookie_t cookie /**< */, 2305 xcb_generic_error_t **e /**< */) 2306 { 2307 return (xcb_glx_query_extensions_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2308 } 2309 2310 int 2311 xcb_glx_query_server_string_sizeof (const void *_buffer /**< */) 2312 { 2313 char *xcb_tmp = (char *)_buffer; 2314 const xcb_glx_query_server_string_reply_t *_aux = (xcb_glx_query_server_string_reply_t *)_buffer; 2315 unsigned int xcb_buffer_len = 0; 2316 unsigned int xcb_block_len = 0; 2317 unsigned int xcb_pad = 0; 2318 unsigned int xcb_align_to; 2319 2320 2321 xcb_block_len += sizeof(xcb_glx_query_server_string_reply_t); 2322 xcb_tmp += xcb_block_len; 2323 /* string */ 2324 xcb_block_len += _aux->str_len * sizeof(char); 2325 xcb_tmp += xcb_block_len; 2326 xcb_align_to = ALIGNOF(char); 2327 /* insert padding */ 2328 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2329 xcb_buffer_len += xcb_block_len + xcb_pad; 2330 if (0 != xcb_pad) { 2331 xcb_tmp += xcb_pad; 2332 xcb_pad = 0; 2333 } 2334 xcb_block_len = 0; 2335 2336 return xcb_buffer_len; 2337 } 2338 2339 2340 /***************************************************************************** 2341 ** 2342 ** xcb_glx_query_server_string_cookie_t xcb_glx_query_server_string 2343 ** 2344 ** @param xcb_connection_t *c 2345 ** @param uint32_t screen 2346 ** @param uint32_t name 2347 ** @returns xcb_glx_query_server_string_cookie_t 2348 ** 2349 *****************************************************************************/ 2350 2351 xcb_glx_query_server_string_cookie_t 2352 xcb_glx_query_server_string (xcb_connection_t *c /**< */, 2353 uint32_t screen /**< */, 2354 uint32_t name /**< */) 2355 { 2356 static const xcb_protocol_request_t xcb_req = { 2357 /* count */ 2, 2358 /* ext */ &xcb_glx_id, 2359 /* opcode */ XCB_GLX_QUERY_SERVER_STRING, 2360 /* isvoid */ 0 2361 }; 2362 2363 struct iovec xcb_parts[4]; 2364 xcb_glx_query_server_string_cookie_t xcb_ret; 2365 xcb_glx_query_server_string_request_t xcb_out; 2366 2367 xcb_out.screen = screen; 2368 xcb_out.name = name; 2369 2370 xcb_parts[2].iov_base = (char *) &xcb_out; 2371 xcb_parts[2].iov_len = sizeof(xcb_out); 2372 xcb_parts[3].iov_base = 0; 2373 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2374 2375 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2376 return xcb_ret; 2377 } 2378 2379 2380 /***************************************************************************** 2381 ** 2382 ** xcb_glx_query_server_string_cookie_t xcb_glx_query_server_string_unchecked 2383 ** 2384 ** @param xcb_connection_t *c 2385 ** @param uint32_t screen 2386 ** @param uint32_t name 2387 ** @returns xcb_glx_query_server_string_cookie_t 2388 ** 2389 *****************************************************************************/ 2390 2391 xcb_glx_query_server_string_cookie_t 2392 xcb_glx_query_server_string_unchecked (xcb_connection_t *c /**< */, 2393 uint32_t screen /**< */, 2394 uint32_t name /**< */) 2395 { 2396 static const xcb_protocol_request_t xcb_req = { 2397 /* count */ 2, 2398 /* ext */ &xcb_glx_id, 2399 /* opcode */ XCB_GLX_QUERY_SERVER_STRING, 2400 /* isvoid */ 0 2401 }; 2402 2403 struct iovec xcb_parts[4]; 2404 xcb_glx_query_server_string_cookie_t xcb_ret; 2405 xcb_glx_query_server_string_request_t xcb_out; 2406 2407 xcb_out.screen = screen; 2408 xcb_out.name = name; 2409 2410 xcb_parts[2].iov_base = (char *) &xcb_out; 2411 xcb_parts[2].iov_len = sizeof(xcb_out); 2412 xcb_parts[3].iov_base = 0; 2413 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2414 2415 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2416 return xcb_ret; 2417 } 2418 2419 2420 /***************************************************************************** 2421 ** 2422 ** char * xcb_glx_query_server_string_string 2423 ** 2424 ** @param const xcb_glx_query_server_string_reply_t *R 2425 ** @returns char * 2426 ** 2427 *****************************************************************************/ 2428 2429 char * 2430 xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R /**< */) 2431 { 2432 return (char *) (R + 1); 2433 } 2434 2435 2436 /***************************************************************************** 2437 ** 2438 ** int xcb_glx_query_server_string_string_length 2439 ** 2440 ** @param const xcb_glx_query_server_string_reply_t *R 2441 ** @returns int 2442 ** 2443 *****************************************************************************/ 2444 2445 int 2446 xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R /**< */) 2447 { 2448 return R->str_len; 2449 } 2450 2451 2452 /***************************************************************************** 2453 ** 2454 ** xcb_generic_iterator_t xcb_glx_query_server_string_string_end 2455 ** 2456 ** @param const xcb_glx_query_server_string_reply_t *R 2457 ** @returns xcb_generic_iterator_t 2458 ** 2459 *****************************************************************************/ 2460 2461 xcb_generic_iterator_t 2462 xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R /**< */) 2463 { 2464 xcb_generic_iterator_t i; 2465 i.data = ((char *) (R + 1)) + (R->str_len); 2466 i.rem = 0; 2467 i.index = (char *) i.data - (char *) R; 2468 return i; 2469 } 2470 2471 2472 /***************************************************************************** 2473 ** 2474 ** xcb_glx_query_server_string_reply_t * xcb_glx_query_server_string_reply 2475 ** 2476 ** @param xcb_connection_t *c 2477 ** @param xcb_glx_query_server_string_cookie_t cookie 2478 ** @param xcb_generic_error_t **e 2479 ** @returns xcb_glx_query_server_string_reply_t * 2480 ** 2481 *****************************************************************************/ 2482 2483 xcb_glx_query_server_string_reply_t * 2484 xcb_glx_query_server_string_reply (xcb_connection_t *c /**< */, 2485 xcb_glx_query_server_string_cookie_t cookie /**< */, 2486 xcb_generic_error_t **e /**< */) 2487 { 2488 return (xcb_glx_query_server_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2489 } 2490 2491 int 2492 xcb_glx_client_info_sizeof (const void *_buffer /**< */) 2493 { 2494 char *xcb_tmp = (char *)_buffer; 2495 const xcb_glx_client_info_request_t *_aux = (xcb_glx_client_info_request_t *)_buffer; 2496 unsigned int xcb_buffer_len = 0; 2497 unsigned int xcb_block_len = 0; 2498 unsigned int xcb_pad = 0; 2499 unsigned int xcb_align_to; 2500 2501 2502 xcb_block_len += sizeof(xcb_glx_client_info_request_t); 2503 xcb_tmp += xcb_block_len; 2504 /* string */ 2505 xcb_block_len += _aux->str_len * sizeof(char); 2506 xcb_tmp += xcb_block_len; 2507 xcb_align_to = ALIGNOF(char); 2508 /* insert padding */ 2509 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2510 xcb_buffer_len += xcb_block_len + xcb_pad; 2511 if (0 != xcb_pad) { 2512 xcb_tmp += xcb_pad; 2513 xcb_pad = 0; 2514 } 2515 xcb_block_len = 0; 2516 2517 return xcb_buffer_len; 2518 } 2519 2520 2521 /***************************************************************************** 2522 ** 2523 ** xcb_void_cookie_t xcb_glx_client_info_checked 2524 ** 2525 ** @param xcb_connection_t *c 2526 ** @param uint32_t major_version 2527 ** @param uint32_t minor_version 2528 ** @param uint32_t str_len 2529 ** @param const char *string 2530 ** @returns xcb_void_cookie_t 2531 ** 2532 *****************************************************************************/ 2533 2534 xcb_void_cookie_t 2535 xcb_glx_client_info_checked (xcb_connection_t *c /**< */, 2536 uint32_t major_version /**< */, 2537 uint32_t minor_version /**< */, 2538 uint32_t str_len /**< */, 2539 const char *string /**< */) 2540 { 2541 static const xcb_protocol_request_t xcb_req = { 2542 /* count */ 4, 2543 /* ext */ &xcb_glx_id, 2544 /* opcode */ XCB_GLX_CLIENT_INFO, 2545 /* isvoid */ 1 2546 }; 2547 2548 struct iovec xcb_parts[6]; 2549 xcb_void_cookie_t xcb_ret; 2550 xcb_glx_client_info_request_t xcb_out; 2551 2552 xcb_out.major_version = major_version; 2553 xcb_out.minor_version = minor_version; 2554 xcb_out.str_len = str_len; 2555 2556 xcb_parts[2].iov_base = (char *) &xcb_out; 2557 xcb_parts[2].iov_len = sizeof(xcb_out); 2558 xcb_parts[3].iov_base = 0; 2559 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2560 /* char string */ 2561 xcb_parts[4].iov_base = (char *) string; 2562 xcb_parts[4].iov_len = str_len * sizeof(char); 2563 xcb_parts[5].iov_base = 0; 2564 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2565 2566 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2567 return xcb_ret; 2568 } 2569 2570 2571 /***************************************************************************** 2572 ** 2573 ** xcb_void_cookie_t xcb_glx_client_info 2574 ** 2575 ** @param xcb_connection_t *c 2576 ** @param uint32_t major_version 2577 ** @param uint32_t minor_version 2578 ** @param uint32_t str_len 2579 ** @param const char *string 2580 ** @returns xcb_void_cookie_t 2581 ** 2582 *****************************************************************************/ 2583 2584 xcb_void_cookie_t 2585 xcb_glx_client_info (xcb_connection_t *c /**< */, 2586 uint32_t major_version /**< */, 2587 uint32_t minor_version /**< */, 2588 uint32_t str_len /**< */, 2589 const char *string /**< */) 2590 { 2591 static const xcb_protocol_request_t xcb_req = { 2592 /* count */ 4, 2593 /* ext */ &xcb_glx_id, 2594 /* opcode */ XCB_GLX_CLIENT_INFO, 2595 /* isvoid */ 1 2596 }; 2597 2598 struct iovec xcb_parts[6]; 2599 xcb_void_cookie_t xcb_ret; 2600 xcb_glx_client_info_request_t xcb_out; 2601 2602 xcb_out.major_version = major_version; 2603 xcb_out.minor_version = minor_version; 2604 xcb_out.str_len = str_len; 2605 2606 xcb_parts[2].iov_base = (char *) &xcb_out; 2607 xcb_parts[2].iov_len = sizeof(xcb_out); 2608 xcb_parts[3].iov_base = 0; 2609 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2610 /* char string */ 2611 xcb_parts[4].iov_base = (char *) string; 2612 xcb_parts[4].iov_len = str_len * sizeof(char); 2613 xcb_parts[5].iov_base = 0; 2614 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2615 2616 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2617 return xcb_ret; 2618 } 2619 2620 int 2621 xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */) 2622 { 2623 char *xcb_tmp = (char *)_buffer; 2624 const xcb_glx_get_fb_configs_reply_t *_aux = (xcb_glx_get_fb_configs_reply_t *)_buffer; 2625 unsigned int xcb_buffer_len = 0; 2626 unsigned int xcb_block_len = 0; 2627 unsigned int xcb_pad = 0; 2628 unsigned int xcb_align_to; 2629 2630 2631 xcb_block_len += sizeof(xcb_glx_get_fb_configs_reply_t); 2632 xcb_tmp += xcb_block_len; 2633 /* property_list */ 2634 xcb_block_len += _aux->length * sizeof(uint32_t); 2635 xcb_tmp += xcb_block_len; 2636 xcb_align_to = ALIGNOF(uint32_t); 2637 /* insert padding */ 2638 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2639 xcb_buffer_len += xcb_block_len + xcb_pad; 2640 if (0 != xcb_pad) { 2641 xcb_tmp += xcb_pad; 2642 xcb_pad = 0; 2643 } 2644 xcb_block_len = 0; 2645 2646 return xcb_buffer_len; 2647 } 2648 2649 2650 /***************************************************************************** 2651 ** 2652 ** xcb_glx_get_fb_configs_cookie_t xcb_glx_get_fb_configs 2653 ** 2654 ** @param xcb_connection_t *c 2655 ** @param uint32_t screen 2656 ** @returns xcb_glx_get_fb_configs_cookie_t 2657 ** 2658 *****************************************************************************/ 2659 2660 xcb_glx_get_fb_configs_cookie_t 2661 xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, 2662 uint32_t screen /**< */) 2663 { 2664 static const xcb_protocol_request_t xcb_req = { 2665 /* count */ 2, 2666 /* ext */ &xcb_glx_id, 2667 /* opcode */ XCB_GLX_GET_FB_CONFIGS, 2668 /* isvoid */ 0 2669 }; 2670 2671 struct iovec xcb_parts[4]; 2672 xcb_glx_get_fb_configs_cookie_t xcb_ret; 2673 xcb_glx_get_fb_configs_request_t xcb_out; 2674 2675 xcb_out.screen = screen; 2676 2677 xcb_parts[2].iov_base = (char *) &xcb_out; 2678 xcb_parts[2].iov_len = sizeof(xcb_out); 2679 xcb_parts[3].iov_base = 0; 2680 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2681 2682 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2683 return xcb_ret; 2684 } 2685 2686 2687 /***************************************************************************** 2688 ** 2689 ** xcb_glx_get_fb_configs_cookie_t xcb_glx_get_fb_configs_unchecked 2690 ** 2691 ** @param xcb_connection_t *c 2692 ** @param uint32_t screen 2693 ** @returns xcb_glx_get_fb_configs_cookie_t 2694 ** 2695 *****************************************************************************/ 2696 2697 xcb_glx_get_fb_configs_cookie_t 2698 xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c /**< */, 2699 uint32_t screen /**< */) 2700 { 2701 static const xcb_protocol_request_t xcb_req = { 2702 /* count */ 2, 2703 /* ext */ &xcb_glx_id, 2704 /* opcode */ XCB_GLX_GET_FB_CONFIGS, 2705 /* isvoid */ 0 2706 }; 2707 2708 struct iovec xcb_parts[4]; 2709 xcb_glx_get_fb_configs_cookie_t xcb_ret; 2710 xcb_glx_get_fb_configs_request_t xcb_out; 2711 2712 xcb_out.screen = screen; 2713 2714 xcb_parts[2].iov_base = (char *) &xcb_out; 2715 xcb_parts[2].iov_len = sizeof(xcb_out); 2716 xcb_parts[3].iov_base = 0; 2717 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2718 2719 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2720 return xcb_ret; 2721 } 2722 2723 2724 /***************************************************************************** 2725 ** 2726 ** uint32_t * xcb_glx_get_fb_configs_property_list 2727 ** 2728 ** @param const xcb_glx_get_fb_configs_reply_t *R 2729 ** @returns uint32_t * 2730 ** 2731 *****************************************************************************/ 2732 2733 uint32_t * 2734 xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2735 { 2736 return (uint32_t *) (R + 1); 2737 } 2738 2739 2740 /***************************************************************************** 2741 ** 2742 ** int xcb_glx_get_fb_configs_property_list_length 2743 ** 2744 ** @param const xcb_glx_get_fb_configs_reply_t *R 2745 ** @returns int 2746 ** 2747 *****************************************************************************/ 2748 2749 int 2750 xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2751 { 2752 return R->length; 2753 } 2754 2755 2756 /***************************************************************************** 2757 ** 2758 ** xcb_generic_iterator_t xcb_glx_get_fb_configs_property_list_end 2759 ** 2760 ** @param const xcb_glx_get_fb_configs_reply_t *R 2761 ** @returns xcb_generic_iterator_t 2762 ** 2763 *****************************************************************************/ 2764 2765 xcb_generic_iterator_t 2766 xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2767 { 2768 xcb_generic_iterator_t i; 2769 i.data = ((uint32_t *) (R + 1)) + (R->length); 2770 i.rem = 0; 2771 i.index = (char *) i.data - (char *) R; 2772 return i; 2773 } 2774 2775 2776 /***************************************************************************** 2777 ** 2778 ** xcb_glx_get_fb_configs_reply_t * xcb_glx_get_fb_configs_reply 2779 ** 2780 ** @param xcb_connection_t *c 2781 ** @param xcb_glx_get_fb_configs_cookie_t cookie 2782 ** @param xcb_generic_error_t **e 2783 ** @returns xcb_glx_get_fb_configs_reply_t * 2784 ** 2785 *****************************************************************************/ 2786 2787 xcb_glx_get_fb_configs_reply_t * 2788 xcb_glx_get_fb_configs_reply (xcb_connection_t *c /**< */, 2789 xcb_glx_get_fb_configs_cookie_t cookie /**< */, 2790 xcb_generic_error_t **e /**< */) 2791 { 2792 return (xcb_glx_get_fb_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2793 } 2794 2795 int 2796 xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */) 2797 { 2798 char *xcb_tmp = (char *)_buffer; 2799 const xcb_glx_create_pixmap_request_t *_aux = (xcb_glx_create_pixmap_request_t *)_buffer; 2800 unsigned int xcb_buffer_len = 0; 2801 unsigned int xcb_block_len = 0; 2802 unsigned int xcb_pad = 0; 2803 unsigned int xcb_align_to; 2804 2805 2806 xcb_block_len += sizeof(xcb_glx_create_pixmap_request_t); 2807 xcb_tmp += xcb_block_len; 2808 /* attribs */ 2809 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2810 xcb_tmp += xcb_block_len; 2811 xcb_align_to = ALIGNOF(uint32_t); 2812 /* insert padding */ 2813 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2814 xcb_buffer_len += xcb_block_len + xcb_pad; 2815 if (0 != xcb_pad) { 2816 xcb_tmp += xcb_pad; 2817 xcb_pad = 0; 2818 } 2819 xcb_block_len = 0; 2820 2821 return xcb_buffer_len; 2822 } 2823 2824 2825 /***************************************************************************** 2826 ** 2827 ** xcb_void_cookie_t xcb_glx_create_pixmap_checked 2828 ** 2829 ** @param xcb_connection_t *c 2830 ** @param uint32_t screen 2831 ** @param xcb_glx_fbconfig_t fbconfig 2832 ** @param xcb_pixmap_t pixmap 2833 ** @param xcb_glx_pixmap_t glx_pixmap 2834 ** @param uint32_t num_attribs 2835 ** @param const uint32_t *attribs 2836 ** @returns xcb_void_cookie_t 2837 ** 2838 *****************************************************************************/ 2839 2840 xcb_void_cookie_t 2841 xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, 2842 uint32_t screen /**< */, 2843 xcb_glx_fbconfig_t fbconfig /**< */, 2844 xcb_pixmap_t pixmap /**< */, 2845 xcb_glx_pixmap_t glx_pixmap /**< */, 2846 uint32_t num_attribs /**< */, 2847 const uint32_t *attribs /**< */) 2848 { 2849 static const xcb_protocol_request_t xcb_req = { 2850 /* count */ 4, 2851 /* ext */ &xcb_glx_id, 2852 /* opcode */ XCB_GLX_CREATE_PIXMAP, 2853 /* isvoid */ 1 2854 }; 2855 2856 struct iovec xcb_parts[6]; 2857 xcb_void_cookie_t xcb_ret; 2858 xcb_glx_create_pixmap_request_t xcb_out; 2859 2860 xcb_out.screen = screen; 2861 xcb_out.fbconfig = fbconfig; 2862 xcb_out.pixmap = pixmap; 2863 xcb_out.glx_pixmap = glx_pixmap; 2864 xcb_out.num_attribs = num_attribs; 2865 2866 xcb_parts[2].iov_base = (char *) &xcb_out; 2867 xcb_parts[2].iov_len = sizeof(xcb_out); 2868 xcb_parts[3].iov_base = 0; 2869 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2870 /* uint32_t attribs */ 2871 xcb_parts[4].iov_base = (char *) attribs; 2872 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2873 xcb_parts[5].iov_base = 0; 2874 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2875 2876 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2877 return xcb_ret; 2878 } 2879 2880 2881 /***************************************************************************** 2882 ** 2883 ** xcb_void_cookie_t xcb_glx_create_pixmap 2884 ** 2885 ** @param xcb_connection_t *c 2886 ** @param uint32_t screen 2887 ** @param xcb_glx_fbconfig_t fbconfig 2888 ** @param xcb_pixmap_t pixmap 2889 ** @param xcb_glx_pixmap_t glx_pixmap 2890 ** @param uint32_t num_attribs 2891 ** @param const uint32_t *attribs 2892 ** @returns xcb_void_cookie_t 2893 ** 2894 *****************************************************************************/ 2895 2896 xcb_void_cookie_t 2897 xcb_glx_create_pixmap (xcb_connection_t *c /**< */, 2898 uint32_t screen /**< */, 2899 xcb_glx_fbconfig_t fbconfig /**< */, 2900 xcb_pixmap_t pixmap /**< */, 2901 xcb_glx_pixmap_t glx_pixmap /**< */, 2902 uint32_t num_attribs /**< */, 2903 const uint32_t *attribs /**< */) 2904 { 2905 static const xcb_protocol_request_t xcb_req = { 2906 /* count */ 4, 2907 /* ext */ &xcb_glx_id, 2908 /* opcode */ XCB_GLX_CREATE_PIXMAP, 2909 /* isvoid */ 1 2910 }; 2911 2912 struct iovec xcb_parts[6]; 2913 xcb_void_cookie_t xcb_ret; 2914 xcb_glx_create_pixmap_request_t xcb_out; 2915 2916 xcb_out.screen = screen; 2917 xcb_out.fbconfig = fbconfig; 2918 xcb_out.pixmap = pixmap; 2919 xcb_out.glx_pixmap = glx_pixmap; 2920 xcb_out.num_attribs = num_attribs; 2921 2922 xcb_parts[2].iov_base = (char *) &xcb_out; 2923 xcb_parts[2].iov_len = sizeof(xcb_out); 2924 xcb_parts[3].iov_base = 0; 2925 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2926 /* uint32_t attribs */ 2927 xcb_parts[4].iov_base = (char *) attribs; 2928 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2929 xcb_parts[5].iov_base = 0; 2930 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2931 2932 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2933 return xcb_ret; 2934 } 2935 2936 2937 /***************************************************************************** 2938 ** 2939 ** xcb_void_cookie_t xcb_glx_destroy_pixmap_checked 2940 ** 2941 ** @param xcb_connection_t *c 2942 ** @param xcb_glx_pixmap_t glx_pixmap 2943 ** @returns xcb_void_cookie_t 2944 ** 2945 *****************************************************************************/ 2946 2947 xcb_void_cookie_t 2948 xcb_glx_destroy_pixmap_checked (xcb_connection_t *c /**< */, 2949 xcb_glx_pixmap_t glx_pixmap /**< */) 2950 { 2951 static const xcb_protocol_request_t xcb_req = { 2952 /* count */ 2, 2953 /* ext */ &xcb_glx_id, 2954 /* opcode */ XCB_GLX_DESTROY_PIXMAP, 2955 /* isvoid */ 1 2956 }; 2957 2958 struct iovec xcb_parts[4]; 2959 xcb_void_cookie_t xcb_ret; 2960 xcb_glx_destroy_pixmap_request_t xcb_out; 2961 2962 xcb_out.glx_pixmap = glx_pixmap; 2963 2964 xcb_parts[2].iov_base = (char *) &xcb_out; 2965 xcb_parts[2].iov_len = sizeof(xcb_out); 2966 xcb_parts[3].iov_base = 0; 2967 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2968 2969 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2970 return xcb_ret; 2971 } 2972 2973 2974 /***************************************************************************** 2975 ** 2976 ** xcb_void_cookie_t xcb_glx_destroy_pixmap 2977 ** 2978 ** @param xcb_connection_t *c 2979 ** @param xcb_glx_pixmap_t glx_pixmap 2980 ** @returns xcb_void_cookie_t 2981 ** 2982 *****************************************************************************/ 2983 2984 xcb_void_cookie_t 2985 xcb_glx_destroy_pixmap (xcb_connection_t *c /**< */, 2986 xcb_glx_pixmap_t glx_pixmap /**< */) 2987 { 2988 static const xcb_protocol_request_t xcb_req = { 2989 /* count */ 2, 2990 /* ext */ &xcb_glx_id, 2991 /* opcode */ XCB_GLX_DESTROY_PIXMAP, 2992 /* isvoid */ 1 2993 }; 2994 2995 struct iovec xcb_parts[4]; 2996 xcb_void_cookie_t xcb_ret; 2997 xcb_glx_destroy_pixmap_request_t xcb_out; 2998 2999 xcb_out.glx_pixmap = glx_pixmap; 3000 3001 xcb_parts[2].iov_base = (char *) &xcb_out; 3002 xcb_parts[2].iov_len = sizeof(xcb_out); 3003 xcb_parts[3].iov_base = 0; 3004 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3005 3006 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3007 return xcb_ret; 3008 } 3009 3010 3011 /***************************************************************************** 3012 ** 3013 ** xcb_void_cookie_t xcb_glx_create_new_context_checked 3014 ** 3015 ** @param xcb_connection_t *c 3016 ** @param xcb_glx_context_t context 3017 ** @param xcb_glx_fbconfig_t fbconfig 3018 ** @param uint32_t screen 3019 ** @param uint32_t render_type 3020 ** @param xcb_glx_context_t share_list 3021 ** @param uint8_t is_direct 3022 ** @returns xcb_void_cookie_t 3023 ** 3024 *****************************************************************************/ 3025 3026 xcb_void_cookie_t 3027 xcb_glx_create_new_context_checked (xcb_connection_t *c /**< */, 3028 xcb_glx_context_t context /**< */, 3029 xcb_glx_fbconfig_t fbconfig /**< */, 3030 uint32_t screen /**< */, 3031 uint32_t render_type /**< */, 3032 xcb_glx_context_t share_list /**< */, 3033 uint8_t is_direct /**< */) 3034 { 3035 static const xcb_protocol_request_t xcb_req = { 3036 /* count */ 2, 3037 /* ext */ &xcb_glx_id, 3038 /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, 3039 /* isvoid */ 1 3040 }; 3041 3042 struct iovec xcb_parts[4]; 3043 xcb_void_cookie_t xcb_ret; 3044 xcb_glx_create_new_context_request_t xcb_out; 3045 3046 xcb_out.context = context; 3047 xcb_out.fbconfig = fbconfig; 3048 xcb_out.screen = screen; 3049 xcb_out.render_type = render_type; 3050 xcb_out.share_list = share_list; 3051 xcb_out.is_direct = is_direct; 3052 memset(xcb_out.pad0, 0, 3); 3053 3054 xcb_parts[2].iov_base = (char *) &xcb_out; 3055 xcb_parts[2].iov_len = sizeof(xcb_out); 3056 xcb_parts[3].iov_base = 0; 3057 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3058 3059 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3060 return xcb_ret; 3061 } 3062 3063 3064 /***************************************************************************** 3065 ** 3066 ** xcb_void_cookie_t xcb_glx_create_new_context 3067 ** 3068 ** @param xcb_connection_t *c 3069 ** @param xcb_glx_context_t context 3070 ** @param xcb_glx_fbconfig_t fbconfig 3071 ** @param uint32_t screen 3072 ** @param uint32_t render_type 3073 ** @param xcb_glx_context_t share_list 3074 ** @param uint8_t is_direct 3075 ** @returns xcb_void_cookie_t 3076 ** 3077 *****************************************************************************/ 3078 3079 xcb_void_cookie_t 3080 xcb_glx_create_new_context (xcb_connection_t *c /**< */, 3081 xcb_glx_context_t context /**< */, 3082 xcb_glx_fbconfig_t fbconfig /**< */, 3083 uint32_t screen /**< */, 3084 uint32_t render_type /**< */, 3085 xcb_glx_context_t share_list /**< */, 3086 uint8_t is_direct /**< */) 3087 { 3088 static const xcb_protocol_request_t xcb_req = { 3089 /* count */ 2, 3090 /* ext */ &xcb_glx_id, 3091 /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, 3092 /* isvoid */ 1 3093 }; 3094 3095 struct iovec xcb_parts[4]; 3096 xcb_void_cookie_t xcb_ret; 3097 xcb_glx_create_new_context_request_t xcb_out; 3098 3099 xcb_out.context = context; 3100 xcb_out.fbconfig = fbconfig; 3101 xcb_out.screen = screen; 3102 xcb_out.render_type = render_type; 3103 xcb_out.share_list = share_list; 3104 xcb_out.is_direct = is_direct; 3105 memset(xcb_out.pad0, 0, 3); 3106 3107 xcb_parts[2].iov_base = (char *) &xcb_out; 3108 xcb_parts[2].iov_len = sizeof(xcb_out); 3109 xcb_parts[3].iov_base = 0; 3110 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3111 3112 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3113 return xcb_ret; 3114 } 3115 3116 int 3117 xcb_glx_query_context_sizeof (const void *_buffer /**< */) 3118 { 3119 char *xcb_tmp = (char *)_buffer; 3120 const xcb_glx_query_context_reply_t *_aux = (xcb_glx_query_context_reply_t *)_buffer; 3121 unsigned int xcb_buffer_len = 0; 3122 unsigned int xcb_block_len = 0; 3123 unsigned int xcb_pad = 0; 3124 unsigned int xcb_align_to; 3125 3126 3127 xcb_block_len += sizeof(xcb_glx_query_context_reply_t); 3128 xcb_tmp += xcb_block_len; 3129 /* attribs */ 3130 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3131 xcb_tmp += xcb_block_len; 3132 xcb_align_to = ALIGNOF(uint32_t); 3133 /* insert padding */ 3134 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3135 xcb_buffer_len += xcb_block_len + xcb_pad; 3136 if (0 != xcb_pad) { 3137 xcb_tmp += xcb_pad; 3138 xcb_pad = 0; 3139 } 3140 xcb_block_len = 0; 3141 3142 return xcb_buffer_len; 3143 } 3144 3145 3146 /***************************************************************************** 3147 ** 3148 ** xcb_glx_query_context_cookie_t xcb_glx_query_context 3149 ** 3150 ** @param xcb_connection_t *c 3151 ** @param xcb_glx_context_t context 3152 ** @returns xcb_glx_query_context_cookie_t 3153 ** 3154 *****************************************************************************/ 3155 3156 xcb_glx_query_context_cookie_t 3157 xcb_glx_query_context (xcb_connection_t *c /**< */, 3158 xcb_glx_context_t context /**< */) 3159 { 3160 static const xcb_protocol_request_t xcb_req = { 3161 /* count */ 2, 3162 /* ext */ &xcb_glx_id, 3163 /* opcode */ XCB_GLX_QUERY_CONTEXT, 3164 /* isvoid */ 0 3165 }; 3166 3167 struct iovec xcb_parts[4]; 3168 xcb_glx_query_context_cookie_t xcb_ret; 3169 xcb_glx_query_context_request_t xcb_out; 3170 3171 xcb_out.context = context; 3172 3173 xcb_parts[2].iov_base = (char *) &xcb_out; 3174 xcb_parts[2].iov_len = sizeof(xcb_out); 3175 xcb_parts[3].iov_base = 0; 3176 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3177 3178 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3179 return xcb_ret; 3180 } 3181 3182 3183 /***************************************************************************** 3184 ** 3185 ** xcb_glx_query_context_cookie_t xcb_glx_query_context_unchecked 3186 ** 3187 ** @param xcb_connection_t *c 3188 ** @param xcb_glx_context_t context 3189 ** @returns xcb_glx_query_context_cookie_t 3190 ** 3191 *****************************************************************************/ 3192 3193 xcb_glx_query_context_cookie_t 3194 xcb_glx_query_context_unchecked (xcb_connection_t *c /**< */, 3195 xcb_glx_context_t context /**< */) 3196 { 3197 static const xcb_protocol_request_t xcb_req = { 3198 /* count */ 2, 3199 /* ext */ &xcb_glx_id, 3200 /* opcode */ XCB_GLX_QUERY_CONTEXT, 3201 /* isvoid */ 0 3202 }; 3203 3204 struct iovec xcb_parts[4]; 3205 xcb_glx_query_context_cookie_t xcb_ret; 3206 xcb_glx_query_context_request_t xcb_out; 3207 3208 xcb_out.context = context; 3209 3210 xcb_parts[2].iov_base = (char *) &xcb_out; 3211 xcb_parts[2].iov_len = sizeof(xcb_out); 3212 xcb_parts[3].iov_base = 0; 3213 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3214 3215 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3216 return xcb_ret; 3217 } 3218 3219 3220 /***************************************************************************** 3221 ** 3222 ** uint32_t * xcb_glx_query_context_attribs 3223 ** 3224 ** @param const xcb_glx_query_context_reply_t *R 3225 ** @returns uint32_t * 3226 ** 3227 *****************************************************************************/ 3228 3229 uint32_t * 3230 xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R /**< */) 3231 { 3232 return (uint32_t *) (R + 1); 3233 } 3234 3235 3236 /***************************************************************************** 3237 ** 3238 ** int xcb_glx_query_context_attribs_length 3239 ** 3240 ** @param const xcb_glx_query_context_reply_t *R 3241 ** @returns int 3242 ** 3243 *****************************************************************************/ 3244 3245 int 3246 xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R /**< */) 3247 { 3248 return (R->num_attribs * 2); 3249 } 3250 3251 3252 /***************************************************************************** 3253 ** 3254 ** xcb_generic_iterator_t xcb_glx_query_context_attribs_end 3255 ** 3256 ** @param const xcb_glx_query_context_reply_t *R 3257 ** @returns xcb_generic_iterator_t 3258 ** 3259 *****************************************************************************/ 3260 3261 xcb_generic_iterator_t 3262 xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< */) 3263 { 3264 xcb_generic_iterator_t i; 3265 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3266 i.rem = 0; 3267 i.index = (char *) i.data - (char *) R; 3268 return i; 3269 } 3270 3271 3272 /***************************************************************************** 3273 ** 3274 ** xcb_glx_query_context_reply_t * xcb_glx_query_context_reply 3275 ** 3276 ** @param xcb_connection_t *c 3277 ** @param xcb_glx_query_context_cookie_t cookie 3278 ** @param xcb_generic_error_t **e 3279 ** @returns xcb_glx_query_context_reply_t * 3280 ** 3281 *****************************************************************************/ 3282 3283 xcb_glx_query_context_reply_t * 3284 xcb_glx_query_context_reply (xcb_connection_t *c /**< */, 3285 xcb_glx_query_context_cookie_t cookie /**< */, 3286 xcb_generic_error_t **e /**< */) 3287 { 3288 return (xcb_glx_query_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3289 } 3290 3291 3292 /***************************************************************************** 3293 ** 3294 ** xcb_glx_make_context_current_cookie_t xcb_glx_make_context_current 3295 ** 3296 ** @param xcb_connection_t *c 3297 ** @param xcb_glx_context_tag_t old_context_tag 3298 ** @param xcb_glx_drawable_t drawable 3299 ** @param xcb_glx_drawable_t read_drawable 3300 ** @param xcb_glx_context_t context 3301 ** @returns xcb_glx_make_context_current_cookie_t 3302 ** 3303 *****************************************************************************/ 3304 3305 xcb_glx_make_context_current_cookie_t 3306 xcb_glx_make_context_current (xcb_connection_t *c /**< */, 3307 xcb_glx_context_tag_t old_context_tag /**< */, 3308 xcb_glx_drawable_t drawable /**< */, 3309 xcb_glx_drawable_t read_drawable /**< */, 3310 xcb_glx_context_t context /**< */) 3311 { 3312 static const xcb_protocol_request_t xcb_req = { 3313 /* count */ 2, 3314 /* ext */ &xcb_glx_id, 3315 /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, 3316 /* isvoid */ 0 3317 }; 3318 3319 struct iovec xcb_parts[4]; 3320 xcb_glx_make_context_current_cookie_t xcb_ret; 3321 xcb_glx_make_context_current_request_t xcb_out; 3322 3323 xcb_out.old_context_tag = old_context_tag; 3324 xcb_out.drawable = drawable; 3325 xcb_out.read_drawable = read_drawable; 3326 xcb_out.context = context; 3327 3328 xcb_parts[2].iov_base = (char *) &xcb_out; 3329 xcb_parts[2].iov_len = sizeof(xcb_out); 3330 xcb_parts[3].iov_base = 0; 3331 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3332 3333 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3334 return xcb_ret; 3335 } 3336 3337 3338 /***************************************************************************** 3339 ** 3340 ** xcb_glx_make_context_current_cookie_t xcb_glx_make_context_current_unchecked 3341 ** 3342 ** @param xcb_connection_t *c 3343 ** @param xcb_glx_context_tag_t old_context_tag 3344 ** @param xcb_glx_drawable_t drawable 3345 ** @param xcb_glx_drawable_t read_drawable 3346 ** @param xcb_glx_context_t context 3347 ** @returns xcb_glx_make_context_current_cookie_t 3348 ** 3349 *****************************************************************************/ 3350 3351 xcb_glx_make_context_current_cookie_t 3352 xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, 3353 xcb_glx_context_tag_t old_context_tag /**< */, 3354 xcb_glx_drawable_t drawable /**< */, 3355 xcb_glx_drawable_t read_drawable /**< */, 3356 xcb_glx_context_t context /**< */) 3357 { 3358 static const xcb_protocol_request_t xcb_req = { 3359 /* count */ 2, 3360 /* ext */ &xcb_glx_id, 3361 /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, 3362 /* isvoid */ 0 3363 }; 3364 3365 struct iovec xcb_parts[4]; 3366 xcb_glx_make_context_current_cookie_t xcb_ret; 3367 xcb_glx_make_context_current_request_t xcb_out; 3368 3369 xcb_out.old_context_tag = old_context_tag; 3370 xcb_out.drawable = drawable; 3371 xcb_out.read_drawable = read_drawable; 3372 xcb_out.context = context; 3373 3374 xcb_parts[2].iov_base = (char *) &xcb_out; 3375 xcb_parts[2].iov_len = sizeof(xcb_out); 3376 xcb_parts[3].iov_base = 0; 3377 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3378 3379 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3380 return xcb_ret; 3381 } 3382 3383 3384 /***************************************************************************** 3385 ** 3386 ** xcb_glx_make_context_current_reply_t * xcb_glx_make_context_current_reply 3387 ** 3388 ** @param xcb_connection_t *c 3389 ** @param xcb_glx_make_context_current_cookie_t cookie 3390 ** @param xcb_generic_error_t **e 3391 ** @returns xcb_glx_make_context_current_reply_t * 3392 ** 3393 *****************************************************************************/ 3394 3395 xcb_glx_make_context_current_reply_t * 3396 xcb_glx_make_context_current_reply (xcb_connection_t *c /**< */, 3397 xcb_glx_make_context_current_cookie_t cookie /**< */, 3398 xcb_generic_error_t **e /**< */) 3399 { 3400 return (xcb_glx_make_context_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3401 } 3402 3403 int 3404 xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */) 3405 { 3406 char *xcb_tmp = (char *)_buffer; 3407 const xcb_glx_create_pbuffer_request_t *_aux = (xcb_glx_create_pbuffer_request_t *)_buffer; 3408 unsigned int xcb_buffer_len = 0; 3409 unsigned int xcb_block_len = 0; 3410 unsigned int xcb_pad = 0; 3411 unsigned int xcb_align_to; 3412 3413 3414 xcb_block_len += sizeof(xcb_glx_create_pbuffer_request_t); 3415 xcb_tmp += xcb_block_len; 3416 /* attribs */ 3417 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3418 xcb_tmp += xcb_block_len; 3419 xcb_align_to = ALIGNOF(uint32_t); 3420 /* insert padding */ 3421 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3422 xcb_buffer_len += xcb_block_len + xcb_pad; 3423 if (0 != xcb_pad) { 3424 xcb_tmp += xcb_pad; 3425 xcb_pad = 0; 3426 } 3427 xcb_block_len = 0; 3428 3429 return xcb_buffer_len; 3430 } 3431 3432 3433 /***************************************************************************** 3434 ** 3435 ** xcb_void_cookie_t xcb_glx_create_pbuffer_checked 3436 ** 3437 ** @param xcb_connection_t *c 3438 ** @param uint32_t screen 3439 ** @param xcb_glx_fbconfig_t fbconfig 3440 ** @param xcb_glx_pbuffer_t pbuffer 3441 ** @param uint32_t num_attribs 3442 ** @param const uint32_t *attribs 3443 ** @returns xcb_void_cookie_t 3444 ** 3445 *****************************************************************************/ 3446 3447 xcb_void_cookie_t 3448 xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, 3449 uint32_t screen /**< */, 3450 xcb_glx_fbconfig_t fbconfig /**< */, 3451 xcb_glx_pbuffer_t pbuffer /**< */, 3452 uint32_t num_attribs /**< */, 3453 const uint32_t *attribs /**< */) 3454 { 3455 static const xcb_protocol_request_t xcb_req = { 3456 /* count */ 4, 3457 /* ext */ &xcb_glx_id, 3458 /* opcode */ XCB_GLX_CREATE_PBUFFER, 3459 /* isvoid */ 1 3460 }; 3461 3462 struct iovec xcb_parts[6]; 3463 xcb_void_cookie_t xcb_ret; 3464 xcb_glx_create_pbuffer_request_t xcb_out; 3465 3466 xcb_out.screen = screen; 3467 xcb_out.fbconfig = fbconfig; 3468 xcb_out.pbuffer = pbuffer; 3469 xcb_out.num_attribs = num_attribs; 3470 3471 xcb_parts[2].iov_base = (char *) &xcb_out; 3472 xcb_parts[2].iov_len = sizeof(xcb_out); 3473 xcb_parts[3].iov_base = 0; 3474 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3475 /* uint32_t attribs */ 3476 xcb_parts[4].iov_base = (char *) attribs; 3477 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3478 xcb_parts[5].iov_base = 0; 3479 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3480 3481 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3482 return xcb_ret; 3483 } 3484 3485 3486 /***************************************************************************** 3487 ** 3488 ** xcb_void_cookie_t xcb_glx_create_pbuffer 3489 ** 3490 ** @param xcb_connection_t *c 3491 ** @param uint32_t screen 3492 ** @param xcb_glx_fbconfig_t fbconfig 3493 ** @param xcb_glx_pbuffer_t pbuffer 3494 ** @param uint32_t num_attribs 3495 ** @param const uint32_t *attribs 3496 ** @returns xcb_void_cookie_t 3497 ** 3498 *****************************************************************************/ 3499 3500 xcb_void_cookie_t 3501 xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, 3502 uint32_t screen /**< */, 3503 xcb_glx_fbconfig_t fbconfig /**< */, 3504 xcb_glx_pbuffer_t pbuffer /**< */, 3505 uint32_t num_attribs /**< */, 3506 const uint32_t *attribs /**< */) 3507 { 3508 static const xcb_protocol_request_t xcb_req = { 3509 /* count */ 4, 3510 /* ext */ &xcb_glx_id, 3511 /* opcode */ XCB_GLX_CREATE_PBUFFER, 3512 /* isvoid */ 1 3513 }; 3514 3515 struct iovec xcb_parts[6]; 3516 xcb_void_cookie_t xcb_ret; 3517 xcb_glx_create_pbuffer_request_t xcb_out; 3518 3519 xcb_out.screen = screen; 3520 xcb_out.fbconfig = fbconfig; 3521 xcb_out.pbuffer = pbuffer; 3522 xcb_out.num_attribs = num_attribs; 3523 3524 xcb_parts[2].iov_base = (char *) &xcb_out; 3525 xcb_parts[2].iov_len = sizeof(xcb_out); 3526 xcb_parts[3].iov_base = 0; 3527 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3528 /* uint32_t attribs */ 3529 xcb_parts[4].iov_base = (char *) attribs; 3530 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3531 xcb_parts[5].iov_base = 0; 3532 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3533 3534 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3535 return xcb_ret; 3536 } 3537 3538 3539 /***************************************************************************** 3540 ** 3541 ** xcb_void_cookie_t xcb_glx_destroy_pbuffer_checked 3542 ** 3543 ** @param xcb_connection_t *c 3544 ** @param xcb_glx_pbuffer_t pbuffer 3545 ** @returns xcb_void_cookie_t 3546 ** 3547 *****************************************************************************/ 3548 3549 xcb_void_cookie_t 3550 xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, 3551 xcb_glx_pbuffer_t pbuffer /**< */) 3552 { 3553 static const xcb_protocol_request_t xcb_req = { 3554 /* count */ 2, 3555 /* ext */ &xcb_glx_id, 3556 /* opcode */ XCB_GLX_DESTROY_PBUFFER, 3557 /* isvoid */ 1 3558 }; 3559 3560 struct iovec xcb_parts[4]; 3561 xcb_void_cookie_t xcb_ret; 3562 xcb_glx_destroy_pbuffer_request_t xcb_out; 3563 3564 xcb_out.pbuffer = pbuffer; 3565 3566 xcb_parts[2].iov_base = (char *) &xcb_out; 3567 xcb_parts[2].iov_len = sizeof(xcb_out); 3568 xcb_parts[3].iov_base = 0; 3569 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3570 3571 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3572 return xcb_ret; 3573 } 3574 3575 3576 /***************************************************************************** 3577 ** 3578 ** xcb_void_cookie_t xcb_glx_destroy_pbuffer 3579 ** 3580 ** @param xcb_connection_t *c 3581 ** @param xcb_glx_pbuffer_t pbuffer 3582 ** @returns xcb_void_cookie_t 3583 ** 3584 *****************************************************************************/ 3585 3586 xcb_void_cookie_t 3587 xcb_glx_destroy_pbuffer (xcb_connection_t *c /**< */, 3588 xcb_glx_pbuffer_t pbuffer /**< */) 3589 { 3590 static const xcb_protocol_request_t xcb_req = { 3591 /* count */ 2, 3592 /* ext */ &xcb_glx_id, 3593 /* opcode */ XCB_GLX_DESTROY_PBUFFER, 3594 /* isvoid */ 1 3595 }; 3596 3597 struct iovec xcb_parts[4]; 3598 xcb_void_cookie_t xcb_ret; 3599 xcb_glx_destroy_pbuffer_request_t xcb_out; 3600 3601 xcb_out.pbuffer = pbuffer; 3602 3603 xcb_parts[2].iov_base = (char *) &xcb_out; 3604 xcb_parts[2].iov_len = sizeof(xcb_out); 3605 xcb_parts[3].iov_base = 0; 3606 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3607 3608 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3609 return xcb_ret; 3610 } 3611 3612 int 3613 xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */) 3614 { 3615 char *xcb_tmp = (char *)_buffer; 3616 const xcb_glx_get_drawable_attributes_reply_t *_aux = (xcb_glx_get_drawable_attributes_reply_t *)_buffer; 3617 unsigned int xcb_buffer_len = 0; 3618 unsigned int xcb_block_len = 0; 3619 unsigned int xcb_pad = 0; 3620 unsigned int xcb_align_to; 3621 3622 3623 xcb_block_len += sizeof(xcb_glx_get_drawable_attributes_reply_t); 3624 xcb_tmp += xcb_block_len; 3625 /* attribs */ 3626 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3627 xcb_tmp += xcb_block_len; 3628 xcb_align_to = ALIGNOF(uint32_t); 3629 /* insert padding */ 3630 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3631 xcb_buffer_len += xcb_block_len + xcb_pad; 3632 if (0 != xcb_pad) { 3633 xcb_tmp += xcb_pad; 3634 xcb_pad = 0; 3635 } 3636 xcb_block_len = 0; 3637 3638 return xcb_buffer_len; 3639 } 3640 3641 3642 /***************************************************************************** 3643 ** 3644 ** xcb_glx_get_drawable_attributes_cookie_t xcb_glx_get_drawable_attributes 3645 ** 3646 ** @param xcb_connection_t *c 3647 ** @param xcb_glx_drawable_t drawable 3648 ** @returns xcb_glx_get_drawable_attributes_cookie_t 3649 ** 3650 *****************************************************************************/ 3651 3652 xcb_glx_get_drawable_attributes_cookie_t 3653 xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, 3654 xcb_glx_drawable_t drawable /**< */) 3655 { 3656 static const xcb_protocol_request_t xcb_req = { 3657 /* count */ 2, 3658 /* ext */ &xcb_glx_id, 3659 /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 3660 /* isvoid */ 0 3661 }; 3662 3663 struct iovec xcb_parts[4]; 3664 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 3665 xcb_glx_get_drawable_attributes_request_t xcb_out; 3666 3667 xcb_out.drawable = drawable; 3668 3669 xcb_parts[2].iov_base = (char *) &xcb_out; 3670 xcb_parts[2].iov_len = sizeof(xcb_out); 3671 xcb_parts[3].iov_base = 0; 3672 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3673 3674 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3675 return xcb_ret; 3676 } 3677 3678 3679 /***************************************************************************** 3680 ** 3681 ** xcb_glx_get_drawable_attributes_cookie_t xcb_glx_get_drawable_attributes_unchecked 3682 ** 3683 ** @param xcb_connection_t *c 3684 ** @param xcb_glx_drawable_t drawable 3685 ** @returns xcb_glx_get_drawable_attributes_cookie_t 3686 ** 3687 *****************************************************************************/ 3688 3689 xcb_glx_get_drawable_attributes_cookie_t 3690 xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c /**< */, 3691 xcb_glx_drawable_t drawable /**< */) 3692 { 3693 static const xcb_protocol_request_t xcb_req = { 3694 /* count */ 2, 3695 /* ext */ &xcb_glx_id, 3696 /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 3697 /* isvoid */ 0 3698 }; 3699 3700 struct iovec xcb_parts[4]; 3701 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 3702 xcb_glx_get_drawable_attributes_request_t xcb_out; 3703 3704 xcb_out.drawable = drawable; 3705 3706 xcb_parts[2].iov_base = (char *) &xcb_out; 3707 xcb_parts[2].iov_len = sizeof(xcb_out); 3708 xcb_parts[3].iov_base = 0; 3709 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3710 3711 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3712 return xcb_ret; 3713 } 3714 3715 3716 /***************************************************************************** 3717 ** 3718 ** uint32_t * xcb_glx_get_drawable_attributes_attribs 3719 ** 3720 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3721 ** @returns uint32_t * 3722 ** 3723 *****************************************************************************/ 3724 3725 uint32_t * 3726 xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3727 { 3728 return (uint32_t *) (R + 1); 3729 } 3730 3731 3732 /***************************************************************************** 3733 ** 3734 ** int xcb_glx_get_drawable_attributes_attribs_length 3735 ** 3736 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3737 ** @returns int 3738 ** 3739 *****************************************************************************/ 3740 3741 int 3742 xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3743 { 3744 return (R->num_attribs * 2); 3745 } 3746 3747 3748 /***************************************************************************** 3749 ** 3750 ** xcb_generic_iterator_t xcb_glx_get_drawable_attributes_attribs_end 3751 ** 3752 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3753 ** @returns xcb_generic_iterator_t 3754 ** 3755 *****************************************************************************/ 3756 3757 xcb_generic_iterator_t 3758 xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3759 { 3760 xcb_generic_iterator_t i; 3761 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3762 i.rem = 0; 3763 i.index = (char *) i.data - (char *) R; 3764 return i; 3765 } 3766 3767 3768 /***************************************************************************** 3769 ** 3770 ** xcb_glx_get_drawable_attributes_reply_t * xcb_glx_get_drawable_attributes_reply 3771 ** 3772 ** @param xcb_connection_t *c 3773 ** @param xcb_glx_get_drawable_attributes_cookie_t cookie 3774 ** @param xcb_generic_error_t **e 3775 ** @returns xcb_glx_get_drawable_attributes_reply_t * 3776 ** 3777 *****************************************************************************/ 3778 3779 xcb_glx_get_drawable_attributes_reply_t * 3780 xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c /**< */, 3781 xcb_glx_get_drawable_attributes_cookie_t cookie /**< */, 3782 xcb_generic_error_t **e /**< */) 3783 { 3784 return (xcb_glx_get_drawable_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3785 } 3786 3787 int 3788 xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */) 3789 { 3790 char *xcb_tmp = (char *)_buffer; 3791 const xcb_glx_change_drawable_attributes_request_t *_aux = (xcb_glx_change_drawable_attributes_request_t *)_buffer; 3792 unsigned int xcb_buffer_len = 0; 3793 unsigned int xcb_block_len = 0; 3794 unsigned int xcb_pad = 0; 3795 unsigned int xcb_align_to; 3796 3797 3798 xcb_block_len += sizeof(xcb_glx_change_drawable_attributes_request_t); 3799 xcb_tmp += xcb_block_len; 3800 /* attribs */ 3801 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3802 xcb_tmp += xcb_block_len; 3803 xcb_align_to = ALIGNOF(uint32_t); 3804 /* insert padding */ 3805 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3806 xcb_buffer_len += xcb_block_len + xcb_pad; 3807 if (0 != xcb_pad) { 3808 xcb_tmp += xcb_pad; 3809 xcb_pad = 0; 3810 } 3811 xcb_block_len = 0; 3812 3813 return xcb_buffer_len; 3814 } 3815 3816 3817 /***************************************************************************** 3818 ** 3819 ** xcb_void_cookie_t xcb_glx_change_drawable_attributes_checked 3820 ** 3821 ** @param xcb_connection_t *c 3822 ** @param xcb_glx_drawable_t drawable 3823 ** @param uint32_t num_attribs 3824 ** @param const uint32_t *attribs 3825 ** @returns xcb_void_cookie_t 3826 ** 3827 *****************************************************************************/ 3828 3829 xcb_void_cookie_t 3830 xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, 3831 xcb_glx_drawable_t drawable /**< */, 3832 uint32_t num_attribs /**< */, 3833 const uint32_t *attribs /**< */) 3834 { 3835 static const xcb_protocol_request_t xcb_req = { 3836 /* count */ 4, 3837 /* ext */ &xcb_glx_id, 3838 /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 3839 /* isvoid */ 1 3840 }; 3841 3842 struct iovec xcb_parts[6]; 3843 xcb_void_cookie_t xcb_ret; 3844 xcb_glx_change_drawable_attributes_request_t xcb_out; 3845 3846 xcb_out.drawable = drawable; 3847 xcb_out.num_attribs = num_attribs; 3848 3849 xcb_parts[2].iov_base = (char *) &xcb_out; 3850 xcb_parts[2].iov_len = sizeof(xcb_out); 3851 xcb_parts[3].iov_base = 0; 3852 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3853 /* uint32_t attribs */ 3854 xcb_parts[4].iov_base = (char *) attribs; 3855 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3856 xcb_parts[5].iov_base = 0; 3857 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3858 3859 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3860 return xcb_ret; 3861 } 3862 3863 3864 /***************************************************************************** 3865 ** 3866 ** xcb_void_cookie_t xcb_glx_change_drawable_attributes 3867 ** 3868 ** @param xcb_connection_t *c 3869 ** @param xcb_glx_drawable_t drawable 3870 ** @param uint32_t num_attribs 3871 ** @param const uint32_t *attribs 3872 ** @returns xcb_void_cookie_t 3873 ** 3874 *****************************************************************************/ 3875 3876 xcb_void_cookie_t 3877 xcb_glx_change_drawable_attributes (xcb_connection_t *c /**< */, 3878 xcb_glx_drawable_t drawable /**< */, 3879 uint32_t num_attribs /**< */, 3880 const uint32_t *attribs /**< */) 3881 { 3882 static const xcb_protocol_request_t xcb_req = { 3883 /* count */ 4, 3884 /* ext */ &xcb_glx_id, 3885 /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 3886 /* isvoid */ 1 3887 }; 3888 3889 struct iovec xcb_parts[6]; 3890 xcb_void_cookie_t xcb_ret; 3891 xcb_glx_change_drawable_attributes_request_t xcb_out; 3892 3893 xcb_out.drawable = drawable; 3894 xcb_out.num_attribs = num_attribs; 3895 3896 xcb_parts[2].iov_base = (char *) &xcb_out; 3897 xcb_parts[2].iov_len = sizeof(xcb_out); 3898 xcb_parts[3].iov_base = 0; 3899 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3900 /* uint32_t attribs */ 3901 xcb_parts[4].iov_base = (char *) attribs; 3902 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3903 xcb_parts[5].iov_base = 0; 3904 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3905 3906 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3907 return xcb_ret; 3908 } 3909 3910 int 3911 xcb_glx_create_window_sizeof (const void *_buffer /**< */) 3912 { 3913 char *xcb_tmp = (char *)_buffer; 3914 const xcb_glx_create_window_request_t *_aux = (xcb_glx_create_window_request_t *)_buffer; 3915 unsigned int xcb_buffer_len = 0; 3916 unsigned int xcb_block_len = 0; 3917 unsigned int xcb_pad = 0; 3918 unsigned int xcb_align_to; 3919 3920 3921 xcb_block_len += sizeof(xcb_glx_create_window_request_t); 3922 xcb_tmp += xcb_block_len; 3923 /* attribs */ 3924 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3925 xcb_tmp += xcb_block_len; 3926 xcb_align_to = ALIGNOF(uint32_t); 3927 /* insert padding */ 3928 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3929 xcb_buffer_len += xcb_block_len + xcb_pad; 3930 if (0 != xcb_pad) { 3931 xcb_tmp += xcb_pad; 3932 xcb_pad = 0; 3933 } 3934 xcb_block_len = 0; 3935 3936 return xcb_buffer_len; 3937 } 3938 3939 3940 /***************************************************************************** 3941 ** 3942 ** xcb_void_cookie_t xcb_glx_create_window_checked 3943 ** 3944 ** @param xcb_connection_t *c 3945 ** @param uint32_t screen 3946 ** @param xcb_glx_fbconfig_t fbconfig 3947 ** @param xcb_window_t window 3948 ** @param xcb_glx_window_t glx_window 3949 ** @param uint32_t num_attribs 3950 ** @param const uint32_t *attribs 3951 ** @returns xcb_void_cookie_t 3952 ** 3953 *****************************************************************************/ 3954 3955 xcb_void_cookie_t 3956 xcb_glx_create_window_checked (xcb_connection_t *c /**< */, 3957 uint32_t screen /**< */, 3958 xcb_glx_fbconfig_t fbconfig /**< */, 3959 xcb_window_t window /**< */, 3960 xcb_glx_window_t glx_window /**< */, 3961 uint32_t num_attribs /**< */, 3962 const uint32_t *attribs /**< */) 3963 { 3964 static const xcb_protocol_request_t xcb_req = { 3965 /* count */ 4, 3966 /* ext */ &xcb_glx_id, 3967 /* opcode */ XCB_GLX_CREATE_WINDOW, 3968 /* isvoid */ 1 3969 }; 3970 3971 struct iovec xcb_parts[6]; 3972 xcb_void_cookie_t xcb_ret; 3973 xcb_glx_create_window_request_t xcb_out; 3974 3975 xcb_out.screen = screen; 3976 xcb_out.fbconfig = fbconfig; 3977 xcb_out.window = window; 3978 xcb_out.glx_window = glx_window; 3979 xcb_out.num_attribs = num_attribs; 3980 3981 xcb_parts[2].iov_base = (char *) &xcb_out; 3982 xcb_parts[2].iov_len = sizeof(xcb_out); 3983 xcb_parts[3].iov_base = 0; 3984 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3985 /* uint32_t attribs */ 3986 xcb_parts[4].iov_base = (char *) attribs; 3987 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3988 xcb_parts[5].iov_base = 0; 3989 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3990 3991 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3992 return xcb_ret; 3993 } 3994 3995 3996 /***************************************************************************** 3997 ** 3998 ** xcb_void_cookie_t xcb_glx_create_window 3999 ** 4000 ** @param xcb_connection_t *c 4001 ** @param uint32_t screen 4002 ** @param xcb_glx_fbconfig_t fbconfig 4003 ** @param xcb_window_t window 4004 ** @param xcb_glx_window_t glx_window 4005 ** @param uint32_t num_attribs 4006 ** @param const uint32_t *attribs 4007 ** @returns xcb_void_cookie_t 4008 ** 4009 *****************************************************************************/ 4010 4011 xcb_void_cookie_t 4012 xcb_glx_create_window (xcb_connection_t *c /**< */, 4013 uint32_t screen /**< */, 4014 xcb_glx_fbconfig_t fbconfig /**< */, 4015 xcb_window_t window /**< */, 4016 xcb_glx_window_t glx_window /**< */, 4017 uint32_t num_attribs /**< */, 4018 const uint32_t *attribs /**< */) 4019 { 4020 static const xcb_protocol_request_t xcb_req = { 4021 /* count */ 4, 4022 /* ext */ &xcb_glx_id, 4023 /* opcode */ XCB_GLX_CREATE_WINDOW, 4024 /* isvoid */ 1 4025 }; 4026 4027 struct iovec xcb_parts[6]; 4028 xcb_void_cookie_t xcb_ret; 4029 xcb_glx_create_window_request_t xcb_out; 4030 4031 xcb_out.screen = screen; 4032 xcb_out.fbconfig = fbconfig; 4033 xcb_out.window = window; 4034 xcb_out.glx_window = glx_window; 4035 xcb_out.num_attribs = num_attribs; 4036 4037 xcb_parts[2].iov_base = (char *) &xcb_out; 4038 xcb_parts[2].iov_len = sizeof(xcb_out); 4039 xcb_parts[3].iov_base = 0; 4040 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4041 /* uint32_t attribs */ 4042 xcb_parts[4].iov_base = (char *) attribs; 4043 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4044 xcb_parts[5].iov_base = 0; 4045 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4046 4047 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4048 return xcb_ret; 4049 } 4050 4051 4052 /***************************************************************************** 4053 ** 4054 ** xcb_void_cookie_t xcb_glx_delete_window_checked 4055 ** 4056 ** @param xcb_connection_t *c 4057 ** @param xcb_glx_window_t glxwindow 4058 ** @returns xcb_void_cookie_t 4059 ** 4060 *****************************************************************************/ 4061 4062 xcb_void_cookie_t 4063 xcb_glx_delete_window_checked (xcb_connection_t *c /**< */, 4064 xcb_glx_window_t glxwindow /**< */) 4065 { 4066 static const xcb_protocol_request_t xcb_req = { 4067 /* count */ 2, 4068 /* ext */ &xcb_glx_id, 4069 /* opcode */ XCB_GLX_DELETE_WINDOW, 4070 /* isvoid */ 1 4071 }; 4072 4073 struct iovec xcb_parts[4]; 4074 xcb_void_cookie_t xcb_ret; 4075 xcb_glx_delete_window_request_t xcb_out; 4076 4077 xcb_out.glxwindow = glxwindow; 4078 4079 xcb_parts[2].iov_base = (char *) &xcb_out; 4080 xcb_parts[2].iov_len = sizeof(xcb_out); 4081 xcb_parts[3].iov_base = 0; 4082 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4083 4084 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4085 return xcb_ret; 4086 } 4087 4088 4089 /***************************************************************************** 4090 ** 4091 ** xcb_void_cookie_t xcb_glx_delete_window 4092 ** 4093 ** @param xcb_connection_t *c 4094 ** @param xcb_glx_window_t glxwindow 4095 ** @returns xcb_void_cookie_t 4096 ** 4097 *****************************************************************************/ 4098 4099 xcb_void_cookie_t 4100 xcb_glx_delete_window (xcb_connection_t *c /**< */, 4101 xcb_glx_window_t glxwindow /**< */) 4102 { 4103 static const xcb_protocol_request_t xcb_req = { 4104 /* count */ 2, 4105 /* ext */ &xcb_glx_id, 4106 /* opcode */ XCB_GLX_DELETE_WINDOW, 4107 /* isvoid */ 1 4108 }; 4109 4110 struct iovec xcb_parts[4]; 4111 xcb_void_cookie_t xcb_ret; 4112 xcb_glx_delete_window_request_t xcb_out; 4113 4114 xcb_out.glxwindow = glxwindow; 4115 4116 xcb_parts[2].iov_base = (char *) &xcb_out; 4117 xcb_parts[2].iov_len = sizeof(xcb_out); 4118 xcb_parts[3].iov_base = 0; 4119 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4120 4121 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4122 return xcb_ret; 4123 } 4124 4125 int 4126 xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */) 4127 { 4128 char *xcb_tmp = (char *)_buffer; 4129 const xcb_glx_set_client_info_arb_request_t *_aux = (xcb_glx_set_client_info_arb_request_t *)_buffer; 4130 unsigned int xcb_buffer_len = 0; 4131 unsigned int xcb_block_len = 0; 4132 unsigned int xcb_pad = 0; 4133 unsigned int xcb_align_to; 4134 4135 4136 xcb_block_len += sizeof(xcb_glx_set_client_info_arb_request_t); 4137 xcb_tmp += xcb_block_len; 4138 /* gl_versions */ 4139 xcb_block_len += (_aux->num_versions * 2) * sizeof(uint32_t); 4140 xcb_tmp += xcb_block_len; 4141 xcb_align_to = ALIGNOF(uint32_t); 4142 /* insert padding */ 4143 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4144 xcb_buffer_len += xcb_block_len + xcb_pad; 4145 if (0 != xcb_pad) { 4146 xcb_tmp += xcb_pad; 4147 xcb_pad = 0; 4148 } 4149 xcb_block_len = 0; 4150 /* gl_extension_string */ 4151 xcb_block_len += _aux->gl_str_len * sizeof(char); 4152 xcb_tmp += xcb_block_len; 4153 xcb_align_to = ALIGNOF(char); 4154 /* insert padding */ 4155 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4156 xcb_buffer_len += xcb_block_len + xcb_pad; 4157 if (0 != xcb_pad) { 4158 xcb_tmp += xcb_pad; 4159 xcb_pad = 0; 4160 } 4161 xcb_block_len = 0; 4162 /* glx_extension_string */ 4163 xcb_block_len += _aux->glx_str_len * sizeof(char); 4164 xcb_tmp += xcb_block_len; 4165 xcb_align_to = ALIGNOF(char); 4166 /* insert padding */ 4167 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4168 xcb_buffer_len += xcb_block_len + xcb_pad; 4169 if (0 != xcb_pad) { 4170 xcb_tmp += xcb_pad; 4171 xcb_pad = 0; 4172 } 4173 xcb_block_len = 0; 4174 4175 return xcb_buffer_len; 4176 } 4177 4178 4179 /***************************************************************************** 4180 ** 4181 ** xcb_void_cookie_t xcb_glx_set_client_info_arb_checked 4182 ** 4183 ** @param xcb_connection_t *c 4184 ** @param uint32_t major_version 4185 ** @param uint32_t minor_version 4186 ** @param uint32_t num_versions 4187 ** @param uint32_t gl_str_len 4188 ** @param uint32_t glx_str_len 4189 ** @param const uint32_t *gl_versions 4190 ** @param const char *gl_extension_string 4191 ** @param const char *glx_extension_string 4192 ** @returns xcb_void_cookie_t 4193 ** 4194 *****************************************************************************/ 4195 4196 xcb_void_cookie_t 4197 xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, 4198 uint32_t major_version /**< */, 4199 uint32_t minor_version /**< */, 4200 uint32_t num_versions /**< */, 4201 uint32_t gl_str_len /**< */, 4202 uint32_t glx_str_len /**< */, 4203 const uint32_t *gl_versions /**< */, 4204 const char *gl_extension_string /**< */, 4205 const char *glx_extension_string /**< */) 4206 { 4207 static const xcb_protocol_request_t xcb_req = { 4208 /* count */ 8, 4209 /* ext */ &xcb_glx_id, 4210 /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, 4211 /* isvoid */ 1 4212 }; 4213 4214 struct iovec xcb_parts[10]; 4215 xcb_void_cookie_t xcb_ret; 4216 xcb_glx_set_client_info_arb_request_t xcb_out; 4217 4218 xcb_out.major_version = major_version; 4219 xcb_out.minor_version = minor_version; 4220 xcb_out.num_versions = num_versions; 4221 xcb_out.gl_str_len = gl_str_len; 4222 xcb_out.glx_str_len = glx_str_len; 4223 4224 xcb_parts[2].iov_base = (char *) &xcb_out; 4225 xcb_parts[2].iov_len = sizeof(xcb_out); 4226 xcb_parts[3].iov_base = 0; 4227 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4228 /* uint32_t gl_versions */ 4229 xcb_parts[4].iov_base = (char *) gl_versions; 4230 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 4231 xcb_parts[5].iov_base = 0; 4232 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4233 /* char gl_extension_string */ 4234 xcb_parts[6].iov_base = (char *) gl_extension_string; 4235 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4236 xcb_parts[7].iov_base = 0; 4237 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4238 /* char glx_extension_string */ 4239 xcb_parts[8].iov_base = (char *) glx_extension_string; 4240 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4241 xcb_parts[9].iov_base = 0; 4242 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4243 4244 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4245 return xcb_ret; 4246 } 4247 4248 4249 /***************************************************************************** 4250 ** 4251 ** xcb_void_cookie_t xcb_glx_set_client_info_arb 4252 ** 4253 ** @param xcb_connection_t *c 4254 ** @param uint32_t major_version 4255 ** @param uint32_t minor_version 4256 ** @param uint32_t num_versions 4257 ** @param uint32_t gl_str_len 4258 ** @param uint32_t glx_str_len 4259 ** @param const uint32_t *gl_versions 4260 ** @param const char *gl_extension_string 4261 ** @param const char *glx_extension_string 4262 ** @returns xcb_void_cookie_t 4263 ** 4264 *****************************************************************************/ 4265 4266 xcb_void_cookie_t 4267 xcb_glx_set_client_info_arb (xcb_connection_t *c /**< */, 4268 uint32_t major_version /**< */, 4269 uint32_t minor_version /**< */, 4270 uint32_t num_versions /**< */, 4271 uint32_t gl_str_len /**< */, 4272 uint32_t glx_str_len /**< */, 4273 const uint32_t *gl_versions /**< */, 4274 const char *gl_extension_string /**< */, 4275 const char *glx_extension_string /**< */) 4276 { 4277 static const xcb_protocol_request_t xcb_req = { 4278 /* count */ 8, 4279 /* ext */ &xcb_glx_id, 4280 /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, 4281 /* isvoid */ 1 4282 }; 4283 4284 struct iovec xcb_parts[10]; 4285 xcb_void_cookie_t xcb_ret; 4286 xcb_glx_set_client_info_arb_request_t xcb_out; 4287 4288 xcb_out.major_version = major_version; 4289 xcb_out.minor_version = minor_version; 4290 xcb_out.num_versions = num_versions; 4291 xcb_out.gl_str_len = gl_str_len; 4292 xcb_out.glx_str_len = glx_str_len; 4293 4294 xcb_parts[2].iov_base = (char *) &xcb_out; 4295 xcb_parts[2].iov_len = sizeof(xcb_out); 4296 xcb_parts[3].iov_base = 0; 4297 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4298 /* uint32_t gl_versions */ 4299 xcb_parts[4].iov_base = (char *) gl_versions; 4300 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 4301 xcb_parts[5].iov_base = 0; 4302 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4303 /* char gl_extension_string */ 4304 xcb_parts[6].iov_base = (char *) gl_extension_string; 4305 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4306 xcb_parts[7].iov_base = 0; 4307 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4308 /* char glx_extension_string */ 4309 xcb_parts[8].iov_base = (char *) glx_extension_string; 4310 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4311 xcb_parts[9].iov_base = 0; 4312 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4313 4314 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4315 return xcb_ret; 4316 } 4317 4318 int 4319 xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */) 4320 { 4321 char *xcb_tmp = (char *)_buffer; 4322 const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer; 4323 unsigned int xcb_buffer_len = 0; 4324 unsigned int xcb_block_len = 0; 4325 unsigned int xcb_pad = 0; 4326 unsigned int xcb_align_to; 4327 4328 4329 xcb_block_len += sizeof(xcb_glx_create_context_attribs_arb_request_t); 4330 xcb_tmp += xcb_block_len; 4331 /* attribs */ 4332 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 4333 xcb_tmp += xcb_block_len; 4334 xcb_align_to = ALIGNOF(uint32_t); 4335 /* insert padding */ 4336 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4337 xcb_buffer_len += xcb_block_len + xcb_pad; 4338 if (0 != xcb_pad) { 4339 xcb_tmp += xcb_pad; 4340 xcb_pad = 0; 4341 } 4342 xcb_block_len = 0; 4343 4344 return xcb_buffer_len; 4345 } 4346 4347 4348 /***************************************************************************** 4349 ** 4350 ** xcb_void_cookie_t xcb_glx_create_context_attribs_arb_checked 4351 ** 4352 ** @param xcb_connection_t *c 4353 ** @param xcb_glx_context_t context 4354 ** @param xcb_glx_fbconfig_t fbconfig 4355 ** @param uint32_t screen 4356 ** @param xcb_glx_context_t share_list 4357 ** @param uint8_t is_direct 4358 ** @param uint32_t num_attribs 4359 ** @param const uint32_t *attribs 4360 ** @returns xcb_void_cookie_t 4361 ** 4362 *****************************************************************************/ 4363 4364 xcb_void_cookie_t 4365 xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, 4366 xcb_glx_context_t context /**< */, 4367 xcb_glx_fbconfig_t fbconfig /**< */, 4368 uint32_t screen /**< */, 4369 xcb_glx_context_t share_list /**< */, 4370 uint8_t is_direct /**< */, 4371 uint32_t num_attribs /**< */, 4372 const uint32_t *attribs /**< */) 4373 { 4374 static const xcb_protocol_request_t xcb_req = { 4375 /* count */ 4, 4376 /* ext */ &xcb_glx_id, 4377 /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 4378 /* isvoid */ 1 4379 }; 4380 4381 struct iovec xcb_parts[6]; 4382 xcb_void_cookie_t xcb_ret; 4383 xcb_glx_create_context_attribs_arb_request_t xcb_out; 4384 4385 xcb_out.context = context; 4386 xcb_out.fbconfig = fbconfig; 4387 xcb_out.screen = screen; 4388 xcb_out.share_list = share_list; 4389 xcb_out.is_direct = is_direct; 4390 memset(xcb_out.pad0, 0, 3); 4391 xcb_out.num_attribs = num_attribs; 4392 4393 xcb_parts[2].iov_base = (char *) &xcb_out; 4394 xcb_parts[2].iov_len = sizeof(xcb_out); 4395 xcb_parts[3].iov_base = 0; 4396 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4397 /* uint32_t attribs */ 4398 xcb_parts[4].iov_base = (char *) attribs; 4399 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4400 xcb_parts[5].iov_base = 0; 4401 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4402 4403 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4404 return xcb_ret; 4405 } 4406 4407 4408 /***************************************************************************** 4409 ** 4410 ** xcb_void_cookie_t xcb_glx_create_context_attribs_arb 4411 ** 4412 ** @param xcb_connection_t *c 4413 ** @param xcb_glx_context_t context 4414 ** @param xcb_glx_fbconfig_t fbconfig 4415 ** @param uint32_t screen 4416 ** @param xcb_glx_context_t share_list 4417 ** @param uint8_t is_direct 4418 ** @param uint32_t num_attribs 4419 ** @param const uint32_t *attribs 4420 ** @returns xcb_void_cookie_t 4421 ** 4422 *****************************************************************************/ 4423 4424 xcb_void_cookie_t 4425 xcb_glx_create_context_attribs_arb (xcb_connection_t *c /**< */, 4426 xcb_glx_context_t context /**< */, 4427 xcb_glx_fbconfig_t fbconfig /**< */, 4428 uint32_t screen /**< */, 4429 xcb_glx_context_t share_list /**< */, 4430 uint8_t is_direct /**< */, 4431 uint32_t num_attribs /**< */, 4432 const uint32_t *attribs /**< */) 4433 { 4434 static const xcb_protocol_request_t xcb_req = { 4435 /* count */ 4, 4436 /* ext */ &xcb_glx_id, 4437 /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 4438 /* isvoid */ 1 4439 }; 4440 4441 struct iovec xcb_parts[6]; 4442 xcb_void_cookie_t xcb_ret; 4443 xcb_glx_create_context_attribs_arb_request_t xcb_out; 4444 4445 xcb_out.context = context; 4446 xcb_out.fbconfig = fbconfig; 4447 xcb_out.screen = screen; 4448 xcb_out.share_list = share_list; 4449 xcb_out.is_direct = is_direct; 4450 memset(xcb_out.pad0, 0, 3); 4451 xcb_out.num_attribs = num_attribs; 4452 4453 xcb_parts[2].iov_base = (char *) &xcb_out; 4454 xcb_parts[2].iov_len = sizeof(xcb_out); 4455 xcb_parts[3].iov_base = 0; 4456 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4457 /* uint32_t attribs */ 4458 xcb_parts[4].iov_base = (char *) attribs; 4459 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4460 xcb_parts[5].iov_base = 0; 4461 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4462 4463 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4464 return xcb_ret; 4465 } 4466 4467 int 4468 xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */) 4469 { 4470 char *xcb_tmp = (char *)_buffer; 4471 const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer; 4472 unsigned int xcb_buffer_len = 0; 4473 unsigned int xcb_block_len = 0; 4474 unsigned int xcb_pad = 0; 4475 unsigned int xcb_align_to; 4476 4477 4478 xcb_block_len += sizeof(xcb_glx_set_client_info_2arb_request_t); 4479 xcb_tmp += xcb_block_len; 4480 /* gl_versions */ 4481 xcb_block_len += (_aux->num_versions * 3) * sizeof(uint32_t); 4482 xcb_tmp += xcb_block_len; 4483 xcb_align_to = ALIGNOF(uint32_t); 4484 /* insert padding */ 4485 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4486 xcb_buffer_len += xcb_block_len + xcb_pad; 4487 if (0 != xcb_pad) { 4488 xcb_tmp += xcb_pad; 4489 xcb_pad = 0; 4490 } 4491 xcb_block_len = 0; 4492 /* gl_extension_string */ 4493 xcb_block_len += _aux->gl_str_len * sizeof(char); 4494 xcb_tmp += xcb_block_len; 4495 xcb_align_to = ALIGNOF(char); 4496 /* insert padding */ 4497 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4498 xcb_buffer_len += xcb_block_len + xcb_pad; 4499 if (0 != xcb_pad) { 4500 xcb_tmp += xcb_pad; 4501 xcb_pad = 0; 4502 } 4503 xcb_block_len = 0; 4504 /* glx_extension_string */ 4505 xcb_block_len += _aux->glx_str_len * sizeof(char); 4506 xcb_tmp += xcb_block_len; 4507 xcb_align_to = ALIGNOF(char); 4508 /* insert padding */ 4509 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4510 xcb_buffer_len += xcb_block_len + xcb_pad; 4511 if (0 != xcb_pad) { 4512 xcb_tmp += xcb_pad; 4513 xcb_pad = 0; 4514 } 4515 xcb_block_len = 0; 4516 4517 return xcb_buffer_len; 4518 } 4519 4520 4521 /***************************************************************************** 4522 ** 4523 ** xcb_void_cookie_t xcb_glx_set_client_info_2arb_checked 4524 ** 4525 ** @param xcb_connection_t *c 4526 ** @param uint32_t major_version 4527 ** @param uint32_t minor_version 4528 ** @param uint32_t num_versions 4529 ** @param uint32_t gl_str_len 4530 ** @param uint32_t glx_str_len 4531 ** @param const uint32_t *gl_versions 4532 ** @param const char *gl_extension_string 4533 ** @param const char *glx_extension_string 4534 ** @returns xcb_void_cookie_t 4535 ** 4536 *****************************************************************************/ 4537 4538 xcb_void_cookie_t 4539 xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, 4540 uint32_t major_version /**< */, 4541 uint32_t minor_version /**< */, 4542 uint32_t num_versions /**< */, 4543 uint32_t gl_str_len /**< */, 4544 uint32_t glx_str_len /**< */, 4545 const uint32_t *gl_versions /**< */, 4546 const char *gl_extension_string /**< */, 4547 const char *glx_extension_string /**< */) 4548 { 4549 static const xcb_protocol_request_t xcb_req = { 4550 /* count */ 8, 4551 /* ext */ &xcb_glx_id, 4552 /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, 4553 /* isvoid */ 1 4554 }; 4555 4556 struct iovec xcb_parts[10]; 4557 xcb_void_cookie_t xcb_ret; 4558 xcb_glx_set_client_info_2arb_request_t xcb_out; 4559 4560 xcb_out.major_version = major_version; 4561 xcb_out.minor_version = minor_version; 4562 xcb_out.num_versions = num_versions; 4563 xcb_out.gl_str_len = gl_str_len; 4564 xcb_out.glx_str_len = glx_str_len; 4565 4566 xcb_parts[2].iov_base = (char *) &xcb_out; 4567 xcb_parts[2].iov_len = sizeof(xcb_out); 4568 xcb_parts[3].iov_base = 0; 4569 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4570 /* uint32_t gl_versions */ 4571 xcb_parts[4].iov_base = (char *) gl_versions; 4572 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 4573 xcb_parts[5].iov_base = 0; 4574 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4575 /* char gl_extension_string */ 4576 xcb_parts[6].iov_base = (char *) gl_extension_string; 4577 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4578 xcb_parts[7].iov_base = 0; 4579 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4580 /* char glx_extension_string */ 4581 xcb_parts[8].iov_base = (char *) glx_extension_string; 4582 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4583 xcb_parts[9].iov_base = 0; 4584 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4585 4586 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4587 return xcb_ret; 4588 } 4589 4590 4591 /***************************************************************************** 4592 ** 4593 ** xcb_void_cookie_t xcb_glx_set_client_info_2arb 4594 ** 4595 ** @param xcb_connection_t *c 4596 ** @param uint32_t major_version 4597 ** @param uint32_t minor_version 4598 ** @param uint32_t num_versions 4599 ** @param uint32_t gl_str_len 4600 ** @param uint32_t glx_str_len 4601 ** @param const uint32_t *gl_versions 4602 ** @param const char *gl_extension_string 4603 ** @param const char *glx_extension_string 4604 ** @returns xcb_void_cookie_t 4605 ** 4606 *****************************************************************************/ 4607 4608 xcb_void_cookie_t 4609 xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, 4610 uint32_t major_version /**< */, 4611 uint32_t minor_version /**< */, 4612 uint32_t num_versions /**< */, 4613 uint32_t gl_str_len /**< */, 4614 uint32_t glx_str_len /**< */, 4615 const uint32_t *gl_versions /**< */, 4616 const char *gl_extension_string /**< */, 4617 const char *glx_extension_string /**< */) 4618 { 4619 static const xcb_protocol_request_t xcb_req = { 4620 /* count */ 8, 4621 /* ext */ &xcb_glx_id, 4622 /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, 4623 /* isvoid */ 1 4624 }; 4625 4626 struct iovec xcb_parts[10]; 4627 xcb_void_cookie_t xcb_ret; 4628 xcb_glx_set_client_info_2arb_request_t xcb_out; 4629 4630 xcb_out.major_version = major_version; 4631 xcb_out.minor_version = minor_version; 4632 xcb_out.num_versions = num_versions; 4633 xcb_out.gl_str_len = gl_str_len; 4634 xcb_out.glx_str_len = glx_str_len; 4635 4636 xcb_parts[2].iov_base = (char *) &xcb_out; 4637 xcb_parts[2].iov_len = sizeof(xcb_out); 4638 xcb_parts[3].iov_base = 0; 4639 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4640 /* uint32_t gl_versions */ 4641 xcb_parts[4].iov_base = (char *) gl_versions; 4642 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 4643 xcb_parts[5].iov_base = 0; 4644 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4645 /* char gl_extension_string */ 4646 xcb_parts[6].iov_base = (char *) gl_extension_string; 4647 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4648 xcb_parts[7].iov_base = 0; 4649 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4650 /* char glx_extension_string */ 4651 xcb_parts[8].iov_base = (char *) glx_extension_string; 4652 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4653 xcb_parts[9].iov_base = 0; 4654 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4655 4656 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4657 return xcb_ret; 4658 } 4659 4660 4661 /***************************************************************************** 4662 ** 4663 ** xcb_void_cookie_t xcb_glx_new_list_checked 4664 ** 4665 ** @param xcb_connection_t *c 4666 ** @param xcb_glx_context_tag_t context_tag 4667 ** @param uint32_t list 4668 ** @param uint32_t mode 4669 ** @returns xcb_void_cookie_t 4670 ** 4671 *****************************************************************************/ 4672 4673 xcb_void_cookie_t 4674 xcb_glx_new_list_checked (xcb_connection_t *c /**< */, 4675 xcb_glx_context_tag_t context_tag /**< */, 4676 uint32_t list /**< */, 4677 uint32_t mode /**< */) 4678 { 4679 static const xcb_protocol_request_t xcb_req = { 4680 /* count */ 2, 4681 /* ext */ &xcb_glx_id, 4682 /* opcode */ XCB_GLX_NEW_LIST, 4683 /* isvoid */ 1 4684 }; 4685 4686 struct iovec xcb_parts[4]; 4687 xcb_void_cookie_t xcb_ret; 4688 xcb_glx_new_list_request_t xcb_out; 4689 4690 xcb_out.context_tag = context_tag; 4691 xcb_out.list = list; 4692 xcb_out.mode = mode; 4693 4694 xcb_parts[2].iov_base = (char *) &xcb_out; 4695 xcb_parts[2].iov_len = sizeof(xcb_out); 4696 xcb_parts[3].iov_base = 0; 4697 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4698 4699 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4700 return xcb_ret; 4701 } 4702 4703 4704 /***************************************************************************** 4705 ** 4706 ** xcb_void_cookie_t xcb_glx_new_list 4707 ** 4708 ** @param xcb_connection_t *c 4709 ** @param xcb_glx_context_tag_t context_tag 4710 ** @param uint32_t list 4711 ** @param uint32_t mode 4712 ** @returns xcb_void_cookie_t 4713 ** 4714 *****************************************************************************/ 4715 4716 xcb_void_cookie_t 4717 xcb_glx_new_list (xcb_connection_t *c /**< */, 4718 xcb_glx_context_tag_t context_tag /**< */, 4719 uint32_t list /**< */, 4720 uint32_t mode /**< */) 4721 { 4722 static const xcb_protocol_request_t xcb_req = { 4723 /* count */ 2, 4724 /* ext */ &xcb_glx_id, 4725 /* opcode */ XCB_GLX_NEW_LIST, 4726 /* isvoid */ 1 4727 }; 4728 4729 struct iovec xcb_parts[4]; 4730 xcb_void_cookie_t xcb_ret; 4731 xcb_glx_new_list_request_t xcb_out; 4732 4733 xcb_out.context_tag = context_tag; 4734 xcb_out.list = list; 4735 xcb_out.mode = mode; 4736 4737 xcb_parts[2].iov_base = (char *) &xcb_out; 4738 xcb_parts[2].iov_len = sizeof(xcb_out); 4739 xcb_parts[3].iov_base = 0; 4740 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4741 4742 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4743 return xcb_ret; 4744 } 4745 4746 4747 /***************************************************************************** 4748 ** 4749 ** xcb_void_cookie_t xcb_glx_end_list_checked 4750 ** 4751 ** @param xcb_connection_t *c 4752 ** @param xcb_glx_context_tag_t context_tag 4753 ** @returns xcb_void_cookie_t 4754 ** 4755 *****************************************************************************/ 4756 4757 xcb_void_cookie_t 4758 xcb_glx_end_list_checked (xcb_connection_t *c /**< */, 4759 xcb_glx_context_tag_t context_tag /**< */) 4760 { 4761 static const xcb_protocol_request_t xcb_req = { 4762 /* count */ 2, 4763 /* ext */ &xcb_glx_id, 4764 /* opcode */ XCB_GLX_END_LIST, 4765 /* isvoid */ 1 4766 }; 4767 4768 struct iovec xcb_parts[4]; 4769 xcb_void_cookie_t xcb_ret; 4770 xcb_glx_end_list_request_t xcb_out; 4771 4772 xcb_out.context_tag = context_tag; 4773 4774 xcb_parts[2].iov_base = (char *) &xcb_out; 4775 xcb_parts[2].iov_len = sizeof(xcb_out); 4776 xcb_parts[3].iov_base = 0; 4777 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4778 4779 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4780 return xcb_ret; 4781 } 4782 4783 4784 /***************************************************************************** 4785 ** 4786 ** xcb_void_cookie_t xcb_glx_end_list 4787 ** 4788 ** @param xcb_connection_t *c 4789 ** @param xcb_glx_context_tag_t context_tag 4790 ** @returns xcb_void_cookie_t 4791 ** 4792 *****************************************************************************/ 4793 4794 xcb_void_cookie_t 4795 xcb_glx_end_list (xcb_connection_t *c /**< */, 4796 xcb_glx_context_tag_t context_tag /**< */) 4797 { 4798 static const xcb_protocol_request_t xcb_req = { 4799 /* count */ 2, 4800 /* ext */ &xcb_glx_id, 4801 /* opcode */ XCB_GLX_END_LIST, 4802 /* isvoid */ 1 4803 }; 4804 4805 struct iovec xcb_parts[4]; 4806 xcb_void_cookie_t xcb_ret; 4807 xcb_glx_end_list_request_t xcb_out; 4808 4809 xcb_out.context_tag = context_tag; 4810 4811 xcb_parts[2].iov_base = (char *) &xcb_out; 4812 xcb_parts[2].iov_len = sizeof(xcb_out); 4813 xcb_parts[3].iov_base = 0; 4814 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4815 4816 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4817 return xcb_ret; 4818 } 4819 4820 4821 /***************************************************************************** 4822 ** 4823 ** xcb_void_cookie_t xcb_glx_delete_lists_checked 4824 ** 4825 ** @param xcb_connection_t *c 4826 ** @param xcb_glx_context_tag_t context_tag 4827 ** @param uint32_t list 4828 ** @param int32_t range 4829 ** @returns xcb_void_cookie_t 4830 ** 4831 *****************************************************************************/ 4832 4833 xcb_void_cookie_t 4834 xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, 4835 xcb_glx_context_tag_t context_tag /**< */, 4836 uint32_t list /**< */, 4837 int32_t range /**< */) 4838 { 4839 static const xcb_protocol_request_t xcb_req = { 4840 /* count */ 2, 4841 /* ext */ &xcb_glx_id, 4842 /* opcode */ XCB_GLX_DELETE_LISTS, 4843 /* isvoid */ 1 4844 }; 4845 4846 struct iovec xcb_parts[4]; 4847 xcb_void_cookie_t xcb_ret; 4848 xcb_glx_delete_lists_request_t xcb_out; 4849 4850 xcb_out.context_tag = context_tag; 4851 xcb_out.list = list; 4852 xcb_out.range = range; 4853 4854 xcb_parts[2].iov_base = (char *) &xcb_out; 4855 xcb_parts[2].iov_len = sizeof(xcb_out); 4856 xcb_parts[3].iov_base = 0; 4857 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4858 4859 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4860 return xcb_ret; 4861 } 4862 4863 4864 /***************************************************************************** 4865 ** 4866 ** xcb_void_cookie_t xcb_glx_delete_lists 4867 ** 4868 ** @param xcb_connection_t *c 4869 ** @param xcb_glx_context_tag_t context_tag 4870 ** @param uint32_t list 4871 ** @param int32_t range 4872 ** @returns xcb_void_cookie_t 4873 ** 4874 *****************************************************************************/ 4875 4876 xcb_void_cookie_t 4877 xcb_glx_delete_lists (xcb_connection_t *c /**< */, 4878 xcb_glx_context_tag_t context_tag /**< */, 4879 uint32_t list /**< */, 4880 int32_t range /**< */) 4881 { 4882 static const xcb_protocol_request_t xcb_req = { 4883 /* count */ 2, 4884 /* ext */ &xcb_glx_id, 4885 /* opcode */ XCB_GLX_DELETE_LISTS, 4886 /* isvoid */ 1 4887 }; 4888 4889 struct iovec xcb_parts[4]; 4890 xcb_void_cookie_t xcb_ret; 4891 xcb_glx_delete_lists_request_t xcb_out; 4892 4893 xcb_out.context_tag = context_tag; 4894 xcb_out.list = list; 4895 xcb_out.range = range; 4896 4897 xcb_parts[2].iov_base = (char *) &xcb_out; 4898 xcb_parts[2].iov_len = sizeof(xcb_out); 4899 xcb_parts[3].iov_base = 0; 4900 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4901 4902 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4903 return xcb_ret; 4904 } 4905 4906 4907 /***************************************************************************** 4908 ** 4909 ** xcb_glx_gen_lists_cookie_t xcb_glx_gen_lists 4910 ** 4911 ** @param xcb_connection_t *c 4912 ** @param xcb_glx_context_tag_t context_tag 4913 ** @param int32_t range 4914 ** @returns xcb_glx_gen_lists_cookie_t 4915 ** 4916 *****************************************************************************/ 4917 4918 xcb_glx_gen_lists_cookie_t 4919 xcb_glx_gen_lists (xcb_connection_t *c /**< */, 4920 xcb_glx_context_tag_t context_tag /**< */, 4921 int32_t range /**< */) 4922 { 4923 static const xcb_protocol_request_t xcb_req = { 4924 /* count */ 2, 4925 /* ext */ &xcb_glx_id, 4926 /* opcode */ XCB_GLX_GEN_LISTS, 4927 /* isvoid */ 0 4928 }; 4929 4930 struct iovec xcb_parts[4]; 4931 xcb_glx_gen_lists_cookie_t xcb_ret; 4932 xcb_glx_gen_lists_request_t xcb_out; 4933 4934 xcb_out.context_tag = context_tag; 4935 xcb_out.range = range; 4936 4937 xcb_parts[2].iov_base = (char *) &xcb_out; 4938 xcb_parts[2].iov_len = sizeof(xcb_out); 4939 xcb_parts[3].iov_base = 0; 4940 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4941 4942 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4943 return xcb_ret; 4944 } 4945 4946 4947 /***************************************************************************** 4948 ** 4949 ** xcb_glx_gen_lists_cookie_t xcb_glx_gen_lists_unchecked 4950 ** 4951 ** @param xcb_connection_t *c 4952 ** @param xcb_glx_context_tag_t context_tag 4953 ** @param int32_t range 4954 ** @returns xcb_glx_gen_lists_cookie_t 4955 ** 4956 *****************************************************************************/ 4957 4958 xcb_glx_gen_lists_cookie_t 4959 xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, 4960 xcb_glx_context_tag_t context_tag /**< */, 4961 int32_t range /**< */) 4962 { 4963 static const xcb_protocol_request_t xcb_req = { 4964 /* count */ 2, 4965 /* ext */ &xcb_glx_id, 4966 /* opcode */ XCB_GLX_GEN_LISTS, 4967 /* isvoid */ 0 4968 }; 4969 4970 struct iovec xcb_parts[4]; 4971 xcb_glx_gen_lists_cookie_t xcb_ret; 4972 xcb_glx_gen_lists_request_t xcb_out; 4973 4974 xcb_out.context_tag = context_tag; 4975 xcb_out.range = range; 4976 4977 xcb_parts[2].iov_base = (char *) &xcb_out; 4978 xcb_parts[2].iov_len = sizeof(xcb_out); 4979 xcb_parts[3].iov_base = 0; 4980 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4981 4982 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4983 return xcb_ret; 4984 } 4985 4986 4987 /***************************************************************************** 4988 ** 4989 ** xcb_glx_gen_lists_reply_t * xcb_glx_gen_lists_reply 4990 ** 4991 ** @param xcb_connection_t *c 4992 ** @param xcb_glx_gen_lists_cookie_t cookie 4993 ** @param xcb_generic_error_t **e 4994 ** @returns xcb_glx_gen_lists_reply_t * 4995 ** 4996 *****************************************************************************/ 4997 4998 xcb_glx_gen_lists_reply_t * 4999 xcb_glx_gen_lists_reply (xcb_connection_t *c /**< */, 5000 xcb_glx_gen_lists_cookie_t cookie /**< */, 5001 xcb_generic_error_t **e /**< */) 5002 { 5003 return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5004 } 5005 5006 5007 /***************************************************************************** 5008 ** 5009 ** xcb_void_cookie_t xcb_glx_feedback_buffer_checked 5010 ** 5011 ** @param xcb_connection_t *c 5012 ** @param xcb_glx_context_tag_t context_tag 5013 ** @param int32_t size 5014 ** @param int32_t type 5015 ** @returns xcb_void_cookie_t 5016 ** 5017 *****************************************************************************/ 5018 5019 xcb_void_cookie_t 5020 xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, 5021 xcb_glx_context_tag_t context_tag /**< */, 5022 int32_t size /**< */, 5023 int32_t type /**< */) 5024 { 5025 static const xcb_protocol_request_t xcb_req = { 5026 /* count */ 2, 5027 /* ext */ &xcb_glx_id, 5028 /* opcode */ XCB_GLX_FEEDBACK_BUFFER, 5029 /* isvoid */ 1 5030 }; 5031 5032 struct iovec xcb_parts[4]; 5033 xcb_void_cookie_t xcb_ret; 5034 xcb_glx_feedback_buffer_request_t xcb_out; 5035 5036 xcb_out.context_tag = context_tag; 5037 xcb_out.size = size; 5038 xcb_out.type = type; 5039 5040 xcb_parts[2].iov_base = (char *) &xcb_out; 5041 xcb_parts[2].iov_len = sizeof(xcb_out); 5042 xcb_parts[3].iov_base = 0; 5043 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5044 5045 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5046 return xcb_ret; 5047 } 5048 5049 5050 /***************************************************************************** 5051 ** 5052 ** xcb_void_cookie_t xcb_glx_feedback_buffer 5053 ** 5054 ** @param xcb_connection_t *c 5055 ** @param xcb_glx_context_tag_t context_tag 5056 ** @param int32_t size 5057 ** @param int32_t type 5058 ** @returns xcb_void_cookie_t 5059 ** 5060 *****************************************************************************/ 5061 5062 xcb_void_cookie_t 5063 xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, 5064 xcb_glx_context_tag_t context_tag /**< */, 5065 int32_t size /**< */, 5066 int32_t type /**< */) 5067 { 5068 static const xcb_protocol_request_t xcb_req = { 5069 /* count */ 2, 5070 /* ext */ &xcb_glx_id, 5071 /* opcode */ XCB_GLX_FEEDBACK_BUFFER, 5072 /* isvoid */ 1 5073 }; 5074 5075 struct iovec xcb_parts[4]; 5076 xcb_void_cookie_t xcb_ret; 5077 xcb_glx_feedback_buffer_request_t xcb_out; 5078 5079 xcb_out.context_tag = context_tag; 5080 xcb_out.size = size; 5081 xcb_out.type = type; 5082 5083 xcb_parts[2].iov_base = (char *) &xcb_out; 5084 xcb_parts[2].iov_len = sizeof(xcb_out); 5085 xcb_parts[3].iov_base = 0; 5086 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5087 5088 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5089 return xcb_ret; 5090 } 5091 5092 5093 /***************************************************************************** 5094 ** 5095 ** xcb_void_cookie_t xcb_glx_select_buffer_checked 5096 ** 5097 ** @param xcb_connection_t *c 5098 ** @param xcb_glx_context_tag_t context_tag 5099 ** @param int32_t size 5100 ** @returns xcb_void_cookie_t 5101 ** 5102 *****************************************************************************/ 5103 5104 xcb_void_cookie_t 5105 xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, 5106 xcb_glx_context_tag_t context_tag /**< */, 5107 int32_t size /**< */) 5108 { 5109 static const xcb_protocol_request_t xcb_req = { 5110 /* count */ 2, 5111 /* ext */ &xcb_glx_id, 5112 /* opcode */ XCB_GLX_SELECT_BUFFER, 5113 /* isvoid */ 1 5114 }; 5115 5116 struct iovec xcb_parts[4]; 5117 xcb_void_cookie_t xcb_ret; 5118 xcb_glx_select_buffer_request_t xcb_out; 5119 5120 xcb_out.context_tag = context_tag; 5121 xcb_out.size = size; 5122 5123 xcb_parts[2].iov_base = (char *) &xcb_out; 5124 xcb_parts[2].iov_len = sizeof(xcb_out); 5125 xcb_parts[3].iov_base = 0; 5126 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5127 5128 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5129 return xcb_ret; 5130 } 5131 5132 5133 /***************************************************************************** 5134 ** 5135 ** xcb_void_cookie_t xcb_glx_select_buffer 5136 ** 5137 ** @param xcb_connection_t *c 5138 ** @param xcb_glx_context_tag_t context_tag 5139 ** @param int32_t size 5140 ** @returns xcb_void_cookie_t 5141 ** 5142 *****************************************************************************/ 5143 5144 xcb_void_cookie_t 5145 xcb_glx_select_buffer (xcb_connection_t *c /**< */, 5146 xcb_glx_context_tag_t context_tag /**< */, 5147 int32_t size /**< */) 5148 { 5149 static const xcb_protocol_request_t xcb_req = { 5150 /* count */ 2, 5151 /* ext */ &xcb_glx_id, 5152 /* opcode */ XCB_GLX_SELECT_BUFFER, 5153 /* isvoid */ 1 5154 }; 5155 5156 struct iovec xcb_parts[4]; 5157 xcb_void_cookie_t xcb_ret; 5158 xcb_glx_select_buffer_request_t xcb_out; 5159 5160 xcb_out.context_tag = context_tag; 5161 xcb_out.size = size; 5162 5163 xcb_parts[2].iov_base = (char *) &xcb_out; 5164 xcb_parts[2].iov_len = sizeof(xcb_out); 5165 xcb_parts[3].iov_base = 0; 5166 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5167 5168 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5169 return xcb_ret; 5170 } 5171 5172 int 5173 xcb_glx_render_mode_sizeof (const void *_buffer /**< */) 5174 { 5175 char *xcb_tmp = (char *)_buffer; 5176 const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer; 5177 unsigned int xcb_buffer_len = 0; 5178 unsigned int xcb_block_len = 0; 5179 unsigned int xcb_pad = 0; 5180 unsigned int xcb_align_to; 5181 5182 5183 xcb_block_len += sizeof(xcb_glx_render_mode_reply_t); 5184 xcb_tmp += xcb_block_len; 5185 /* data */ 5186 xcb_block_len += _aux->n * sizeof(uint32_t); 5187 xcb_tmp += xcb_block_len; 5188 xcb_align_to = ALIGNOF(uint32_t); 5189 /* insert padding */ 5190 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5191 xcb_buffer_len += xcb_block_len + xcb_pad; 5192 if (0 != xcb_pad) { 5193 xcb_tmp += xcb_pad; 5194 xcb_pad = 0; 5195 } 5196 xcb_block_len = 0; 5197 5198 return xcb_buffer_len; 5199 } 5200 5201 5202 /***************************************************************************** 5203 ** 5204 ** xcb_glx_render_mode_cookie_t xcb_glx_render_mode 5205 ** 5206 ** @param xcb_connection_t *c 5207 ** @param xcb_glx_context_tag_t context_tag 5208 ** @param uint32_t mode 5209 ** @returns xcb_glx_render_mode_cookie_t 5210 ** 5211 *****************************************************************************/ 5212 5213 xcb_glx_render_mode_cookie_t 5214 xcb_glx_render_mode (xcb_connection_t *c /**< */, 5215 xcb_glx_context_tag_t context_tag /**< */, 5216 uint32_t mode /**< */) 5217 { 5218 static const xcb_protocol_request_t xcb_req = { 5219 /* count */ 2, 5220 /* ext */ &xcb_glx_id, 5221 /* opcode */ XCB_GLX_RENDER_MODE, 5222 /* isvoid */ 0 5223 }; 5224 5225 struct iovec xcb_parts[4]; 5226 xcb_glx_render_mode_cookie_t xcb_ret; 5227 xcb_glx_render_mode_request_t xcb_out; 5228 5229 xcb_out.context_tag = context_tag; 5230 xcb_out.mode = mode; 5231 5232 xcb_parts[2].iov_base = (char *) &xcb_out; 5233 xcb_parts[2].iov_len = sizeof(xcb_out); 5234 xcb_parts[3].iov_base = 0; 5235 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5236 5237 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5238 return xcb_ret; 5239 } 5240 5241 5242 /***************************************************************************** 5243 ** 5244 ** xcb_glx_render_mode_cookie_t xcb_glx_render_mode_unchecked 5245 ** 5246 ** @param xcb_connection_t *c 5247 ** @param xcb_glx_context_tag_t context_tag 5248 ** @param uint32_t mode 5249 ** @returns xcb_glx_render_mode_cookie_t 5250 ** 5251 *****************************************************************************/ 5252 5253 xcb_glx_render_mode_cookie_t 5254 xcb_glx_render_mode_unchecked (xcb_connection_t *c /**< */, 5255 xcb_glx_context_tag_t context_tag /**< */, 5256 uint32_t mode /**< */) 5257 { 5258 static const xcb_protocol_request_t xcb_req = { 5259 /* count */ 2, 5260 /* ext */ &xcb_glx_id, 5261 /* opcode */ XCB_GLX_RENDER_MODE, 5262 /* isvoid */ 0 5263 }; 5264 5265 struct iovec xcb_parts[4]; 5266 xcb_glx_render_mode_cookie_t xcb_ret; 5267 xcb_glx_render_mode_request_t xcb_out; 5268 5269 xcb_out.context_tag = context_tag; 5270 xcb_out.mode = mode; 5271 5272 xcb_parts[2].iov_base = (char *) &xcb_out; 5273 xcb_parts[2].iov_len = sizeof(xcb_out); 5274 xcb_parts[3].iov_base = 0; 5275 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5276 5277 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5278 return xcb_ret; 5279 } 5280 5281 5282 /***************************************************************************** 5283 ** 5284 ** uint32_t * xcb_glx_render_mode_data 5285 ** 5286 ** @param const xcb_glx_render_mode_reply_t *R 5287 ** @returns uint32_t * 5288 ** 5289 *****************************************************************************/ 5290 5291 uint32_t * 5292 xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R /**< */) 5293 { 5294 return (uint32_t *) (R + 1); 5295 } 5296 5297 5298 /***************************************************************************** 5299 ** 5300 ** int xcb_glx_render_mode_data_length 5301 ** 5302 ** @param const xcb_glx_render_mode_reply_t *R 5303 ** @returns int 5304 ** 5305 *****************************************************************************/ 5306 5307 int 5308 xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R /**< */) 5309 { 5310 return R->n; 5311 } 5312 5313 5314 /***************************************************************************** 5315 ** 5316 ** xcb_generic_iterator_t xcb_glx_render_mode_data_end 5317 ** 5318 ** @param const xcb_glx_render_mode_reply_t *R 5319 ** @returns xcb_generic_iterator_t 5320 ** 5321 *****************************************************************************/ 5322 5323 xcb_generic_iterator_t 5324 xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */) 5325 { 5326 xcb_generic_iterator_t i; 5327 i.data = ((uint32_t *) (R + 1)) + (R->n); 5328 i.rem = 0; 5329 i.index = (char *) i.data - (char *) R; 5330 return i; 5331 } 5332 5333 5334 /***************************************************************************** 5335 ** 5336 ** xcb_glx_render_mode_reply_t * xcb_glx_render_mode_reply 5337 ** 5338 ** @param xcb_connection_t *c 5339 ** @param xcb_glx_render_mode_cookie_t cookie 5340 ** @param xcb_generic_error_t **e 5341 ** @returns xcb_glx_render_mode_reply_t * 5342 ** 5343 *****************************************************************************/ 5344 5345 xcb_glx_render_mode_reply_t * 5346 xcb_glx_render_mode_reply (xcb_connection_t *c /**< */, 5347 xcb_glx_render_mode_cookie_t cookie /**< */, 5348 xcb_generic_error_t **e /**< */) 5349 { 5350 return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5351 } 5352 5353 5354 /***************************************************************************** 5355 ** 5356 ** xcb_glx_finish_cookie_t xcb_glx_finish 5357 ** 5358 ** @param xcb_connection_t *c 5359 ** @param xcb_glx_context_tag_t context_tag 5360 ** @returns xcb_glx_finish_cookie_t 5361 ** 5362 *****************************************************************************/ 5363 5364 xcb_glx_finish_cookie_t 5365 xcb_glx_finish (xcb_connection_t *c /**< */, 5366 xcb_glx_context_tag_t context_tag /**< */) 5367 { 5368 static const xcb_protocol_request_t xcb_req = { 5369 /* count */ 2, 5370 /* ext */ &xcb_glx_id, 5371 /* opcode */ XCB_GLX_FINISH, 5372 /* isvoid */ 0 5373 }; 5374 5375 struct iovec xcb_parts[4]; 5376 xcb_glx_finish_cookie_t xcb_ret; 5377 xcb_glx_finish_request_t xcb_out; 5378 5379 xcb_out.context_tag = context_tag; 5380 5381 xcb_parts[2].iov_base = (char *) &xcb_out; 5382 xcb_parts[2].iov_len = sizeof(xcb_out); 5383 xcb_parts[3].iov_base = 0; 5384 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5385 5386 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5387 return xcb_ret; 5388 } 5389 5390 5391 /***************************************************************************** 5392 ** 5393 ** xcb_glx_finish_cookie_t xcb_glx_finish_unchecked 5394 ** 5395 ** @param xcb_connection_t *c 5396 ** @param xcb_glx_context_tag_t context_tag 5397 ** @returns xcb_glx_finish_cookie_t 5398 ** 5399 *****************************************************************************/ 5400 5401 xcb_glx_finish_cookie_t 5402 xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, 5403 xcb_glx_context_tag_t context_tag /**< */) 5404 { 5405 static const xcb_protocol_request_t xcb_req = { 5406 /* count */ 2, 5407 /* ext */ &xcb_glx_id, 5408 /* opcode */ XCB_GLX_FINISH, 5409 /* isvoid */ 0 5410 }; 5411 5412 struct iovec xcb_parts[4]; 5413 xcb_glx_finish_cookie_t xcb_ret; 5414 xcb_glx_finish_request_t xcb_out; 5415 5416 xcb_out.context_tag = context_tag; 5417 5418 xcb_parts[2].iov_base = (char *) &xcb_out; 5419 xcb_parts[2].iov_len = sizeof(xcb_out); 5420 xcb_parts[3].iov_base = 0; 5421 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5422 5423 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5424 return xcb_ret; 5425 } 5426 5427 5428 /***************************************************************************** 5429 ** 5430 ** xcb_glx_finish_reply_t * xcb_glx_finish_reply 5431 ** 5432 ** @param xcb_connection_t *c 5433 ** @param xcb_glx_finish_cookie_t cookie 5434 ** @param xcb_generic_error_t **e 5435 ** @returns xcb_glx_finish_reply_t * 5436 ** 5437 *****************************************************************************/ 5438 5439 xcb_glx_finish_reply_t * 5440 xcb_glx_finish_reply (xcb_connection_t *c /**< */, 5441 xcb_glx_finish_cookie_t cookie /**< */, 5442 xcb_generic_error_t **e /**< */) 5443 { 5444 return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5445 } 5446 5447 5448 /***************************************************************************** 5449 ** 5450 ** xcb_void_cookie_t xcb_glx_pixel_storef_checked 5451 ** 5452 ** @param xcb_connection_t *c 5453 ** @param xcb_glx_context_tag_t context_tag 5454 ** @param uint32_t pname 5455 ** @param xcb_glx_float32_t datum 5456 ** @returns xcb_void_cookie_t 5457 ** 5458 *****************************************************************************/ 5459 5460 xcb_void_cookie_t 5461 xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, 5462 xcb_glx_context_tag_t context_tag /**< */, 5463 uint32_t pname /**< */, 5464 xcb_glx_float32_t datum /**< */) 5465 { 5466 static const xcb_protocol_request_t xcb_req = { 5467 /* count */ 2, 5468 /* ext */ &xcb_glx_id, 5469 /* opcode */ XCB_GLX_PIXEL_STOREF, 5470 /* isvoid */ 1 5471 }; 5472 5473 struct iovec xcb_parts[4]; 5474 xcb_void_cookie_t xcb_ret; 5475 xcb_glx_pixel_storef_request_t xcb_out; 5476 5477 xcb_out.context_tag = context_tag; 5478 xcb_out.pname = pname; 5479 xcb_out.datum = datum; 5480 5481 xcb_parts[2].iov_base = (char *) &xcb_out; 5482 xcb_parts[2].iov_len = sizeof(xcb_out); 5483 xcb_parts[3].iov_base = 0; 5484 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5485 5486 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5487 return xcb_ret; 5488 } 5489 5490 5491 /***************************************************************************** 5492 ** 5493 ** xcb_void_cookie_t xcb_glx_pixel_storef 5494 ** 5495 ** @param xcb_connection_t *c 5496 ** @param xcb_glx_context_tag_t context_tag 5497 ** @param uint32_t pname 5498 ** @param xcb_glx_float32_t datum 5499 ** @returns xcb_void_cookie_t 5500 ** 5501 *****************************************************************************/ 5502 5503 xcb_void_cookie_t 5504 xcb_glx_pixel_storef (xcb_connection_t *c /**< */, 5505 xcb_glx_context_tag_t context_tag /**< */, 5506 uint32_t pname /**< */, 5507 xcb_glx_float32_t datum /**< */) 5508 { 5509 static const xcb_protocol_request_t xcb_req = { 5510 /* count */ 2, 5511 /* ext */ &xcb_glx_id, 5512 /* opcode */ XCB_GLX_PIXEL_STOREF, 5513 /* isvoid */ 1 5514 }; 5515 5516 struct iovec xcb_parts[4]; 5517 xcb_void_cookie_t xcb_ret; 5518 xcb_glx_pixel_storef_request_t xcb_out; 5519 5520 xcb_out.context_tag = context_tag; 5521 xcb_out.pname = pname; 5522 xcb_out.datum = datum; 5523 5524 xcb_parts[2].iov_base = (char *) &xcb_out; 5525 xcb_parts[2].iov_len = sizeof(xcb_out); 5526 xcb_parts[3].iov_base = 0; 5527 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5528 5529 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5530 return xcb_ret; 5531 } 5532 5533 5534 /***************************************************************************** 5535 ** 5536 ** xcb_void_cookie_t xcb_glx_pixel_storei_checked 5537 ** 5538 ** @param xcb_connection_t *c 5539 ** @param xcb_glx_context_tag_t context_tag 5540 ** @param uint32_t pname 5541 ** @param int32_t datum 5542 ** @returns xcb_void_cookie_t 5543 ** 5544 *****************************************************************************/ 5545 5546 xcb_void_cookie_t 5547 xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, 5548 xcb_glx_context_tag_t context_tag /**< */, 5549 uint32_t pname /**< */, 5550 int32_t datum /**< */) 5551 { 5552 static const xcb_protocol_request_t xcb_req = { 5553 /* count */ 2, 5554 /* ext */ &xcb_glx_id, 5555 /* opcode */ XCB_GLX_PIXEL_STOREI, 5556 /* isvoid */ 1 5557 }; 5558 5559 struct iovec xcb_parts[4]; 5560 xcb_void_cookie_t xcb_ret; 5561 xcb_glx_pixel_storei_request_t xcb_out; 5562 5563 xcb_out.context_tag = context_tag; 5564 xcb_out.pname = pname; 5565 xcb_out.datum = datum; 5566 5567 xcb_parts[2].iov_base = (char *) &xcb_out; 5568 xcb_parts[2].iov_len = sizeof(xcb_out); 5569 xcb_parts[3].iov_base = 0; 5570 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5571 5572 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5573 return xcb_ret; 5574 } 5575 5576 5577 /***************************************************************************** 5578 ** 5579 ** xcb_void_cookie_t xcb_glx_pixel_storei 5580 ** 5581 ** @param xcb_connection_t *c 5582 ** @param xcb_glx_context_tag_t context_tag 5583 ** @param uint32_t pname 5584 ** @param int32_t datum 5585 ** @returns xcb_void_cookie_t 5586 ** 5587 *****************************************************************************/ 5588 5589 xcb_void_cookie_t 5590 xcb_glx_pixel_storei (xcb_connection_t *c /**< */, 5591 xcb_glx_context_tag_t context_tag /**< */, 5592 uint32_t pname /**< */, 5593 int32_t datum /**< */) 5594 { 5595 static const xcb_protocol_request_t xcb_req = { 5596 /* count */ 2, 5597 /* ext */ &xcb_glx_id, 5598 /* opcode */ XCB_GLX_PIXEL_STOREI, 5599 /* isvoid */ 1 5600 }; 5601 5602 struct iovec xcb_parts[4]; 5603 xcb_void_cookie_t xcb_ret; 5604 xcb_glx_pixel_storei_request_t xcb_out; 5605 5606 xcb_out.context_tag = context_tag; 5607 xcb_out.pname = pname; 5608 xcb_out.datum = datum; 5609 5610 xcb_parts[2].iov_base = (char *) &xcb_out; 5611 xcb_parts[2].iov_len = sizeof(xcb_out); 5612 xcb_parts[3].iov_base = 0; 5613 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5614 5615 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5616 return xcb_ret; 5617 } 5618 5619 int 5620 xcb_glx_read_pixels_sizeof (const void *_buffer /**< */) 5621 { 5622 char *xcb_tmp = (char *)_buffer; 5623 const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer; 5624 unsigned int xcb_buffer_len = 0; 5625 unsigned int xcb_block_len = 0; 5626 unsigned int xcb_pad = 0; 5627 unsigned int xcb_align_to; 5628 5629 5630 xcb_block_len += sizeof(xcb_glx_read_pixels_reply_t); 5631 xcb_tmp += xcb_block_len; 5632 /* data */ 5633 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 5634 xcb_tmp += xcb_block_len; 5635 xcb_align_to = ALIGNOF(uint8_t); 5636 /* insert padding */ 5637 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5638 xcb_buffer_len += xcb_block_len + xcb_pad; 5639 if (0 != xcb_pad) { 5640 xcb_tmp += xcb_pad; 5641 xcb_pad = 0; 5642 } 5643 xcb_block_len = 0; 5644 5645 return xcb_buffer_len; 5646 } 5647 5648 5649 /***************************************************************************** 5650 ** 5651 ** xcb_glx_read_pixels_cookie_t xcb_glx_read_pixels 5652 ** 5653 ** @param xcb_connection_t *c 5654 ** @param xcb_glx_context_tag_t context_tag 5655 ** @param int32_t x 5656 ** @param int32_t y 5657 ** @param int32_t width 5658 ** @param int32_t height 5659 ** @param uint32_t format 5660 ** @param uint32_t type 5661 ** @param uint8_t swap_bytes 5662 ** @param uint8_t lsb_first 5663 ** @returns xcb_glx_read_pixels_cookie_t 5664 ** 5665 *****************************************************************************/ 5666 5667 xcb_glx_read_pixels_cookie_t 5668 xcb_glx_read_pixels (xcb_connection_t *c /**< */, 5669 xcb_glx_context_tag_t context_tag /**< */, 5670 int32_t x /**< */, 5671 int32_t y /**< */, 5672 int32_t width /**< */, 5673 int32_t height /**< */, 5674 uint32_t format /**< */, 5675 uint32_t type /**< */, 5676 uint8_t swap_bytes /**< */, 5677 uint8_t lsb_first /**< */) 5678 { 5679 static const xcb_protocol_request_t xcb_req = { 5680 /* count */ 2, 5681 /* ext */ &xcb_glx_id, 5682 /* opcode */ XCB_GLX_READ_PIXELS, 5683 /* isvoid */ 0 5684 }; 5685 5686 struct iovec xcb_parts[4]; 5687 xcb_glx_read_pixels_cookie_t xcb_ret; 5688 xcb_glx_read_pixels_request_t xcb_out; 5689 5690 xcb_out.context_tag = context_tag; 5691 xcb_out.x = x; 5692 xcb_out.y = y; 5693 xcb_out.width = width; 5694 xcb_out.height = height; 5695 xcb_out.format = format; 5696 xcb_out.type = type; 5697 xcb_out.swap_bytes = swap_bytes; 5698 xcb_out.lsb_first = lsb_first; 5699 5700 xcb_parts[2].iov_base = (char *) &xcb_out; 5701 xcb_parts[2].iov_len = sizeof(xcb_out); 5702 xcb_parts[3].iov_base = 0; 5703 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5704 5705 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5706 return xcb_ret; 5707 } 5708 5709 5710 /***************************************************************************** 5711 ** 5712 ** xcb_glx_read_pixels_cookie_t xcb_glx_read_pixels_unchecked 5713 ** 5714 ** @param xcb_connection_t *c 5715 ** @param xcb_glx_context_tag_t context_tag 5716 ** @param int32_t x 5717 ** @param int32_t y 5718 ** @param int32_t width 5719 ** @param int32_t height 5720 ** @param uint32_t format 5721 ** @param uint32_t type 5722 ** @param uint8_t swap_bytes 5723 ** @param uint8_t lsb_first 5724 ** @returns xcb_glx_read_pixels_cookie_t 5725 ** 5726 *****************************************************************************/ 5727 5728 xcb_glx_read_pixels_cookie_t 5729 xcb_glx_read_pixels_unchecked (xcb_connection_t *c /**< */, 5730 xcb_glx_context_tag_t context_tag /**< */, 5731 int32_t x /**< */, 5732 int32_t y /**< */, 5733 int32_t width /**< */, 5734 int32_t height /**< */, 5735 uint32_t format /**< */, 5736 uint32_t type /**< */, 5737 uint8_t swap_bytes /**< */, 5738 uint8_t lsb_first /**< */) 5739 { 5740 static const xcb_protocol_request_t xcb_req = { 5741 /* count */ 2, 5742 /* ext */ &xcb_glx_id, 5743 /* opcode */ XCB_GLX_READ_PIXELS, 5744 /* isvoid */ 0 5745 }; 5746 5747 struct iovec xcb_parts[4]; 5748 xcb_glx_read_pixels_cookie_t xcb_ret; 5749 xcb_glx_read_pixels_request_t xcb_out; 5750 5751 xcb_out.context_tag = context_tag; 5752 xcb_out.x = x; 5753 xcb_out.y = y; 5754 xcb_out.width = width; 5755 xcb_out.height = height; 5756 xcb_out.format = format; 5757 xcb_out.type = type; 5758 xcb_out.swap_bytes = swap_bytes; 5759 xcb_out.lsb_first = lsb_first; 5760 5761 xcb_parts[2].iov_base = (char *) &xcb_out; 5762 xcb_parts[2].iov_len = sizeof(xcb_out); 5763 xcb_parts[3].iov_base = 0; 5764 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5765 5766 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5767 return xcb_ret; 5768 } 5769 5770 5771 /***************************************************************************** 5772 ** 5773 ** uint8_t * xcb_glx_read_pixels_data 5774 ** 5775 ** @param const xcb_glx_read_pixels_reply_t *R 5776 ** @returns uint8_t * 5777 ** 5778 *****************************************************************************/ 5779 5780 uint8_t * 5781 xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R /**< */) 5782 { 5783 return (uint8_t *) (R + 1); 5784 } 5785 5786 5787 /***************************************************************************** 5788 ** 5789 ** int xcb_glx_read_pixels_data_length 5790 ** 5791 ** @param const xcb_glx_read_pixels_reply_t *R 5792 ** @returns int 5793 ** 5794 *****************************************************************************/ 5795 5796 int 5797 xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R /**< */) 5798 { 5799 return (R->length * 4); 5800 } 5801 5802 5803 /***************************************************************************** 5804 ** 5805 ** xcb_generic_iterator_t xcb_glx_read_pixels_data_end 5806 ** 5807 ** @param const xcb_glx_read_pixels_reply_t *R 5808 ** @returns xcb_generic_iterator_t 5809 ** 5810 *****************************************************************************/ 5811 5812 xcb_generic_iterator_t 5813 xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */) 5814 { 5815 xcb_generic_iterator_t i; 5816 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 5817 i.rem = 0; 5818 i.index = (char *) i.data - (char *) R; 5819 return i; 5820 } 5821 5822 5823 /***************************************************************************** 5824 ** 5825 ** xcb_glx_read_pixels_reply_t * xcb_glx_read_pixels_reply 5826 ** 5827 ** @param xcb_connection_t *c 5828 ** @param xcb_glx_read_pixels_cookie_t cookie 5829 ** @param xcb_generic_error_t **e 5830 ** @returns xcb_glx_read_pixels_reply_t * 5831 ** 5832 *****************************************************************************/ 5833 5834 xcb_glx_read_pixels_reply_t * 5835 xcb_glx_read_pixels_reply (xcb_connection_t *c /**< */, 5836 xcb_glx_read_pixels_cookie_t cookie /**< */, 5837 xcb_generic_error_t **e /**< */) 5838 { 5839 return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5840 } 5841 5842 int 5843 xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */) 5844 { 5845 char *xcb_tmp = (char *)_buffer; 5846 const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer; 5847 unsigned int xcb_buffer_len = 0; 5848 unsigned int xcb_block_len = 0; 5849 unsigned int xcb_pad = 0; 5850 unsigned int xcb_align_to; 5851 5852 5853 xcb_block_len += sizeof(xcb_glx_get_booleanv_reply_t); 5854 xcb_tmp += xcb_block_len; 5855 /* data */ 5856 xcb_block_len += _aux->n * sizeof(uint8_t); 5857 xcb_tmp += xcb_block_len; 5858 xcb_align_to = ALIGNOF(uint8_t); 5859 /* insert padding */ 5860 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5861 xcb_buffer_len += xcb_block_len + xcb_pad; 5862 if (0 != xcb_pad) { 5863 xcb_tmp += xcb_pad; 5864 xcb_pad = 0; 5865 } 5866 xcb_block_len = 0; 5867 5868 return xcb_buffer_len; 5869 } 5870 5871 5872 /***************************************************************************** 5873 ** 5874 ** xcb_glx_get_booleanv_cookie_t xcb_glx_get_booleanv 5875 ** 5876 ** @param xcb_connection_t *c 5877 ** @param xcb_glx_context_tag_t context_tag 5878 ** @param int32_t pname 5879 ** @returns xcb_glx_get_booleanv_cookie_t 5880 ** 5881 *****************************************************************************/ 5882 5883 xcb_glx_get_booleanv_cookie_t 5884 xcb_glx_get_booleanv (xcb_connection_t *c /**< */, 5885 xcb_glx_context_tag_t context_tag /**< */, 5886 int32_t pname /**< */) 5887 { 5888 static const xcb_protocol_request_t xcb_req = { 5889 /* count */ 2, 5890 /* ext */ &xcb_glx_id, 5891 /* opcode */ XCB_GLX_GET_BOOLEANV, 5892 /* isvoid */ 0 5893 }; 5894 5895 struct iovec xcb_parts[4]; 5896 xcb_glx_get_booleanv_cookie_t xcb_ret; 5897 xcb_glx_get_booleanv_request_t xcb_out; 5898 5899 xcb_out.context_tag = context_tag; 5900 xcb_out.pname = pname; 5901 5902 xcb_parts[2].iov_base = (char *) &xcb_out; 5903 xcb_parts[2].iov_len = sizeof(xcb_out); 5904 xcb_parts[3].iov_base = 0; 5905 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5906 5907 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5908 return xcb_ret; 5909 } 5910 5911 5912 /***************************************************************************** 5913 ** 5914 ** xcb_glx_get_booleanv_cookie_t xcb_glx_get_booleanv_unchecked 5915 ** 5916 ** @param xcb_connection_t *c 5917 ** @param xcb_glx_context_tag_t context_tag 5918 ** @param int32_t pname 5919 ** @returns xcb_glx_get_booleanv_cookie_t 5920 ** 5921 *****************************************************************************/ 5922 5923 xcb_glx_get_booleanv_cookie_t 5924 xcb_glx_get_booleanv_unchecked (xcb_connection_t *c /**< */, 5925 xcb_glx_context_tag_t context_tag /**< */, 5926 int32_t pname /**< */) 5927 { 5928 static const xcb_protocol_request_t xcb_req = { 5929 /* count */ 2, 5930 /* ext */ &xcb_glx_id, 5931 /* opcode */ XCB_GLX_GET_BOOLEANV, 5932 /* isvoid */ 0 5933 }; 5934 5935 struct iovec xcb_parts[4]; 5936 xcb_glx_get_booleanv_cookie_t xcb_ret; 5937 xcb_glx_get_booleanv_request_t xcb_out; 5938 5939 xcb_out.context_tag = context_tag; 5940 xcb_out.pname = pname; 5941 5942 xcb_parts[2].iov_base = (char *) &xcb_out; 5943 xcb_parts[2].iov_len = sizeof(xcb_out); 5944 xcb_parts[3].iov_base = 0; 5945 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5946 5947 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5948 return xcb_ret; 5949 } 5950 5951 5952 /***************************************************************************** 5953 ** 5954 ** uint8_t * xcb_glx_get_booleanv_data 5955 ** 5956 ** @param const xcb_glx_get_booleanv_reply_t *R 5957 ** @returns uint8_t * 5958 ** 5959 *****************************************************************************/ 5960 5961 uint8_t * 5962 xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R /**< */) 5963 { 5964 return (uint8_t *) (R + 1); 5965 } 5966 5967 5968 /***************************************************************************** 5969 ** 5970 ** int xcb_glx_get_booleanv_data_length 5971 ** 5972 ** @param const xcb_glx_get_booleanv_reply_t *R 5973 ** @returns int 5974 ** 5975 *****************************************************************************/ 5976 5977 int 5978 xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R /**< */) 5979 { 5980 return R->n; 5981 } 5982 5983 5984 /***************************************************************************** 5985 ** 5986 ** xcb_generic_iterator_t xcb_glx_get_booleanv_data_end 5987 ** 5988 ** @param const xcb_glx_get_booleanv_reply_t *R 5989 ** @returns xcb_generic_iterator_t 5990 ** 5991 *****************************************************************************/ 5992 5993 xcb_generic_iterator_t 5994 xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */) 5995 { 5996 xcb_generic_iterator_t i; 5997 i.data = ((uint8_t *) (R + 1)) + (R->n); 5998 i.rem = 0; 5999 i.index = (char *) i.data - (char *) R; 6000 return i; 6001 } 6002 6003 6004 /***************************************************************************** 6005 ** 6006 ** xcb_glx_get_booleanv_reply_t * xcb_glx_get_booleanv_reply 6007 ** 6008 ** @param xcb_connection_t *c 6009 ** @param xcb_glx_get_booleanv_cookie_t cookie 6010 ** @param xcb_generic_error_t **e 6011 ** @returns xcb_glx_get_booleanv_reply_t * 6012 ** 6013 *****************************************************************************/ 6014 6015 xcb_glx_get_booleanv_reply_t * 6016 xcb_glx_get_booleanv_reply (xcb_connection_t *c /**< */, 6017 xcb_glx_get_booleanv_cookie_t cookie /**< */, 6018 xcb_generic_error_t **e /**< */) 6019 { 6020 return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6021 } 6022 6023 int 6024 xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */) 6025 { 6026 char *xcb_tmp = (char *)_buffer; 6027 const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer; 6028 unsigned int xcb_buffer_len = 0; 6029 unsigned int xcb_block_len = 0; 6030 unsigned int xcb_pad = 0; 6031 unsigned int xcb_align_to; 6032 6033 6034 xcb_block_len += sizeof(xcb_glx_get_clip_plane_reply_t); 6035 xcb_tmp += xcb_block_len; 6036 /* data */ 6037 xcb_block_len += (_aux->length / 2) * sizeof(xcb_glx_float64_t); 6038 xcb_tmp += xcb_block_len; 6039 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6040 /* insert padding */ 6041 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6042 xcb_buffer_len += xcb_block_len + xcb_pad; 6043 if (0 != xcb_pad) { 6044 xcb_tmp += xcb_pad; 6045 xcb_pad = 0; 6046 } 6047 xcb_block_len = 0; 6048 6049 return xcb_buffer_len; 6050 } 6051 6052 6053 /***************************************************************************** 6054 ** 6055 ** xcb_glx_get_clip_plane_cookie_t xcb_glx_get_clip_plane 6056 ** 6057 ** @param xcb_connection_t *c 6058 ** @param xcb_glx_context_tag_t context_tag 6059 ** @param int32_t plane 6060 ** @returns xcb_glx_get_clip_plane_cookie_t 6061 ** 6062 *****************************************************************************/ 6063 6064 xcb_glx_get_clip_plane_cookie_t 6065 xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, 6066 xcb_glx_context_tag_t context_tag /**< */, 6067 int32_t plane /**< */) 6068 { 6069 static const xcb_protocol_request_t xcb_req = { 6070 /* count */ 2, 6071 /* ext */ &xcb_glx_id, 6072 /* opcode */ XCB_GLX_GET_CLIP_PLANE, 6073 /* isvoid */ 0 6074 }; 6075 6076 struct iovec xcb_parts[4]; 6077 xcb_glx_get_clip_plane_cookie_t xcb_ret; 6078 xcb_glx_get_clip_plane_request_t xcb_out; 6079 6080 xcb_out.context_tag = context_tag; 6081 xcb_out.plane = plane; 6082 6083 xcb_parts[2].iov_base = (char *) &xcb_out; 6084 xcb_parts[2].iov_len = sizeof(xcb_out); 6085 xcb_parts[3].iov_base = 0; 6086 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6087 6088 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6089 return xcb_ret; 6090 } 6091 6092 6093 /***************************************************************************** 6094 ** 6095 ** xcb_glx_get_clip_plane_cookie_t xcb_glx_get_clip_plane_unchecked 6096 ** 6097 ** @param xcb_connection_t *c 6098 ** @param xcb_glx_context_tag_t context_tag 6099 ** @param int32_t plane 6100 ** @returns xcb_glx_get_clip_plane_cookie_t 6101 ** 6102 *****************************************************************************/ 6103 6104 xcb_glx_get_clip_plane_cookie_t 6105 xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c /**< */, 6106 xcb_glx_context_tag_t context_tag /**< */, 6107 int32_t plane /**< */) 6108 { 6109 static const xcb_protocol_request_t xcb_req = { 6110 /* count */ 2, 6111 /* ext */ &xcb_glx_id, 6112 /* opcode */ XCB_GLX_GET_CLIP_PLANE, 6113 /* isvoid */ 0 6114 }; 6115 6116 struct iovec xcb_parts[4]; 6117 xcb_glx_get_clip_plane_cookie_t xcb_ret; 6118 xcb_glx_get_clip_plane_request_t xcb_out; 6119 6120 xcb_out.context_tag = context_tag; 6121 xcb_out.plane = plane; 6122 6123 xcb_parts[2].iov_base = (char *) &xcb_out; 6124 xcb_parts[2].iov_len = sizeof(xcb_out); 6125 xcb_parts[3].iov_base = 0; 6126 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6127 6128 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6129 return xcb_ret; 6130 } 6131 6132 6133 /***************************************************************************** 6134 ** 6135 ** xcb_glx_float64_t * xcb_glx_get_clip_plane_data 6136 ** 6137 ** @param const xcb_glx_get_clip_plane_reply_t *R 6138 ** @returns xcb_glx_float64_t * 6139 ** 6140 *****************************************************************************/ 6141 6142 xcb_glx_float64_t * 6143 xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6144 { 6145 return (xcb_glx_float64_t *) (R + 1); 6146 } 6147 6148 6149 /***************************************************************************** 6150 ** 6151 ** int xcb_glx_get_clip_plane_data_length 6152 ** 6153 ** @param const xcb_glx_get_clip_plane_reply_t *R 6154 ** @returns int 6155 ** 6156 *****************************************************************************/ 6157 6158 int 6159 xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6160 { 6161 return (R->length / 2); 6162 } 6163 6164 6165 /***************************************************************************** 6166 ** 6167 ** xcb_generic_iterator_t xcb_glx_get_clip_plane_data_end 6168 ** 6169 ** @param const xcb_glx_get_clip_plane_reply_t *R 6170 ** @returns xcb_generic_iterator_t 6171 ** 6172 *****************************************************************************/ 6173 6174 xcb_generic_iterator_t 6175 xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6176 { 6177 xcb_generic_iterator_t i; 6178 i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2)); 6179 i.rem = 0; 6180 i.index = (char *) i.data - (char *) R; 6181 return i; 6182 } 6183 6184 6185 /***************************************************************************** 6186 ** 6187 ** xcb_glx_get_clip_plane_reply_t * xcb_glx_get_clip_plane_reply 6188 ** 6189 ** @param xcb_connection_t *c 6190 ** @param xcb_glx_get_clip_plane_cookie_t cookie 6191 ** @param xcb_generic_error_t **e 6192 ** @returns xcb_glx_get_clip_plane_reply_t * 6193 ** 6194 *****************************************************************************/ 6195 6196 xcb_glx_get_clip_plane_reply_t * 6197 xcb_glx_get_clip_plane_reply (xcb_connection_t *c /**< */, 6198 xcb_glx_get_clip_plane_cookie_t cookie /**< */, 6199 xcb_generic_error_t **e /**< */) 6200 { 6201 return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6202 } 6203 6204 int 6205 xcb_glx_get_doublev_sizeof (const void *_buffer /**< */) 6206 { 6207 char *xcb_tmp = (char *)_buffer; 6208 const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer; 6209 unsigned int xcb_buffer_len = 0; 6210 unsigned int xcb_block_len = 0; 6211 unsigned int xcb_pad = 0; 6212 unsigned int xcb_align_to; 6213 6214 6215 xcb_block_len += sizeof(xcb_glx_get_doublev_reply_t); 6216 xcb_tmp += xcb_block_len; 6217 /* data */ 6218 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 6219 xcb_tmp += xcb_block_len; 6220 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6221 /* insert padding */ 6222 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6223 xcb_buffer_len += xcb_block_len + xcb_pad; 6224 if (0 != xcb_pad) { 6225 xcb_tmp += xcb_pad; 6226 xcb_pad = 0; 6227 } 6228 xcb_block_len = 0; 6229 6230 return xcb_buffer_len; 6231 } 6232 6233 6234 /***************************************************************************** 6235 ** 6236 ** xcb_glx_get_doublev_cookie_t xcb_glx_get_doublev 6237 ** 6238 ** @param xcb_connection_t *c 6239 ** @param xcb_glx_context_tag_t context_tag 6240 ** @param uint32_t pname 6241 ** @returns xcb_glx_get_doublev_cookie_t 6242 ** 6243 *****************************************************************************/ 6244 6245 xcb_glx_get_doublev_cookie_t 6246 xcb_glx_get_doublev (xcb_connection_t *c /**< */, 6247 xcb_glx_context_tag_t context_tag /**< */, 6248 uint32_t pname /**< */) 6249 { 6250 static const xcb_protocol_request_t xcb_req = { 6251 /* count */ 2, 6252 /* ext */ &xcb_glx_id, 6253 /* opcode */ XCB_GLX_GET_DOUBLEV, 6254 /* isvoid */ 0 6255 }; 6256 6257 struct iovec xcb_parts[4]; 6258 xcb_glx_get_doublev_cookie_t xcb_ret; 6259 xcb_glx_get_doublev_request_t xcb_out; 6260 6261 xcb_out.context_tag = context_tag; 6262 xcb_out.pname = pname; 6263 6264 xcb_parts[2].iov_base = (char *) &xcb_out; 6265 xcb_parts[2].iov_len = sizeof(xcb_out); 6266 xcb_parts[3].iov_base = 0; 6267 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6268 6269 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6270 return xcb_ret; 6271 } 6272 6273 6274 /***************************************************************************** 6275 ** 6276 ** xcb_glx_get_doublev_cookie_t xcb_glx_get_doublev_unchecked 6277 ** 6278 ** @param xcb_connection_t *c 6279 ** @param xcb_glx_context_tag_t context_tag 6280 ** @param uint32_t pname 6281 ** @returns xcb_glx_get_doublev_cookie_t 6282 ** 6283 *****************************************************************************/ 6284 6285 xcb_glx_get_doublev_cookie_t 6286 xcb_glx_get_doublev_unchecked (xcb_connection_t *c /**< */, 6287 xcb_glx_context_tag_t context_tag /**< */, 6288 uint32_t pname /**< */) 6289 { 6290 static const xcb_protocol_request_t xcb_req = { 6291 /* count */ 2, 6292 /* ext */ &xcb_glx_id, 6293 /* opcode */ XCB_GLX_GET_DOUBLEV, 6294 /* isvoid */ 0 6295 }; 6296 6297 struct iovec xcb_parts[4]; 6298 xcb_glx_get_doublev_cookie_t xcb_ret; 6299 xcb_glx_get_doublev_request_t xcb_out; 6300 6301 xcb_out.context_tag = context_tag; 6302 xcb_out.pname = pname; 6303 6304 xcb_parts[2].iov_base = (char *) &xcb_out; 6305 xcb_parts[2].iov_len = sizeof(xcb_out); 6306 xcb_parts[3].iov_base = 0; 6307 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6308 6309 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6310 return xcb_ret; 6311 } 6312 6313 6314 /***************************************************************************** 6315 ** 6316 ** xcb_glx_float64_t * xcb_glx_get_doublev_data 6317 ** 6318 ** @param const xcb_glx_get_doublev_reply_t *R 6319 ** @returns xcb_glx_float64_t * 6320 ** 6321 *****************************************************************************/ 6322 6323 xcb_glx_float64_t * 6324 xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R /**< */) 6325 { 6326 return (xcb_glx_float64_t *) (R + 1); 6327 } 6328 6329 6330 /***************************************************************************** 6331 ** 6332 ** int xcb_glx_get_doublev_data_length 6333 ** 6334 ** @param const xcb_glx_get_doublev_reply_t *R 6335 ** @returns int 6336 ** 6337 *****************************************************************************/ 6338 6339 int 6340 xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R /**< */) 6341 { 6342 return R->n; 6343 } 6344 6345 6346 /***************************************************************************** 6347 ** 6348 ** xcb_generic_iterator_t xcb_glx_get_doublev_data_end 6349 ** 6350 ** @param const xcb_glx_get_doublev_reply_t *R 6351 ** @returns xcb_generic_iterator_t 6352 ** 6353 *****************************************************************************/ 6354 6355 xcb_generic_iterator_t 6356 xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */) 6357 { 6358 xcb_generic_iterator_t i; 6359 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 6360 i.rem = 0; 6361 i.index = (char *) i.data - (char *) R; 6362 return i; 6363 } 6364 6365 6366 /***************************************************************************** 6367 ** 6368 ** xcb_glx_get_doublev_reply_t * xcb_glx_get_doublev_reply 6369 ** 6370 ** @param xcb_connection_t *c 6371 ** @param xcb_glx_get_doublev_cookie_t cookie 6372 ** @param xcb_generic_error_t **e 6373 ** @returns xcb_glx_get_doublev_reply_t * 6374 ** 6375 *****************************************************************************/ 6376 6377 xcb_glx_get_doublev_reply_t * 6378 xcb_glx_get_doublev_reply (xcb_connection_t *c /**< */, 6379 xcb_glx_get_doublev_cookie_t cookie /**< */, 6380 xcb_generic_error_t **e /**< */) 6381 { 6382 return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6383 } 6384 6385 6386 /***************************************************************************** 6387 ** 6388 ** xcb_glx_get_error_cookie_t xcb_glx_get_error 6389 ** 6390 ** @param xcb_connection_t *c 6391 ** @param xcb_glx_context_tag_t context_tag 6392 ** @returns xcb_glx_get_error_cookie_t 6393 ** 6394 *****************************************************************************/ 6395 6396 xcb_glx_get_error_cookie_t 6397 xcb_glx_get_error (xcb_connection_t *c /**< */, 6398 xcb_glx_context_tag_t context_tag /**< */) 6399 { 6400 static const xcb_protocol_request_t xcb_req = { 6401 /* count */ 2, 6402 /* ext */ &xcb_glx_id, 6403 /* opcode */ XCB_GLX_GET_ERROR, 6404 /* isvoid */ 0 6405 }; 6406 6407 struct iovec xcb_parts[4]; 6408 xcb_glx_get_error_cookie_t xcb_ret; 6409 xcb_glx_get_error_request_t xcb_out; 6410 6411 xcb_out.context_tag = context_tag; 6412 6413 xcb_parts[2].iov_base = (char *) &xcb_out; 6414 xcb_parts[2].iov_len = sizeof(xcb_out); 6415 xcb_parts[3].iov_base = 0; 6416 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6417 6418 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6419 return xcb_ret; 6420 } 6421 6422 6423 /***************************************************************************** 6424 ** 6425 ** xcb_glx_get_error_cookie_t xcb_glx_get_error_unchecked 6426 ** 6427 ** @param xcb_connection_t *c 6428 ** @param xcb_glx_context_tag_t context_tag 6429 ** @returns xcb_glx_get_error_cookie_t 6430 ** 6431 *****************************************************************************/ 6432 6433 xcb_glx_get_error_cookie_t 6434 xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, 6435 xcb_glx_context_tag_t context_tag /**< */) 6436 { 6437 static const xcb_protocol_request_t xcb_req = { 6438 /* count */ 2, 6439 /* ext */ &xcb_glx_id, 6440 /* opcode */ XCB_GLX_GET_ERROR, 6441 /* isvoid */ 0 6442 }; 6443 6444 struct iovec xcb_parts[4]; 6445 xcb_glx_get_error_cookie_t xcb_ret; 6446 xcb_glx_get_error_request_t xcb_out; 6447 6448 xcb_out.context_tag = context_tag; 6449 6450 xcb_parts[2].iov_base = (char *) &xcb_out; 6451 xcb_parts[2].iov_len = sizeof(xcb_out); 6452 xcb_parts[3].iov_base = 0; 6453 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6454 6455 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6456 return xcb_ret; 6457 } 6458 6459 6460 /***************************************************************************** 6461 ** 6462 ** xcb_glx_get_error_reply_t * xcb_glx_get_error_reply 6463 ** 6464 ** @param xcb_connection_t *c 6465 ** @param xcb_glx_get_error_cookie_t cookie 6466 ** @param xcb_generic_error_t **e 6467 ** @returns xcb_glx_get_error_reply_t * 6468 ** 6469 *****************************************************************************/ 6470 6471 xcb_glx_get_error_reply_t * 6472 xcb_glx_get_error_reply (xcb_connection_t *c /**< */, 6473 xcb_glx_get_error_cookie_t cookie /**< */, 6474 xcb_generic_error_t **e /**< */) 6475 { 6476 return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6477 } 6478 6479 int 6480 xcb_glx_get_floatv_sizeof (const void *_buffer /**< */) 6481 { 6482 char *xcb_tmp = (char *)_buffer; 6483 const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer; 6484 unsigned int xcb_buffer_len = 0; 6485 unsigned int xcb_block_len = 0; 6486 unsigned int xcb_pad = 0; 6487 unsigned int xcb_align_to; 6488 6489 6490 xcb_block_len += sizeof(xcb_glx_get_floatv_reply_t); 6491 xcb_tmp += xcb_block_len; 6492 /* data */ 6493 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6494 xcb_tmp += xcb_block_len; 6495 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6496 /* insert padding */ 6497 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6498 xcb_buffer_len += xcb_block_len + xcb_pad; 6499 if (0 != xcb_pad) { 6500 xcb_tmp += xcb_pad; 6501 xcb_pad = 0; 6502 } 6503 xcb_block_len = 0; 6504 6505 return xcb_buffer_len; 6506 } 6507 6508 6509 /***************************************************************************** 6510 ** 6511 ** xcb_glx_get_floatv_cookie_t xcb_glx_get_floatv 6512 ** 6513 ** @param xcb_connection_t *c 6514 ** @param xcb_glx_context_tag_t context_tag 6515 ** @param uint32_t pname 6516 ** @returns xcb_glx_get_floatv_cookie_t 6517 ** 6518 *****************************************************************************/ 6519 6520 xcb_glx_get_floatv_cookie_t 6521 xcb_glx_get_floatv (xcb_connection_t *c /**< */, 6522 xcb_glx_context_tag_t context_tag /**< */, 6523 uint32_t pname /**< */) 6524 { 6525 static const xcb_protocol_request_t xcb_req = { 6526 /* count */ 2, 6527 /* ext */ &xcb_glx_id, 6528 /* opcode */ XCB_GLX_GET_FLOATV, 6529 /* isvoid */ 0 6530 }; 6531 6532 struct iovec xcb_parts[4]; 6533 xcb_glx_get_floatv_cookie_t xcb_ret; 6534 xcb_glx_get_floatv_request_t xcb_out; 6535 6536 xcb_out.context_tag = context_tag; 6537 xcb_out.pname = pname; 6538 6539 xcb_parts[2].iov_base = (char *) &xcb_out; 6540 xcb_parts[2].iov_len = sizeof(xcb_out); 6541 xcb_parts[3].iov_base = 0; 6542 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6543 6544 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6545 return xcb_ret; 6546 } 6547 6548 6549 /***************************************************************************** 6550 ** 6551 ** xcb_glx_get_floatv_cookie_t xcb_glx_get_floatv_unchecked 6552 ** 6553 ** @param xcb_connection_t *c 6554 ** @param xcb_glx_context_tag_t context_tag 6555 ** @param uint32_t pname 6556 ** @returns xcb_glx_get_floatv_cookie_t 6557 ** 6558 *****************************************************************************/ 6559 6560 xcb_glx_get_floatv_cookie_t 6561 xcb_glx_get_floatv_unchecked (xcb_connection_t *c /**< */, 6562 xcb_glx_context_tag_t context_tag /**< */, 6563 uint32_t pname /**< */) 6564 { 6565 static const xcb_protocol_request_t xcb_req = { 6566 /* count */ 2, 6567 /* ext */ &xcb_glx_id, 6568 /* opcode */ XCB_GLX_GET_FLOATV, 6569 /* isvoid */ 0 6570 }; 6571 6572 struct iovec xcb_parts[4]; 6573 xcb_glx_get_floatv_cookie_t xcb_ret; 6574 xcb_glx_get_floatv_request_t xcb_out; 6575 6576 xcb_out.context_tag = context_tag; 6577 xcb_out.pname = pname; 6578 6579 xcb_parts[2].iov_base = (char *) &xcb_out; 6580 xcb_parts[2].iov_len = sizeof(xcb_out); 6581 xcb_parts[3].iov_base = 0; 6582 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6583 6584 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6585 return xcb_ret; 6586 } 6587 6588 6589 /***************************************************************************** 6590 ** 6591 ** xcb_glx_float32_t * xcb_glx_get_floatv_data 6592 ** 6593 ** @param const xcb_glx_get_floatv_reply_t *R 6594 ** @returns xcb_glx_float32_t * 6595 ** 6596 *****************************************************************************/ 6597 6598 xcb_glx_float32_t * 6599 xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R /**< */) 6600 { 6601 return (xcb_glx_float32_t *) (R + 1); 6602 } 6603 6604 6605 /***************************************************************************** 6606 ** 6607 ** int xcb_glx_get_floatv_data_length 6608 ** 6609 ** @param const xcb_glx_get_floatv_reply_t *R 6610 ** @returns int 6611 ** 6612 *****************************************************************************/ 6613 6614 int 6615 xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R /**< */) 6616 { 6617 return R->n; 6618 } 6619 6620 6621 /***************************************************************************** 6622 ** 6623 ** xcb_generic_iterator_t xcb_glx_get_floatv_data_end 6624 ** 6625 ** @param const xcb_glx_get_floatv_reply_t *R 6626 ** @returns xcb_generic_iterator_t 6627 ** 6628 *****************************************************************************/ 6629 6630 xcb_generic_iterator_t 6631 xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */) 6632 { 6633 xcb_generic_iterator_t i; 6634 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6635 i.rem = 0; 6636 i.index = (char *) i.data - (char *) R; 6637 return i; 6638 } 6639 6640 6641 /***************************************************************************** 6642 ** 6643 ** xcb_glx_get_floatv_reply_t * xcb_glx_get_floatv_reply 6644 ** 6645 ** @param xcb_connection_t *c 6646 ** @param xcb_glx_get_floatv_cookie_t cookie 6647 ** @param xcb_generic_error_t **e 6648 ** @returns xcb_glx_get_floatv_reply_t * 6649 ** 6650 *****************************************************************************/ 6651 6652 xcb_glx_get_floatv_reply_t * 6653 xcb_glx_get_floatv_reply (xcb_connection_t *c /**< */, 6654 xcb_glx_get_floatv_cookie_t cookie /**< */, 6655 xcb_generic_error_t **e /**< */) 6656 { 6657 return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6658 } 6659 6660 int 6661 xcb_glx_get_integerv_sizeof (const void *_buffer /**< */) 6662 { 6663 char *xcb_tmp = (char *)_buffer; 6664 const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer; 6665 unsigned int xcb_buffer_len = 0; 6666 unsigned int xcb_block_len = 0; 6667 unsigned int xcb_pad = 0; 6668 unsigned int xcb_align_to; 6669 6670 6671 xcb_block_len += sizeof(xcb_glx_get_integerv_reply_t); 6672 xcb_tmp += xcb_block_len; 6673 /* data */ 6674 xcb_block_len += _aux->n * sizeof(int32_t); 6675 xcb_tmp += xcb_block_len; 6676 xcb_align_to = ALIGNOF(int32_t); 6677 /* insert padding */ 6678 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6679 xcb_buffer_len += xcb_block_len + xcb_pad; 6680 if (0 != xcb_pad) { 6681 xcb_tmp += xcb_pad; 6682 xcb_pad = 0; 6683 } 6684 xcb_block_len = 0; 6685 6686 return xcb_buffer_len; 6687 } 6688 6689 6690 /***************************************************************************** 6691 ** 6692 ** xcb_glx_get_integerv_cookie_t xcb_glx_get_integerv 6693 ** 6694 ** @param xcb_connection_t *c 6695 ** @param xcb_glx_context_tag_t context_tag 6696 ** @param uint32_t pname 6697 ** @returns xcb_glx_get_integerv_cookie_t 6698 ** 6699 *****************************************************************************/ 6700 6701 xcb_glx_get_integerv_cookie_t 6702 xcb_glx_get_integerv (xcb_connection_t *c /**< */, 6703 xcb_glx_context_tag_t context_tag /**< */, 6704 uint32_t pname /**< */) 6705 { 6706 static const xcb_protocol_request_t xcb_req = { 6707 /* count */ 2, 6708 /* ext */ &xcb_glx_id, 6709 /* opcode */ XCB_GLX_GET_INTEGERV, 6710 /* isvoid */ 0 6711 }; 6712 6713 struct iovec xcb_parts[4]; 6714 xcb_glx_get_integerv_cookie_t xcb_ret; 6715 xcb_glx_get_integerv_request_t xcb_out; 6716 6717 xcb_out.context_tag = context_tag; 6718 xcb_out.pname = pname; 6719 6720 xcb_parts[2].iov_base = (char *) &xcb_out; 6721 xcb_parts[2].iov_len = sizeof(xcb_out); 6722 xcb_parts[3].iov_base = 0; 6723 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6724 6725 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6726 return xcb_ret; 6727 } 6728 6729 6730 /***************************************************************************** 6731 ** 6732 ** xcb_glx_get_integerv_cookie_t xcb_glx_get_integerv_unchecked 6733 ** 6734 ** @param xcb_connection_t *c 6735 ** @param xcb_glx_context_tag_t context_tag 6736 ** @param uint32_t pname 6737 ** @returns xcb_glx_get_integerv_cookie_t 6738 ** 6739 *****************************************************************************/ 6740 6741 xcb_glx_get_integerv_cookie_t 6742 xcb_glx_get_integerv_unchecked (xcb_connection_t *c /**< */, 6743 xcb_glx_context_tag_t context_tag /**< */, 6744 uint32_t pname /**< */) 6745 { 6746 static const xcb_protocol_request_t xcb_req = { 6747 /* count */ 2, 6748 /* ext */ &xcb_glx_id, 6749 /* opcode */ XCB_GLX_GET_INTEGERV, 6750 /* isvoid */ 0 6751 }; 6752 6753 struct iovec xcb_parts[4]; 6754 xcb_glx_get_integerv_cookie_t xcb_ret; 6755 xcb_glx_get_integerv_request_t xcb_out; 6756 6757 xcb_out.context_tag = context_tag; 6758 xcb_out.pname = pname; 6759 6760 xcb_parts[2].iov_base = (char *) &xcb_out; 6761 xcb_parts[2].iov_len = sizeof(xcb_out); 6762 xcb_parts[3].iov_base = 0; 6763 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6764 6765 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6766 return xcb_ret; 6767 } 6768 6769 6770 /***************************************************************************** 6771 ** 6772 ** int32_t * xcb_glx_get_integerv_data 6773 ** 6774 ** @param const xcb_glx_get_integerv_reply_t *R 6775 ** @returns int32_t * 6776 ** 6777 *****************************************************************************/ 6778 6779 int32_t * 6780 xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R /**< */) 6781 { 6782 return (int32_t *) (R + 1); 6783 } 6784 6785 6786 /***************************************************************************** 6787 ** 6788 ** int xcb_glx_get_integerv_data_length 6789 ** 6790 ** @param const xcb_glx_get_integerv_reply_t *R 6791 ** @returns int 6792 ** 6793 *****************************************************************************/ 6794 6795 int 6796 xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R /**< */) 6797 { 6798 return R->n; 6799 } 6800 6801 6802 /***************************************************************************** 6803 ** 6804 ** xcb_generic_iterator_t xcb_glx_get_integerv_data_end 6805 ** 6806 ** @param const xcb_glx_get_integerv_reply_t *R 6807 ** @returns xcb_generic_iterator_t 6808 ** 6809 *****************************************************************************/ 6810 6811 xcb_generic_iterator_t 6812 xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */) 6813 { 6814 xcb_generic_iterator_t i; 6815 i.data = ((int32_t *) (R + 1)) + (R->n); 6816 i.rem = 0; 6817 i.index = (char *) i.data - (char *) R; 6818 return i; 6819 } 6820 6821 6822 /***************************************************************************** 6823 ** 6824 ** xcb_glx_get_integerv_reply_t * xcb_glx_get_integerv_reply 6825 ** 6826 ** @param xcb_connection_t *c 6827 ** @param xcb_glx_get_integerv_cookie_t cookie 6828 ** @param xcb_generic_error_t **e 6829 ** @returns xcb_glx_get_integerv_reply_t * 6830 ** 6831 *****************************************************************************/ 6832 6833 xcb_glx_get_integerv_reply_t * 6834 xcb_glx_get_integerv_reply (xcb_connection_t *c /**< */, 6835 xcb_glx_get_integerv_cookie_t cookie /**< */, 6836 xcb_generic_error_t **e /**< */) 6837 { 6838 return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6839 } 6840 6841 int 6842 xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */) 6843 { 6844 char *xcb_tmp = (char *)_buffer; 6845 const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer; 6846 unsigned int xcb_buffer_len = 0; 6847 unsigned int xcb_block_len = 0; 6848 unsigned int xcb_pad = 0; 6849 unsigned int xcb_align_to; 6850 6851 6852 xcb_block_len += sizeof(xcb_glx_get_lightfv_reply_t); 6853 xcb_tmp += xcb_block_len; 6854 /* data */ 6855 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6856 xcb_tmp += xcb_block_len; 6857 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6858 /* insert padding */ 6859 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6860 xcb_buffer_len += xcb_block_len + xcb_pad; 6861 if (0 != xcb_pad) { 6862 xcb_tmp += xcb_pad; 6863 xcb_pad = 0; 6864 } 6865 xcb_block_len = 0; 6866 6867 return xcb_buffer_len; 6868 } 6869 6870 6871 /***************************************************************************** 6872 ** 6873 ** xcb_glx_get_lightfv_cookie_t xcb_glx_get_lightfv 6874 ** 6875 ** @param xcb_connection_t *c 6876 ** @param xcb_glx_context_tag_t context_tag 6877 ** @param uint32_t light 6878 ** @param uint32_t pname 6879 ** @returns xcb_glx_get_lightfv_cookie_t 6880 ** 6881 *****************************************************************************/ 6882 6883 xcb_glx_get_lightfv_cookie_t 6884 xcb_glx_get_lightfv (xcb_connection_t *c /**< */, 6885 xcb_glx_context_tag_t context_tag /**< */, 6886 uint32_t light /**< */, 6887 uint32_t pname /**< */) 6888 { 6889 static const xcb_protocol_request_t xcb_req = { 6890 /* count */ 2, 6891 /* ext */ &xcb_glx_id, 6892 /* opcode */ XCB_GLX_GET_LIGHTFV, 6893 /* isvoid */ 0 6894 }; 6895 6896 struct iovec xcb_parts[4]; 6897 xcb_glx_get_lightfv_cookie_t xcb_ret; 6898 xcb_glx_get_lightfv_request_t xcb_out; 6899 6900 xcb_out.context_tag = context_tag; 6901 xcb_out.light = light; 6902 xcb_out.pname = pname; 6903 6904 xcb_parts[2].iov_base = (char *) &xcb_out; 6905 xcb_parts[2].iov_len = sizeof(xcb_out); 6906 xcb_parts[3].iov_base = 0; 6907 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6908 6909 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6910 return xcb_ret; 6911 } 6912 6913 6914 /***************************************************************************** 6915 ** 6916 ** xcb_glx_get_lightfv_cookie_t xcb_glx_get_lightfv_unchecked 6917 ** 6918 ** @param xcb_connection_t *c 6919 ** @param xcb_glx_context_tag_t context_tag 6920 ** @param uint32_t light 6921 ** @param uint32_t pname 6922 ** @returns xcb_glx_get_lightfv_cookie_t 6923 ** 6924 *****************************************************************************/ 6925 6926 xcb_glx_get_lightfv_cookie_t 6927 xcb_glx_get_lightfv_unchecked (xcb_connection_t *c /**< */, 6928 xcb_glx_context_tag_t context_tag /**< */, 6929 uint32_t light /**< */, 6930 uint32_t pname /**< */) 6931 { 6932 static const xcb_protocol_request_t xcb_req = { 6933 /* count */ 2, 6934 /* ext */ &xcb_glx_id, 6935 /* opcode */ XCB_GLX_GET_LIGHTFV, 6936 /* isvoid */ 0 6937 }; 6938 6939 struct iovec xcb_parts[4]; 6940 xcb_glx_get_lightfv_cookie_t xcb_ret; 6941 xcb_glx_get_lightfv_request_t xcb_out; 6942 6943 xcb_out.context_tag = context_tag; 6944 xcb_out.light = light; 6945 xcb_out.pname = pname; 6946 6947 xcb_parts[2].iov_base = (char *) &xcb_out; 6948 xcb_parts[2].iov_len = sizeof(xcb_out); 6949 xcb_parts[3].iov_base = 0; 6950 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6951 6952 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6953 return xcb_ret; 6954 } 6955 6956 6957 /***************************************************************************** 6958 ** 6959 ** xcb_glx_float32_t * xcb_glx_get_lightfv_data 6960 ** 6961 ** @param const xcb_glx_get_lightfv_reply_t *R 6962 ** @returns xcb_glx_float32_t * 6963 ** 6964 *****************************************************************************/ 6965 6966 xcb_glx_float32_t * 6967 xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R /**< */) 6968 { 6969 return (xcb_glx_float32_t *) (R + 1); 6970 } 6971 6972 6973 /***************************************************************************** 6974 ** 6975 ** int xcb_glx_get_lightfv_data_length 6976 ** 6977 ** @param const xcb_glx_get_lightfv_reply_t *R 6978 ** @returns int 6979 ** 6980 *****************************************************************************/ 6981 6982 int 6983 xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R /**< */) 6984 { 6985 return R->n; 6986 } 6987 6988 6989 /***************************************************************************** 6990 ** 6991 ** xcb_generic_iterator_t xcb_glx_get_lightfv_data_end 6992 ** 6993 ** @param const xcb_glx_get_lightfv_reply_t *R 6994 ** @returns xcb_generic_iterator_t 6995 ** 6996 *****************************************************************************/ 6997 6998 xcb_generic_iterator_t 6999 xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */) 7000 { 7001 xcb_generic_iterator_t i; 7002 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7003 i.rem = 0; 7004 i.index = (char *) i.data - (char *) R; 7005 return i; 7006 } 7007 7008 7009 /***************************************************************************** 7010 ** 7011 ** xcb_glx_get_lightfv_reply_t * xcb_glx_get_lightfv_reply 7012 ** 7013 ** @param xcb_connection_t *c 7014 ** @param xcb_glx_get_lightfv_cookie_t cookie 7015 ** @param xcb_generic_error_t **e 7016 ** @returns xcb_glx_get_lightfv_reply_t * 7017 ** 7018 *****************************************************************************/ 7019 7020 xcb_glx_get_lightfv_reply_t * 7021 xcb_glx_get_lightfv_reply (xcb_connection_t *c /**< */, 7022 xcb_glx_get_lightfv_cookie_t cookie /**< */, 7023 xcb_generic_error_t **e /**< */) 7024 { 7025 return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7026 } 7027 7028 int 7029 xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */) 7030 { 7031 char *xcb_tmp = (char *)_buffer; 7032 const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer; 7033 unsigned int xcb_buffer_len = 0; 7034 unsigned int xcb_block_len = 0; 7035 unsigned int xcb_pad = 0; 7036 unsigned int xcb_align_to; 7037 7038 7039 xcb_block_len += sizeof(xcb_glx_get_lightiv_reply_t); 7040 xcb_tmp += xcb_block_len; 7041 /* data */ 7042 xcb_block_len += _aux->n * sizeof(int32_t); 7043 xcb_tmp += xcb_block_len; 7044 xcb_align_to = ALIGNOF(int32_t); 7045 /* insert padding */ 7046 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7047 xcb_buffer_len += xcb_block_len + xcb_pad; 7048 if (0 != xcb_pad) { 7049 xcb_tmp += xcb_pad; 7050 xcb_pad = 0; 7051 } 7052 xcb_block_len = 0; 7053 7054 return xcb_buffer_len; 7055 } 7056 7057 7058 /***************************************************************************** 7059 ** 7060 ** xcb_glx_get_lightiv_cookie_t xcb_glx_get_lightiv 7061 ** 7062 ** @param xcb_connection_t *c 7063 ** @param xcb_glx_context_tag_t context_tag 7064 ** @param uint32_t light 7065 ** @param uint32_t pname 7066 ** @returns xcb_glx_get_lightiv_cookie_t 7067 ** 7068 *****************************************************************************/ 7069 7070 xcb_glx_get_lightiv_cookie_t 7071 xcb_glx_get_lightiv (xcb_connection_t *c /**< */, 7072 xcb_glx_context_tag_t context_tag /**< */, 7073 uint32_t light /**< */, 7074 uint32_t pname /**< */) 7075 { 7076 static const xcb_protocol_request_t xcb_req = { 7077 /* count */ 2, 7078 /* ext */ &xcb_glx_id, 7079 /* opcode */ XCB_GLX_GET_LIGHTIV, 7080 /* isvoid */ 0 7081 }; 7082 7083 struct iovec xcb_parts[4]; 7084 xcb_glx_get_lightiv_cookie_t xcb_ret; 7085 xcb_glx_get_lightiv_request_t xcb_out; 7086 7087 xcb_out.context_tag = context_tag; 7088 xcb_out.light = light; 7089 xcb_out.pname = pname; 7090 7091 xcb_parts[2].iov_base = (char *) &xcb_out; 7092 xcb_parts[2].iov_len = sizeof(xcb_out); 7093 xcb_parts[3].iov_base = 0; 7094 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7095 7096 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7097 return xcb_ret; 7098 } 7099 7100 7101 /***************************************************************************** 7102 ** 7103 ** xcb_glx_get_lightiv_cookie_t xcb_glx_get_lightiv_unchecked 7104 ** 7105 ** @param xcb_connection_t *c 7106 ** @param xcb_glx_context_tag_t context_tag 7107 ** @param uint32_t light 7108 ** @param uint32_t pname 7109 ** @returns xcb_glx_get_lightiv_cookie_t 7110 ** 7111 *****************************************************************************/ 7112 7113 xcb_glx_get_lightiv_cookie_t 7114 xcb_glx_get_lightiv_unchecked (xcb_connection_t *c /**< */, 7115 xcb_glx_context_tag_t context_tag /**< */, 7116 uint32_t light /**< */, 7117 uint32_t pname /**< */) 7118 { 7119 static const xcb_protocol_request_t xcb_req = { 7120 /* count */ 2, 7121 /* ext */ &xcb_glx_id, 7122 /* opcode */ XCB_GLX_GET_LIGHTIV, 7123 /* isvoid */ 0 7124 }; 7125 7126 struct iovec xcb_parts[4]; 7127 xcb_glx_get_lightiv_cookie_t xcb_ret; 7128 xcb_glx_get_lightiv_request_t xcb_out; 7129 7130 xcb_out.context_tag = context_tag; 7131 xcb_out.light = light; 7132 xcb_out.pname = pname; 7133 7134 xcb_parts[2].iov_base = (char *) &xcb_out; 7135 xcb_parts[2].iov_len = sizeof(xcb_out); 7136 xcb_parts[3].iov_base = 0; 7137 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7138 7139 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7140 return xcb_ret; 7141 } 7142 7143 7144 /***************************************************************************** 7145 ** 7146 ** int32_t * xcb_glx_get_lightiv_data 7147 ** 7148 ** @param const xcb_glx_get_lightiv_reply_t *R 7149 ** @returns int32_t * 7150 ** 7151 *****************************************************************************/ 7152 7153 int32_t * 7154 xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R /**< */) 7155 { 7156 return (int32_t *) (R + 1); 7157 } 7158 7159 7160 /***************************************************************************** 7161 ** 7162 ** int xcb_glx_get_lightiv_data_length 7163 ** 7164 ** @param const xcb_glx_get_lightiv_reply_t *R 7165 ** @returns int 7166 ** 7167 *****************************************************************************/ 7168 7169 int 7170 xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R /**< */) 7171 { 7172 return R->n; 7173 } 7174 7175 7176 /***************************************************************************** 7177 ** 7178 ** xcb_generic_iterator_t xcb_glx_get_lightiv_data_end 7179 ** 7180 ** @param const xcb_glx_get_lightiv_reply_t *R 7181 ** @returns xcb_generic_iterator_t 7182 ** 7183 *****************************************************************************/ 7184 7185 xcb_generic_iterator_t 7186 xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */) 7187 { 7188 xcb_generic_iterator_t i; 7189 i.data = ((int32_t *) (R + 1)) + (R->n); 7190 i.rem = 0; 7191 i.index = (char *) i.data - (char *) R; 7192 return i; 7193 } 7194 7195 7196 /***************************************************************************** 7197 ** 7198 ** xcb_glx_get_lightiv_reply_t * xcb_glx_get_lightiv_reply 7199 ** 7200 ** @param xcb_connection_t *c 7201 ** @param xcb_glx_get_lightiv_cookie_t cookie 7202 ** @param xcb_generic_error_t **e 7203 ** @returns xcb_glx_get_lightiv_reply_t * 7204 ** 7205 *****************************************************************************/ 7206 7207 xcb_glx_get_lightiv_reply_t * 7208 xcb_glx_get_lightiv_reply (xcb_connection_t *c /**< */, 7209 xcb_glx_get_lightiv_cookie_t cookie /**< */, 7210 xcb_generic_error_t **e /**< */) 7211 { 7212 return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7213 } 7214 7215 int 7216 xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */) 7217 { 7218 char *xcb_tmp = (char *)_buffer; 7219 const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer; 7220 unsigned int xcb_buffer_len = 0; 7221 unsigned int xcb_block_len = 0; 7222 unsigned int xcb_pad = 0; 7223 unsigned int xcb_align_to; 7224 7225 7226 xcb_block_len += sizeof(xcb_glx_get_mapdv_reply_t); 7227 xcb_tmp += xcb_block_len; 7228 /* data */ 7229 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 7230 xcb_tmp += xcb_block_len; 7231 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 7232 /* insert padding */ 7233 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7234 xcb_buffer_len += xcb_block_len + xcb_pad; 7235 if (0 != xcb_pad) { 7236 xcb_tmp += xcb_pad; 7237 xcb_pad = 0; 7238 } 7239 xcb_block_len = 0; 7240 7241 return xcb_buffer_len; 7242 } 7243 7244 7245 /***************************************************************************** 7246 ** 7247 ** xcb_glx_get_mapdv_cookie_t xcb_glx_get_mapdv 7248 ** 7249 ** @param xcb_connection_t *c 7250 ** @param xcb_glx_context_tag_t context_tag 7251 ** @param uint32_t target 7252 ** @param uint32_t query 7253 ** @returns xcb_glx_get_mapdv_cookie_t 7254 ** 7255 *****************************************************************************/ 7256 7257 xcb_glx_get_mapdv_cookie_t 7258 xcb_glx_get_mapdv (xcb_connection_t *c /**< */, 7259 xcb_glx_context_tag_t context_tag /**< */, 7260 uint32_t target /**< */, 7261 uint32_t query /**< */) 7262 { 7263 static const xcb_protocol_request_t xcb_req = { 7264 /* count */ 2, 7265 /* ext */ &xcb_glx_id, 7266 /* opcode */ XCB_GLX_GET_MAPDV, 7267 /* isvoid */ 0 7268 }; 7269 7270 struct iovec xcb_parts[4]; 7271 xcb_glx_get_mapdv_cookie_t xcb_ret; 7272 xcb_glx_get_mapdv_request_t xcb_out; 7273 7274 xcb_out.context_tag = context_tag; 7275 xcb_out.target = target; 7276 xcb_out.query = query; 7277 7278 xcb_parts[2].iov_base = (char *) &xcb_out; 7279 xcb_parts[2].iov_len = sizeof(xcb_out); 7280 xcb_parts[3].iov_base = 0; 7281 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7282 7283 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7284 return xcb_ret; 7285 } 7286 7287 7288 /***************************************************************************** 7289 ** 7290 ** xcb_glx_get_mapdv_cookie_t xcb_glx_get_mapdv_unchecked 7291 ** 7292 ** @param xcb_connection_t *c 7293 ** @param xcb_glx_context_tag_t context_tag 7294 ** @param uint32_t target 7295 ** @param uint32_t query 7296 ** @returns xcb_glx_get_mapdv_cookie_t 7297 ** 7298 *****************************************************************************/ 7299 7300 xcb_glx_get_mapdv_cookie_t 7301 xcb_glx_get_mapdv_unchecked (xcb_connection_t *c /**< */, 7302 xcb_glx_context_tag_t context_tag /**< */, 7303 uint32_t target /**< */, 7304 uint32_t query /**< */) 7305 { 7306 static const xcb_protocol_request_t xcb_req = { 7307 /* count */ 2, 7308 /* ext */ &xcb_glx_id, 7309 /* opcode */ XCB_GLX_GET_MAPDV, 7310 /* isvoid */ 0 7311 }; 7312 7313 struct iovec xcb_parts[4]; 7314 xcb_glx_get_mapdv_cookie_t xcb_ret; 7315 xcb_glx_get_mapdv_request_t xcb_out; 7316 7317 xcb_out.context_tag = context_tag; 7318 xcb_out.target = target; 7319 xcb_out.query = query; 7320 7321 xcb_parts[2].iov_base = (char *) &xcb_out; 7322 xcb_parts[2].iov_len = sizeof(xcb_out); 7323 xcb_parts[3].iov_base = 0; 7324 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7325 7326 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7327 return xcb_ret; 7328 } 7329 7330 7331 /***************************************************************************** 7332 ** 7333 ** xcb_glx_float64_t * xcb_glx_get_mapdv_data 7334 ** 7335 ** @param const xcb_glx_get_mapdv_reply_t *R 7336 ** @returns xcb_glx_float64_t * 7337 ** 7338 *****************************************************************************/ 7339 7340 xcb_glx_float64_t * 7341 xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R /**< */) 7342 { 7343 return (xcb_glx_float64_t *) (R + 1); 7344 } 7345 7346 7347 /***************************************************************************** 7348 ** 7349 ** int xcb_glx_get_mapdv_data_length 7350 ** 7351 ** @param const xcb_glx_get_mapdv_reply_t *R 7352 ** @returns int 7353 ** 7354 *****************************************************************************/ 7355 7356 int 7357 xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R /**< */) 7358 { 7359 return R->n; 7360 } 7361 7362 7363 /***************************************************************************** 7364 ** 7365 ** xcb_generic_iterator_t xcb_glx_get_mapdv_data_end 7366 ** 7367 ** @param const xcb_glx_get_mapdv_reply_t *R 7368 ** @returns xcb_generic_iterator_t 7369 ** 7370 *****************************************************************************/ 7371 7372 xcb_generic_iterator_t 7373 xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */) 7374 { 7375 xcb_generic_iterator_t i; 7376 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 7377 i.rem = 0; 7378 i.index = (char *) i.data - (char *) R; 7379 return i; 7380 } 7381 7382 7383 /***************************************************************************** 7384 ** 7385 ** xcb_glx_get_mapdv_reply_t * xcb_glx_get_mapdv_reply 7386 ** 7387 ** @param xcb_connection_t *c 7388 ** @param xcb_glx_get_mapdv_cookie_t cookie 7389 ** @param xcb_generic_error_t **e 7390 ** @returns xcb_glx_get_mapdv_reply_t * 7391 ** 7392 *****************************************************************************/ 7393 7394 xcb_glx_get_mapdv_reply_t * 7395 xcb_glx_get_mapdv_reply (xcb_connection_t *c /**< */, 7396 xcb_glx_get_mapdv_cookie_t cookie /**< */, 7397 xcb_generic_error_t **e /**< */) 7398 { 7399 return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7400 } 7401 7402 int 7403 xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */) 7404 { 7405 char *xcb_tmp = (char *)_buffer; 7406 const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer; 7407 unsigned int xcb_buffer_len = 0; 7408 unsigned int xcb_block_len = 0; 7409 unsigned int xcb_pad = 0; 7410 unsigned int xcb_align_to; 7411 7412 7413 xcb_block_len += sizeof(xcb_glx_get_mapfv_reply_t); 7414 xcb_tmp += xcb_block_len; 7415 /* data */ 7416 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7417 xcb_tmp += xcb_block_len; 7418 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7419 /* insert padding */ 7420 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7421 xcb_buffer_len += xcb_block_len + xcb_pad; 7422 if (0 != xcb_pad) { 7423 xcb_tmp += xcb_pad; 7424 xcb_pad = 0; 7425 } 7426 xcb_block_len = 0; 7427 7428 return xcb_buffer_len; 7429 } 7430 7431 7432 /***************************************************************************** 7433 ** 7434 ** xcb_glx_get_mapfv_cookie_t xcb_glx_get_mapfv 7435 ** 7436 ** @param xcb_connection_t *c 7437 ** @param xcb_glx_context_tag_t context_tag 7438 ** @param uint32_t target 7439 ** @param uint32_t query 7440 ** @returns xcb_glx_get_mapfv_cookie_t 7441 ** 7442 *****************************************************************************/ 7443 7444 xcb_glx_get_mapfv_cookie_t 7445 xcb_glx_get_mapfv (xcb_connection_t *c /**< */, 7446 xcb_glx_context_tag_t context_tag /**< */, 7447 uint32_t target /**< */, 7448 uint32_t query /**< */) 7449 { 7450 static const xcb_protocol_request_t xcb_req = { 7451 /* count */ 2, 7452 /* ext */ &xcb_glx_id, 7453 /* opcode */ XCB_GLX_GET_MAPFV, 7454 /* isvoid */ 0 7455 }; 7456 7457 struct iovec xcb_parts[4]; 7458 xcb_glx_get_mapfv_cookie_t xcb_ret; 7459 xcb_glx_get_mapfv_request_t xcb_out; 7460 7461 xcb_out.context_tag = context_tag; 7462 xcb_out.target = target; 7463 xcb_out.query = query; 7464 7465 xcb_parts[2].iov_base = (char *) &xcb_out; 7466 xcb_parts[2].iov_len = sizeof(xcb_out); 7467 xcb_parts[3].iov_base = 0; 7468 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7469 7470 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7471 return xcb_ret; 7472 } 7473 7474 7475 /***************************************************************************** 7476 ** 7477 ** xcb_glx_get_mapfv_cookie_t xcb_glx_get_mapfv_unchecked 7478 ** 7479 ** @param xcb_connection_t *c 7480 ** @param xcb_glx_context_tag_t context_tag 7481 ** @param uint32_t target 7482 ** @param uint32_t query 7483 ** @returns xcb_glx_get_mapfv_cookie_t 7484 ** 7485 *****************************************************************************/ 7486 7487 xcb_glx_get_mapfv_cookie_t 7488 xcb_glx_get_mapfv_unchecked (xcb_connection_t *c /**< */, 7489 xcb_glx_context_tag_t context_tag /**< */, 7490 uint32_t target /**< */, 7491 uint32_t query /**< */) 7492 { 7493 static const xcb_protocol_request_t xcb_req = { 7494 /* count */ 2, 7495 /* ext */ &xcb_glx_id, 7496 /* opcode */ XCB_GLX_GET_MAPFV, 7497 /* isvoid */ 0 7498 }; 7499 7500 struct iovec xcb_parts[4]; 7501 xcb_glx_get_mapfv_cookie_t xcb_ret; 7502 xcb_glx_get_mapfv_request_t xcb_out; 7503 7504 xcb_out.context_tag = context_tag; 7505 xcb_out.target = target; 7506 xcb_out.query = query; 7507 7508 xcb_parts[2].iov_base = (char *) &xcb_out; 7509 xcb_parts[2].iov_len = sizeof(xcb_out); 7510 xcb_parts[3].iov_base = 0; 7511 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7512 7513 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7514 return xcb_ret; 7515 } 7516 7517 7518 /***************************************************************************** 7519 ** 7520 ** xcb_glx_float32_t * xcb_glx_get_mapfv_data 7521 ** 7522 ** @param const xcb_glx_get_mapfv_reply_t *R 7523 ** @returns xcb_glx_float32_t * 7524 ** 7525 *****************************************************************************/ 7526 7527 xcb_glx_float32_t * 7528 xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R /**< */) 7529 { 7530 return (xcb_glx_float32_t *) (R + 1); 7531 } 7532 7533 7534 /***************************************************************************** 7535 ** 7536 ** int xcb_glx_get_mapfv_data_length 7537 ** 7538 ** @param const xcb_glx_get_mapfv_reply_t *R 7539 ** @returns int 7540 ** 7541 *****************************************************************************/ 7542 7543 int 7544 xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R /**< */) 7545 { 7546 return R->n; 7547 } 7548 7549 7550 /***************************************************************************** 7551 ** 7552 ** xcb_generic_iterator_t xcb_glx_get_mapfv_data_end 7553 ** 7554 ** @param const xcb_glx_get_mapfv_reply_t *R 7555 ** @returns xcb_generic_iterator_t 7556 ** 7557 *****************************************************************************/ 7558 7559 xcb_generic_iterator_t 7560 xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */) 7561 { 7562 xcb_generic_iterator_t i; 7563 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7564 i.rem = 0; 7565 i.index = (char *) i.data - (char *) R; 7566 return i; 7567 } 7568 7569 7570 /***************************************************************************** 7571 ** 7572 ** xcb_glx_get_mapfv_reply_t * xcb_glx_get_mapfv_reply 7573 ** 7574 ** @param xcb_connection_t *c 7575 ** @param xcb_glx_get_mapfv_cookie_t cookie 7576 ** @param xcb_generic_error_t **e 7577 ** @returns xcb_glx_get_mapfv_reply_t * 7578 ** 7579 *****************************************************************************/ 7580 7581 xcb_glx_get_mapfv_reply_t * 7582 xcb_glx_get_mapfv_reply (xcb_connection_t *c /**< */, 7583 xcb_glx_get_mapfv_cookie_t cookie /**< */, 7584 xcb_generic_error_t **e /**< */) 7585 { 7586 return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7587 } 7588 7589 int 7590 xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */) 7591 { 7592 char *xcb_tmp = (char *)_buffer; 7593 const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer; 7594 unsigned int xcb_buffer_len = 0; 7595 unsigned int xcb_block_len = 0; 7596 unsigned int xcb_pad = 0; 7597 unsigned int xcb_align_to; 7598 7599 7600 xcb_block_len += sizeof(xcb_glx_get_mapiv_reply_t); 7601 xcb_tmp += xcb_block_len; 7602 /* data */ 7603 xcb_block_len += _aux->n * sizeof(int32_t); 7604 xcb_tmp += xcb_block_len; 7605 xcb_align_to = ALIGNOF(int32_t); 7606 /* insert padding */ 7607 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7608 xcb_buffer_len += xcb_block_len + xcb_pad; 7609 if (0 != xcb_pad) { 7610 xcb_tmp += xcb_pad; 7611 xcb_pad = 0; 7612 } 7613 xcb_block_len = 0; 7614 7615 return xcb_buffer_len; 7616 } 7617 7618 7619 /***************************************************************************** 7620 ** 7621 ** xcb_glx_get_mapiv_cookie_t xcb_glx_get_mapiv 7622 ** 7623 ** @param xcb_connection_t *c 7624 ** @param xcb_glx_context_tag_t context_tag 7625 ** @param uint32_t target 7626 ** @param uint32_t query 7627 ** @returns xcb_glx_get_mapiv_cookie_t 7628 ** 7629 *****************************************************************************/ 7630 7631 xcb_glx_get_mapiv_cookie_t 7632 xcb_glx_get_mapiv (xcb_connection_t *c /**< */, 7633 xcb_glx_context_tag_t context_tag /**< */, 7634 uint32_t target /**< */, 7635 uint32_t query /**< */) 7636 { 7637 static const xcb_protocol_request_t xcb_req = { 7638 /* count */ 2, 7639 /* ext */ &xcb_glx_id, 7640 /* opcode */ XCB_GLX_GET_MAPIV, 7641 /* isvoid */ 0 7642 }; 7643 7644 struct iovec xcb_parts[4]; 7645 xcb_glx_get_mapiv_cookie_t xcb_ret; 7646 xcb_glx_get_mapiv_request_t xcb_out; 7647 7648 xcb_out.context_tag = context_tag; 7649 xcb_out.target = target; 7650 xcb_out.query = query; 7651 7652 xcb_parts[2].iov_base = (char *) &xcb_out; 7653 xcb_parts[2].iov_len = sizeof(xcb_out); 7654 xcb_parts[3].iov_base = 0; 7655 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7656 7657 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7658 return xcb_ret; 7659 } 7660 7661 7662 /***************************************************************************** 7663 ** 7664 ** xcb_glx_get_mapiv_cookie_t xcb_glx_get_mapiv_unchecked 7665 ** 7666 ** @param xcb_connection_t *c 7667 ** @param xcb_glx_context_tag_t context_tag 7668 ** @param uint32_t target 7669 ** @param uint32_t query 7670 ** @returns xcb_glx_get_mapiv_cookie_t 7671 ** 7672 *****************************************************************************/ 7673 7674 xcb_glx_get_mapiv_cookie_t 7675 xcb_glx_get_mapiv_unchecked (xcb_connection_t *c /**< */, 7676 xcb_glx_context_tag_t context_tag /**< */, 7677 uint32_t target /**< */, 7678 uint32_t query /**< */) 7679 { 7680 static const xcb_protocol_request_t xcb_req = { 7681 /* count */ 2, 7682 /* ext */ &xcb_glx_id, 7683 /* opcode */ XCB_GLX_GET_MAPIV, 7684 /* isvoid */ 0 7685 }; 7686 7687 struct iovec xcb_parts[4]; 7688 xcb_glx_get_mapiv_cookie_t xcb_ret; 7689 xcb_glx_get_mapiv_request_t xcb_out; 7690 7691 xcb_out.context_tag = context_tag; 7692 xcb_out.target = target; 7693 xcb_out.query = query; 7694 7695 xcb_parts[2].iov_base = (char *) &xcb_out; 7696 xcb_parts[2].iov_len = sizeof(xcb_out); 7697 xcb_parts[3].iov_base = 0; 7698 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7699 7700 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7701 return xcb_ret; 7702 } 7703 7704 7705 /***************************************************************************** 7706 ** 7707 ** int32_t * xcb_glx_get_mapiv_data 7708 ** 7709 ** @param const xcb_glx_get_mapiv_reply_t *R 7710 ** @returns int32_t * 7711 ** 7712 *****************************************************************************/ 7713 7714 int32_t * 7715 xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R /**< */) 7716 { 7717 return (int32_t *) (R + 1); 7718 } 7719 7720 7721 /***************************************************************************** 7722 ** 7723 ** int xcb_glx_get_mapiv_data_length 7724 ** 7725 ** @param const xcb_glx_get_mapiv_reply_t *R 7726 ** @returns int 7727 ** 7728 *****************************************************************************/ 7729 7730 int 7731 xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R /**< */) 7732 { 7733 return R->n; 7734 } 7735 7736 7737 /***************************************************************************** 7738 ** 7739 ** xcb_generic_iterator_t xcb_glx_get_mapiv_data_end 7740 ** 7741 ** @param const xcb_glx_get_mapiv_reply_t *R 7742 ** @returns xcb_generic_iterator_t 7743 ** 7744 *****************************************************************************/ 7745 7746 xcb_generic_iterator_t 7747 xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */) 7748 { 7749 xcb_generic_iterator_t i; 7750 i.data = ((int32_t *) (R + 1)) + (R->n); 7751 i.rem = 0; 7752 i.index = (char *) i.data - (char *) R; 7753 return i; 7754 } 7755 7756 7757 /***************************************************************************** 7758 ** 7759 ** xcb_glx_get_mapiv_reply_t * xcb_glx_get_mapiv_reply 7760 ** 7761 ** @param xcb_connection_t *c 7762 ** @param xcb_glx_get_mapiv_cookie_t cookie 7763 ** @param xcb_generic_error_t **e 7764 ** @returns xcb_glx_get_mapiv_reply_t * 7765 ** 7766 *****************************************************************************/ 7767 7768 xcb_glx_get_mapiv_reply_t * 7769 xcb_glx_get_mapiv_reply (xcb_connection_t *c /**< */, 7770 xcb_glx_get_mapiv_cookie_t cookie /**< */, 7771 xcb_generic_error_t **e /**< */) 7772 { 7773 return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7774 } 7775 7776 int 7777 xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */) 7778 { 7779 char *xcb_tmp = (char *)_buffer; 7780 const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer; 7781 unsigned int xcb_buffer_len = 0; 7782 unsigned int xcb_block_len = 0; 7783 unsigned int xcb_pad = 0; 7784 unsigned int xcb_align_to; 7785 7786 7787 xcb_block_len += sizeof(xcb_glx_get_materialfv_reply_t); 7788 xcb_tmp += xcb_block_len; 7789 /* data */ 7790 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7791 xcb_tmp += xcb_block_len; 7792 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7793 /* insert padding */ 7794 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7795 xcb_buffer_len += xcb_block_len + xcb_pad; 7796 if (0 != xcb_pad) { 7797 xcb_tmp += xcb_pad; 7798 xcb_pad = 0; 7799 } 7800 xcb_block_len = 0; 7801 7802 return xcb_buffer_len; 7803 } 7804 7805 7806 /***************************************************************************** 7807 ** 7808 ** xcb_glx_get_materialfv_cookie_t xcb_glx_get_materialfv 7809 ** 7810 ** @param xcb_connection_t *c 7811 ** @param xcb_glx_context_tag_t context_tag 7812 ** @param uint32_t face 7813 ** @param uint32_t pname 7814 ** @returns xcb_glx_get_materialfv_cookie_t 7815 ** 7816 *****************************************************************************/ 7817 7818 xcb_glx_get_materialfv_cookie_t 7819 xcb_glx_get_materialfv (xcb_connection_t *c /**< */, 7820 xcb_glx_context_tag_t context_tag /**< */, 7821 uint32_t face /**< */, 7822 uint32_t pname /**< */) 7823 { 7824 static const xcb_protocol_request_t xcb_req = { 7825 /* count */ 2, 7826 /* ext */ &xcb_glx_id, 7827 /* opcode */ XCB_GLX_GET_MATERIALFV, 7828 /* isvoid */ 0 7829 }; 7830 7831 struct iovec xcb_parts[4]; 7832 xcb_glx_get_materialfv_cookie_t xcb_ret; 7833 xcb_glx_get_materialfv_request_t xcb_out; 7834 7835 xcb_out.context_tag = context_tag; 7836 xcb_out.face = face; 7837 xcb_out.pname = pname; 7838 7839 xcb_parts[2].iov_base = (char *) &xcb_out; 7840 xcb_parts[2].iov_len = sizeof(xcb_out); 7841 xcb_parts[3].iov_base = 0; 7842 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7843 7844 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7845 return xcb_ret; 7846 } 7847 7848 7849 /***************************************************************************** 7850 ** 7851 ** xcb_glx_get_materialfv_cookie_t xcb_glx_get_materialfv_unchecked 7852 ** 7853 ** @param xcb_connection_t *c 7854 ** @param xcb_glx_context_tag_t context_tag 7855 ** @param uint32_t face 7856 ** @param uint32_t pname 7857 ** @returns xcb_glx_get_materialfv_cookie_t 7858 ** 7859 *****************************************************************************/ 7860 7861 xcb_glx_get_materialfv_cookie_t 7862 xcb_glx_get_materialfv_unchecked (xcb_connection_t *c /**< */, 7863 xcb_glx_context_tag_t context_tag /**< */, 7864 uint32_t face /**< */, 7865 uint32_t pname /**< */) 7866 { 7867 static const xcb_protocol_request_t xcb_req = { 7868 /* count */ 2, 7869 /* ext */ &xcb_glx_id, 7870 /* opcode */ XCB_GLX_GET_MATERIALFV, 7871 /* isvoid */ 0 7872 }; 7873 7874 struct iovec xcb_parts[4]; 7875 xcb_glx_get_materialfv_cookie_t xcb_ret; 7876 xcb_glx_get_materialfv_request_t xcb_out; 7877 7878 xcb_out.context_tag = context_tag; 7879 xcb_out.face = face; 7880 xcb_out.pname = pname; 7881 7882 xcb_parts[2].iov_base = (char *) &xcb_out; 7883 xcb_parts[2].iov_len = sizeof(xcb_out); 7884 xcb_parts[3].iov_base = 0; 7885 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7886 7887 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7888 return xcb_ret; 7889 } 7890 7891 7892 /***************************************************************************** 7893 ** 7894 ** xcb_glx_float32_t * xcb_glx_get_materialfv_data 7895 ** 7896 ** @param const xcb_glx_get_materialfv_reply_t *R 7897 ** @returns xcb_glx_float32_t * 7898 ** 7899 *****************************************************************************/ 7900 7901 xcb_glx_float32_t * 7902 xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R /**< */) 7903 { 7904 return (xcb_glx_float32_t *) (R + 1); 7905 } 7906 7907 7908 /***************************************************************************** 7909 ** 7910 ** int xcb_glx_get_materialfv_data_length 7911 ** 7912 ** @param const xcb_glx_get_materialfv_reply_t *R 7913 ** @returns int 7914 ** 7915 *****************************************************************************/ 7916 7917 int 7918 xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R /**< */) 7919 { 7920 return R->n; 7921 } 7922 7923 7924 /***************************************************************************** 7925 ** 7926 ** xcb_generic_iterator_t xcb_glx_get_materialfv_data_end 7927 ** 7928 ** @param const xcb_glx_get_materialfv_reply_t *R 7929 ** @returns xcb_generic_iterator_t 7930 ** 7931 *****************************************************************************/ 7932 7933 xcb_generic_iterator_t 7934 xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< */) 7935 { 7936 xcb_generic_iterator_t i; 7937 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7938 i.rem = 0; 7939 i.index = (char *) i.data - (char *) R; 7940 return i; 7941 } 7942 7943 7944 /***************************************************************************** 7945 ** 7946 ** xcb_glx_get_materialfv_reply_t * xcb_glx_get_materialfv_reply 7947 ** 7948 ** @param xcb_connection_t *c 7949 ** @param xcb_glx_get_materialfv_cookie_t cookie 7950 ** @param xcb_generic_error_t **e 7951 ** @returns xcb_glx_get_materialfv_reply_t * 7952 ** 7953 *****************************************************************************/ 7954 7955 xcb_glx_get_materialfv_reply_t * 7956 xcb_glx_get_materialfv_reply (xcb_connection_t *c /**< */, 7957 xcb_glx_get_materialfv_cookie_t cookie /**< */, 7958 xcb_generic_error_t **e /**< */) 7959 { 7960 return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7961 } 7962 7963 int 7964 xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */) 7965 { 7966 char *xcb_tmp = (char *)_buffer; 7967 const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer; 7968 unsigned int xcb_buffer_len = 0; 7969 unsigned int xcb_block_len = 0; 7970 unsigned int xcb_pad = 0; 7971 unsigned int xcb_align_to; 7972 7973 7974 xcb_block_len += sizeof(xcb_glx_get_materialiv_reply_t); 7975 xcb_tmp += xcb_block_len; 7976 /* data */ 7977 xcb_block_len += _aux->n * sizeof(int32_t); 7978 xcb_tmp += xcb_block_len; 7979 xcb_align_to = ALIGNOF(int32_t); 7980 /* insert padding */ 7981 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7982 xcb_buffer_len += xcb_block_len + xcb_pad; 7983 if (0 != xcb_pad) { 7984 xcb_tmp += xcb_pad; 7985 xcb_pad = 0; 7986 } 7987 xcb_block_len = 0; 7988 7989 return xcb_buffer_len; 7990 } 7991 7992 7993 /***************************************************************************** 7994 ** 7995 ** xcb_glx_get_materialiv_cookie_t xcb_glx_get_materialiv 7996 ** 7997 ** @param xcb_connection_t *c 7998 ** @param xcb_glx_context_tag_t context_tag 7999 ** @param uint32_t face 8000 ** @param uint32_t pname 8001 ** @returns xcb_glx_get_materialiv_cookie_t 8002 ** 8003 *****************************************************************************/ 8004 8005 xcb_glx_get_materialiv_cookie_t 8006 xcb_glx_get_materialiv (xcb_connection_t *c /**< */, 8007 xcb_glx_context_tag_t context_tag /**< */, 8008 uint32_t face /**< */, 8009 uint32_t pname /**< */) 8010 { 8011 static const xcb_protocol_request_t xcb_req = { 8012 /* count */ 2, 8013 /* ext */ &xcb_glx_id, 8014 /* opcode */ XCB_GLX_GET_MATERIALIV, 8015 /* isvoid */ 0 8016 }; 8017 8018 struct iovec xcb_parts[4]; 8019 xcb_glx_get_materialiv_cookie_t xcb_ret; 8020 xcb_glx_get_materialiv_request_t xcb_out; 8021 8022 xcb_out.context_tag = context_tag; 8023 xcb_out.face = face; 8024 xcb_out.pname = pname; 8025 8026 xcb_parts[2].iov_base = (char *) &xcb_out; 8027 xcb_parts[2].iov_len = sizeof(xcb_out); 8028 xcb_parts[3].iov_base = 0; 8029 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8030 8031 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8032 return xcb_ret; 8033 } 8034 8035 8036 /***************************************************************************** 8037 ** 8038 ** xcb_glx_get_materialiv_cookie_t xcb_glx_get_materialiv_unchecked 8039 ** 8040 ** @param xcb_connection_t *c 8041 ** @param xcb_glx_context_tag_t context_tag 8042 ** @param uint32_t face 8043 ** @param uint32_t pname 8044 ** @returns xcb_glx_get_materialiv_cookie_t 8045 ** 8046 *****************************************************************************/ 8047 8048 xcb_glx_get_materialiv_cookie_t 8049 xcb_glx_get_materialiv_unchecked (xcb_connection_t *c /**< */, 8050 xcb_glx_context_tag_t context_tag /**< */, 8051 uint32_t face /**< */, 8052 uint32_t pname /**< */) 8053 { 8054 static const xcb_protocol_request_t xcb_req = { 8055 /* count */ 2, 8056 /* ext */ &xcb_glx_id, 8057 /* opcode */ XCB_GLX_GET_MATERIALIV, 8058 /* isvoid */ 0 8059 }; 8060 8061 struct iovec xcb_parts[4]; 8062 xcb_glx_get_materialiv_cookie_t xcb_ret; 8063 xcb_glx_get_materialiv_request_t xcb_out; 8064 8065 xcb_out.context_tag = context_tag; 8066 xcb_out.face = face; 8067 xcb_out.pname = pname; 8068 8069 xcb_parts[2].iov_base = (char *) &xcb_out; 8070 xcb_parts[2].iov_len = sizeof(xcb_out); 8071 xcb_parts[3].iov_base = 0; 8072 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8073 8074 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8075 return xcb_ret; 8076 } 8077 8078 8079 /***************************************************************************** 8080 ** 8081 ** int32_t * xcb_glx_get_materialiv_data 8082 ** 8083 ** @param const xcb_glx_get_materialiv_reply_t *R 8084 ** @returns int32_t * 8085 ** 8086 *****************************************************************************/ 8087 8088 int32_t * 8089 xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R /**< */) 8090 { 8091 return (int32_t *) (R + 1); 8092 } 8093 8094 8095 /***************************************************************************** 8096 ** 8097 ** int xcb_glx_get_materialiv_data_length 8098 ** 8099 ** @param const xcb_glx_get_materialiv_reply_t *R 8100 ** @returns int 8101 ** 8102 *****************************************************************************/ 8103 8104 int 8105 xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R /**< */) 8106 { 8107 return R->n; 8108 } 8109 8110 8111 /***************************************************************************** 8112 ** 8113 ** xcb_generic_iterator_t xcb_glx_get_materialiv_data_end 8114 ** 8115 ** @param const xcb_glx_get_materialiv_reply_t *R 8116 ** @returns xcb_generic_iterator_t 8117 ** 8118 *****************************************************************************/ 8119 8120 xcb_generic_iterator_t 8121 xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< */) 8122 { 8123 xcb_generic_iterator_t i; 8124 i.data = ((int32_t *) (R + 1)) + (R->n); 8125 i.rem = 0; 8126 i.index = (char *) i.data - (char *) R; 8127 return i; 8128 } 8129 8130 8131 /***************************************************************************** 8132 ** 8133 ** xcb_glx_get_materialiv_reply_t * xcb_glx_get_materialiv_reply 8134 ** 8135 ** @param xcb_connection_t *c 8136 ** @param xcb_glx_get_materialiv_cookie_t cookie 8137 ** @param xcb_generic_error_t **e 8138 ** @returns xcb_glx_get_materialiv_reply_t * 8139 ** 8140 *****************************************************************************/ 8141 8142 xcb_glx_get_materialiv_reply_t * 8143 xcb_glx_get_materialiv_reply (xcb_connection_t *c /**< */, 8144 xcb_glx_get_materialiv_cookie_t cookie /**< */, 8145 xcb_generic_error_t **e /**< */) 8146 { 8147 return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8148 } 8149 8150 int 8151 xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */) 8152 { 8153 char *xcb_tmp = (char *)_buffer; 8154 const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer; 8155 unsigned int xcb_buffer_len = 0; 8156 unsigned int xcb_block_len = 0; 8157 unsigned int xcb_pad = 0; 8158 unsigned int xcb_align_to; 8159 8160 8161 xcb_block_len += sizeof(xcb_glx_get_pixel_mapfv_reply_t); 8162 xcb_tmp += xcb_block_len; 8163 /* data */ 8164 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8165 xcb_tmp += xcb_block_len; 8166 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8167 /* insert padding */ 8168 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8169 xcb_buffer_len += xcb_block_len + xcb_pad; 8170 if (0 != xcb_pad) { 8171 xcb_tmp += xcb_pad; 8172 xcb_pad = 0; 8173 } 8174 xcb_block_len = 0; 8175 8176 return xcb_buffer_len; 8177 } 8178 8179 8180 /***************************************************************************** 8181 ** 8182 ** xcb_glx_get_pixel_mapfv_cookie_t xcb_glx_get_pixel_mapfv 8183 ** 8184 ** @param xcb_connection_t *c 8185 ** @param xcb_glx_context_tag_t context_tag 8186 ** @param uint32_t map 8187 ** @returns xcb_glx_get_pixel_mapfv_cookie_t 8188 ** 8189 *****************************************************************************/ 8190 8191 xcb_glx_get_pixel_mapfv_cookie_t 8192 xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, 8193 xcb_glx_context_tag_t context_tag /**< */, 8194 uint32_t map /**< */) 8195 { 8196 static const xcb_protocol_request_t xcb_req = { 8197 /* count */ 2, 8198 /* ext */ &xcb_glx_id, 8199 /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, 8200 /* isvoid */ 0 8201 }; 8202 8203 struct iovec xcb_parts[4]; 8204 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 8205 xcb_glx_get_pixel_mapfv_request_t xcb_out; 8206 8207 xcb_out.context_tag = context_tag; 8208 xcb_out.map = map; 8209 8210 xcb_parts[2].iov_base = (char *) &xcb_out; 8211 xcb_parts[2].iov_len = sizeof(xcb_out); 8212 xcb_parts[3].iov_base = 0; 8213 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8214 8215 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8216 return xcb_ret; 8217 } 8218 8219 8220 /***************************************************************************** 8221 ** 8222 ** xcb_glx_get_pixel_mapfv_cookie_t xcb_glx_get_pixel_mapfv_unchecked 8223 ** 8224 ** @param xcb_connection_t *c 8225 ** @param xcb_glx_context_tag_t context_tag 8226 ** @param uint32_t map 8227 ** @returns xcb_glx_get_pixel_mapfv_cookie_t 8228 ** 8229 *****************************************************************************/ 8230 8231 xcb_glx_get_pixel_mapfv_cookie_t 8232 xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c /**< */, 8233 xcb_glx_context_tag_t context_tag /**< */, 8234 uint32_t map /**< */) 8235 { 8236 static const xcb_protocol_request_t xcb_req = { 8237 /* count */ 2, 8238 /* ext */ &xcb_glx_id, 8239 /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, 8240 /* isvoid */ 0 8241 }; 8242 8243 struct iovec xcb_parts[4]; 8244 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 8245 xcb_glx_get_pixel_mapfv_request_t xcb_out; 8246 8247 xcb_out.context_tag = context_tag; 8248 xcb_out.map = map; 8249 8250 xcb_parts[2].iov_base = (char *) &xcb_out; 8251 xcb_parts[2].iov_len = sizeof(xcb_out); 8252 xcb_parts[3].iov_base = 0; 8253 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8254 8255 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8256 return xcb_ret; 8257 } 8258 8259 8260 /***************************************************************************** 8261 ** 8262 ** xcb_glx_float32_t * xcb_glx_get_pixel_mapfv_data 8263 ** 8264 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8265 ** @returns xcb_glx_float32_t * 8266 ** 8267 *****************************************************************************/ 8268 8269 xcb_glx_float32_t * 8270 xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8271 { 8272 return (xcb_glx_float32_t *) (R + 1); 8273 } 8274 8275 8276 /***************************************************************************** 8277 ** 8278 ** int xcb_glx_get_pixel_mapfv_data_length 8279 ** 8280 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8281 ** @returns int 8282 ** 8283 *****************************************************************************/ 8284 8285 int 8286 xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8287 { 8288 return R->n; 8289 } 8290 8291 8292 /***************************************************************************** 8293 ** 8294 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapfv_data_end 8295 ** 8296 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8297 ** @returns xcb_generic_iterator_t 8298 ** 8299 *****************************************************************************/ 8300 8301 xcb_generic_iterator_t 8302 xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8303 { 8304 xcb_generic_iterator_t i; 8305 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8306 i.rem = 0; 8307 i.index = (char *) i.data - (char *) R; 8308 return i; 8309 } 8310 8311 8312 /***************************************************************************** 8313 ** 8314 ** xcb_glx_get_pixel_mapfv_reply_t * xcb_glx_get_pixel_mapfv_reply 8315 ** 8316 ** @param xcb_connection_t *c 8317 ** @param xcb_glx_get_pixel_mapfv_cookie_t cookie 8318 ** @param xcb_generic_error_t **e 8319 ** @returns xcb_glx_get_pixel_mapfv_reply_t * 8320 ** 8321 *****************************************************************************/ 8322 8323 xcb_glx_get_pixel_mapfv_reply_t * 8324 xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c /**< */, 8325 xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, 8326 xcb_generic_error_t **e /**< */) 8327 { 8328 return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8329 } 8330 8331 int 8332 xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */) 8333 { 8334 char *xcb_tmp = (char *)_buffer; 8335 const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer; 8336 unsigned int xcb_buffer_len = 0; 8337 unsigned int xcb_block_len = 0; 8338 unsigned int xcb_pad = 0; 8339 unsigned int xcb_align_to; 8340 8341 8342 xcb_block_len += sizeof(xcb_glx_get_pixel_mapuiv_reply_t); 8343 xcb_tmp += xcb_block_len; 8344 /* data */ 8345 xcb_block_len += _aux->n * sizeof(uint32_t); 8346 xcb_tmp += xcb_block_len; 8347 xcb_align_to = ALIGNOF(uint32_t); 8348 /* insert padding */ 8349 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8350 xcb_buffer_len += xcb_block_len + xcb_pad; 8351 if (0 != xcb_pad) { 8352 xcb_tmp += xcb_pad; 8353 xcb_pad = 0; 8354 } 8355 xcb_block_len = 0; 8356 8357 return xcb_buffer_len; 8358 } 8359 8360 8361 /***************************************************************************** 8362 ** 8363 ** xcb_glx_get_pixel_mapuiv_cookie_t xcb_glx_get_pixel_mapuiv 8364 ** 8365 ** @param xcb_connection_t *c 8366 ** @param xcb_glx_context_tag_t context_tag 8367 ** @param uint32_t map 8368 ** @returns xcb_glx_get_pixel_mapuiv_cookie_t 8369 ** 8370 *****************************************************************************/ 8371 8372 xcb_glx_get_pixel_mapuiv_cookie_t 8373 xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, 8374 xcb_glx_context_tag_t context_tag /**< */, 8375 uint32_t map /**< */) 8376 { 8377 static const xcb_protocol_request_t xcb_req = { 8378 /* count */ 2, 8379 /* ext */ &xcb_glx_id, 8380 /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, 8381 /* isvoid */ 0 8382 }; 8383 8384 struct iovec xcb_parts[4]; 8385 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 8386 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 8387 8388 xcb_out.context_tag = context_tag; 8389 xcb_out.map = map; 8390 8391 xcb_parts[2].iov_base = (char *) &xcb_out; 8392 xcb_parts[2].iov_len = sizeof(xcb_out); 8393 xcb_parts[3].iov_base = 0; 8394 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8395 8396 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8397 return xcb_ret; 8398 } 8399 8400 8401 /***************************************************************************** 8402 ** 8403 ** xcb_glx_get_pixel_mapuiv_cookie_t xcb_glx_get_pixel_mapuiv_unchecked 8404 ** 8405 ** @param xcb_connection_t *c 8406 ** @param xcb_glx_context_tag_t context_tag 8407 ** @param uint32_t map 8408 ** @returns xcb_glx_get_pixel_mapuiv_cookie_t 8409 ** 8410 *****************************************************************************/ 8411 8412 xcb_glx_get_pixel_mapuiv_cookie_t 8413 xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c /**< */, 8414 xcb_glx_context_tag_t context_tag /**< */, 8415 uint32_t map /**< */) 8416 { 8417 static const xcb_protocol_request_t xcb_req = { 8418 /* count */ 2, 8419 /* ext */ &xcb_glx_id, 8420 /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, 8421 /* isvoid */ 0 8422 }; 8423 8424 struct iovec xcb_parts[4]; 8425 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 8426 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 8427 8428 xcb_out.context_tag = context_tag; 8429 xcb_out.map = map; 8430 8431 xcb_parts[2].iov_base = (char *) &xcb_out; 8432 xcb_parts[2].iov_len = sizeof(xcb_out); 8433 xcb_parts[3].iov_base = 0; 8434 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8435 8436 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8437 return xcb_ret; 8438 } 8439 8440 8441 /***************************************************************************** 8442 ** 8443 ** uint32_t * xcb_glx_get_pixel_mapuiv_data 8444 ** 8445 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8446 ** @returns uint32_t * 8447 ** 8448 *****************************************************************************/ 8449 8450 uint32_t * 8451 xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8452 { 8453 return (uint32_t *) (R + 1); 8454 } 8455 8456 8457 /***************************************************************************** 8458 ** 8459 ** int xcb_glx_get_pixel_mapuiv_data_length 8460 ** 8461 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8462 ** @returns int 8463 ** 8464 *****************************************************************************/ 8465 8466 int 8467 xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8468 { 8469 return R->n; 8470 } 8471 8472 8473 /***************************************************************************** 8474 ** 8475 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapuiv_data_end 8476 ** 8477 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8478 ** @returns xcb_generic_iterator_t 8479 ** 8480 *****************************************************************************/ 8481 8482 xcb_generic_iterator_t 8483 xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8484 { 8485 xcb_generic_iterator_t i; 8486 i.data = ((uint32_t *) (R + 1)) + (R->n); 8487 i.rem = 0; 8488 i.index = (char *) i.data - (char *) R; 8489 return i; 8490 } 8491 8492 8493 /***************************************************************************** 8494 ** 8495 ** xcb_glx_get_pixel_mapuiv_reply_t * xcb_glx_get_pixel_mapuiv_reply 8496 ** 8497 ** @param xcb_connection_t *c 8498 ** @param xcb_glx_get_pixel_mapuiv_cookie_t cookie 8499 ** @param xcb_generic_error_t **e 8500 ** @returns xcb_glx_get_pixel_mapuiv_reply_t * 8501 ** 8502 *****************************************************************************/ 8503 8504 xcb_glx_get_pixel_mapuiv_reply_t * 8505 xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c /**< */, 8506 xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, 8507 xcb_generic_error_t **e /**< */) 8508 { 8509 return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8510 } 8511 8512 int 8513 xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */) 8514 { 8515 char *xcb_tmp = (char *)_buffer; 8516 const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer; 8517 unsigned int xcb_buffer_len = 0; 8518 unsigned int xcb_block_len = 0; 8519 unsigned int xcb_pad = 0; 8520 unsigned int xcb_align_to; 8521 8522 8523 xcb_block_len += sizeof(xcb_glx_get_pixel_mapusv_reply_t); 8524 xcb_tmp += xcb_block_len; 8525 /* data */ 8526 xcb_block_len += _aux->n * sizeof(uint16_t); 8527 xcb_tmp += xcb_block_len; 8528 xcb_align_to = ALIGNOF(uint16_t); 8529 /* insert padding */ 8530 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8531 xcb_buffer_len += xcb_block_len + xcb_pad; 8532 if (0 != xcb_pad) { 8533 xcb_tmp += xcb_pad; 8534 xcb_pad = 0; 8535 } 8536 xcb_block_len = 0; 8537 8538 return xcb_buffer_len; 8539 } 8540 8541 8542 /***************************************************************************** 8543 ** 8544 ** xcb_glx_get_pixel_mapusv_cookie_t xcb_glx_get_pixel_mapusv 8545 ** 8546 ** @param xcb_connection_t *c 8547 ** @param xcb_glx_context_tag_t context_tag 8548 ** @param uint32_t map 8549 ** @returns xcb_glx_get_pixel_mapusv_cookie_t 8550 ** 8551 *****************************************************************************/ 8552 8553 xcb_glx_get_pixel_mapusv_cookie_t 8554 xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, 8555 xcb_glx_context_tag_t context_tag /**< */, 8556 uint32_t map /**< */) 8557 { 8558 static const xcb_protocol_request_t xcb_req = { 8559 /* count */ 2, 8560 /* ext */ &xcb_glx_id, 8561 /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, 8562 /* isvoid */ 0 8563 }; 8564 8565 struct iovec xcb_parts[4]; 8566 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 8567 xcb_glx_get_pixel_mapusv_request_t xcb_out; 8568 8569 xcb_out.context_tag = context_tag; 8570 xcb_out.map = map; 8571 8572 xcb_parts[2].iov_base = (char *) &xcb_out; 8573 xcb_parts[2].iov_len = sizeof(xcb_out); 8574 xcb_parts[3].iov_base = 0; 8575 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8576 8577 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8578 return xcb_ret; 8579 } 8580 8581 8582 /***************************************************************************** 8583 ** 8584 ** xcb_glx_get_pixel_mapusv_cookie_t xcb_glx_get_pixel_mapusv_unchecked 8585 ** 8586 ** @param xcb_connection_t *c 8587 ** @param xcb_glx_context_tag_t context_tag 8588 ** @param uint32_t map 8589 ** @returns xcb_glx_get_pixel_mapusv_cookie_t 8590 ** 8591 *****************************************************************************/ 8592 8593 xcb_glx_get_pixel_mapusv_cookie_t 8594 xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c /**< */, 8595 xcb_glx_context_tag_t context_tag /**< */, 8596 uint32_t map /**< */) 8597 { 8598 static const xcb_protocol_request_t xcb_req = { 8599 /* count */ 2, 8600 /* ext */ &xcb_glx_id, 8601 /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, 8602 /* isvoid */ 0 8603 }; 8604 8605 struct iovec xcb_parts[4]; 8606 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 8607 xcb_glx_get_pixel_mapusv_request_t xcb_out; 8608 8609 xcb_out.context_tag = context_tag; 8610 xcb_out.map = map; 8611 8612 xcb_parts[2].iov_base = (char *) &xcb_out; 8613 xcb_parts[2].iov_len = sizeof(xcb_out); 8614 xcb_parts[3].iov_base = 0; 8615 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8616 8617 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8618 return xcb_ret; 8619 } 8620 8621 8622 /***************************************************************************** 8623 ** 8624 ** uint16_t * xcb_glx_get_pixel_mapusv_data 8625 ** 8626 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8627 ** @returns uint16_t * 8628 ** 8629 *****************************************************************************/ 8630 8631 uint16_t * 8632 xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8633 { 8634 return (uint16_t *) (R + 1); 8635 } 8636 8637 8638 /***************************************************************************** 8639 ** 8640 ** int xcb_glx_get_pixel_mapusv_data_length 8641 ** 8642 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8643 ** @returns int 8644 ** 8645 *****************************************************************************/ 8646 8647 int 8648 xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8649 { 8650 return R->n; 8651 } 8652 8653 8654 /***************************************************************************** 8655 ** 8656 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapusv_data_end 8657 ** 8658 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8659 ** @returns xcb_generic_iterator_t 8660 ** 8661 *****************************************************************************/ 8662 8663 xcb_generic_iterator_t 8664 xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8665 { 8666 xcb_generic_iterator_t i; 8667 i.data = ((uint16_t *) (R + 1)) + (R->n); 8668 i.rem = 0; 8669 i.index = (char *) i.data - (char *) R; 8670 return i; 8671 } 8672 8673 8674 /***************************************************************************** 8675 ** 8676 ** xcb_glx_get_pixel_mapusv_reply_t * xcb_glx_get_pixel_mapusv_reply 8677 ** 8678 ** @param xcb_connection_t *c 8679 ** @param xcb_glx_get_pixel_mapusv_cookie_t cookie 8680 ** @param xcb_generic_error_t **e 8681 ** @returns xcb_glx_get_pixel_mapusv_reply_t * 8682 ** 8683 *****************************************************************************/ 8684 8685 xcb_glx_get_pixel_mapusv_reply_t * 8686 xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c /**< */, 8687 xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, 8688 xcb_generic_error_t **e /**< */) 8689 { 8690 return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8691 } 8692 8693 int 8694 xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */) 8695 { 8696 char *xcb_tmp = (char *)_buffer; 8697 const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer; 8698 unsigned int xcb_buffer_len = 0; 8699 unsigned int xcb_block_len = 0; 8700 unsigned int xcb_pad = 0; 8701 unsigned int xcb_align_to; 8702 8703 8704 xcb_block_len += sizeof(xcb_glx_get_polygon_stipple_reply_t); 8705 xcb_tmp += xcb_block_len; 8706 /* data */ 8707 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8708 xcb_tmp += xcb_block_len; 8709 xcb_align_to = ALIGNOF(uint8_t); 8710 /* insert padding */ 8711 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8712 xcb_buffer_len += xcb_block_len + xcb_pad; 8713 if (0 != xcb_pad) { 8714 xcb_tmp += xcb_pad; 8715 xcb_pad = 0; 8716 } 8717 xcb_block_len = 0; 8718 8719 return xcb_buffer_len; 8720 } 8721 8722 8723 /***************************************************************************** 8724 ** 8725 ** xcb_glx_get_polygon_stipple_cookie_t xcb_glx_get_polygon_stipple 8726 ** 8727 ** @param xcb_connection_t *c 8728 ** @param xcb_glx_context_tag_t context_tag 8729 ** @param uint8_t lsb_first 8730 ** @returns xcb_glx_get_polygon_stipple_cookie_t 8731 ** 8732 *****************************************************************************/ 8733 8734 xcb_glx_get_polygon_stipple_cookie_t 8735 xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, 8736 xcb_glx_context_tag_t context_tag /**< */, 8737 uint8_t lsb_first /**< */) 8738 { 8739 static const xcb_protocol_request_t xcb_req = { 8740 /* count */ 2, 8741 /* ext */ &xcb_glx_id, 8742 /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, 8743 /* isvoid */ 0 8744 }; 8745 8746 struct iovec xcb_parts[4]; 8747 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 8748 xcb_glx_get_polygon_stipple_request_t xcb_out; 8749 8750 xcb_out.context_tag = context_tag; 8751 xcb_out.lsb_first = lsb_first; 8752 8753 xcb_parts[2].iov_base = (char *) &xcb_out; 8754 xcb_parts[2].iov_len = sizeof(xcb_out); 8755 xcb_parts[3].iov_base = 0; 8756 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8757 8758 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8759 return xcb_ret; 8760 } 8761 8762 8763 /***************************************************************************** 8764 ** 8765 ** xcb_glx_get_polygon_stipple_cookie_t xcb_glx_get_polygon_stipple_unchecked 8766 ** 8767 ** @param xcb_connection_t *c 8768 ** @param xcb_glx_context_tag_t context_tag 8769 ** @param uint8_t lsb_first 8770 ** @returns xcb_glx_get_polygon_stipple_cookie_t 8771 ** 8772 *****************************************************************************/ 8773 8774 xcb_glx_get_polygon_stipple_cookie_t 8775 xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c /**< */, 8776 xcb_glx_context_tag_t context_tag /**< */, 8777 uint8_t lsb_first /**< */) 8778 { 8779 static const xcb_protocol_request_t xcb_req = { 8780 /* count */ 2, 8781 /* ext */ &xcb_glx_id, 8782 /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, 8783 /* isvoid */ 0 8784 }; 8785 8786 struct iovec xcb_parts[4]; 8787 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 8788 xcb_glx_get_polygon_stipple_request_t xcb_out; 8789 8790 xcb_out.context_tag = context_tag; 8791 xcb_out.lsb_first = lsb_first; 8792 8793 xcb_parts[2].iov_base = (char *) &xcb_out; 8794 xcb_parts[2].iov_len = sizeof(xcb_out); 8795 xcb_parts[3].iov_base = 0; 8796 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8797 8798 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8799 return xcb_ret; 8800 } 8801 8802 8803 /***************************************************************************** 8804 ** 8805 ** uint8_t * xcb_glx_get_polygon_stipple_data 8806 ** 8807 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8808 ** @returns uint8_t * 8809 ** 8810 *****************************************************************************/ 8811 8812 uint8_t * 8813 xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8814 { 8815 return (uint8_t *) (R + 1); 8816 } 8817 8818 8819 /***************************************************************************** 8820 ** 8821 ** int xcb_glx_get_polygon_stipple_data_length 8822 ** 8823 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8824 ** @returns int 8825 ** 8826 *****************************************************************************/ 8827 8828 int 8829 xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8830 { 8831 return (R->length * 4); 8832 } 8833 8834 8835 /***************************************************************************** 8836 ** 8837 ** xcb_generic_iterator_t xcb_glx_get_polygon_stipple_data_end 8838 ** 8839 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8840 ** @returns xcb_generic_iterator_t 8841 ** 8842 *****************************************************************************/ 8843 8844 xcb_generic_iterator_t 8845 xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8846 { 8847 xcb_generic_iterator_t i; 8848 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8849 i.rem = 0; 8850 i.index = (char *) i.data - (char *) R; 8851 return i; 8852 } 8853 8854 8855 /***************************************************************************** 8856 ** 8857 ** xcb_glx_get_polygon_stipple_reply_t * xcb_glx_get_polygon_stipple_reply 8858 ** 8859 ** @param xcb_connection_t *c 8860 ** @param xcb_glx_get_polygon_stipple_cookie_t cookie 8861 ** @param xcb_generic_error_t **e 8862 ** @returns xcb_glx_get_polygon_stipple_reply_t * 8863 ** 8864 *****************************************************************************/ 8865 8866 xcb_glx_get_polygon_stipple_reply_t * 8867 xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c /**< */, 8868 xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, 8869 xcb_generic_error_t **e /**< */) 8870 { 8871 return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8872 } 8873 8874 int 8875 xcb_glx_get_string_sizeof (const void *_buffer /**< */) 8876 { 8877 char *xcb_tmp = (char *)_buffer; 8878 const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer; 8879 unsigned int xcb_buffer_len = 0; 8880 unsigned int xcb_block_len = 0; 8881 unsigned int xcb_pad = 0; 8882 unsigned int xcb_align_to; 8883 8884 8885 xcb_block_len += sizeof(xcb_glx_get_string_reply_t); 8886 xcb_tmp += xcb_block_len; 8887 /* string */ 8888 xcb_block_len += _aux->n * sizeof(char); 8889 xcb_tmp += xcb_block_len; 8890 xcb_align_to = ALIGNOF(char); 8891 /* insert padding */ 8892 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8893 xcb_buffer_len += xcb_block_len + xcb_pad; 8894 if (0 != xcb_pad) { 8895 xcb_tmp += xcb_pad; 8896 xcb_pad = 0; 8897 } 8898 xcb_block_len = 0; 8899 8900 return xcb_buffer_len; 8901 } 8902 8903 8904 /***************************************************************************** 8905 ** 8906 ** xcb_glx_get_string_cookie_t xcb_glx_get_string 8907 ** 8908 ** @param xcb_connection_t *c 8909 ** @param xcb_glx_context_tag_t context_tag 8910 ** @param uint32_t name 8911 ** @returns xcb_glx_get_string_cookie_t 8912 ** 8913 *****************************************************************************/ 8914 8915 xcb_glx_get_string_cookie_t 8916 xcb_glx_get_string (xcb_connection_t *c /**< */, 8917 xcb_glx_context_tag_t context_tag /**< */, 8918 uint32_t name /**< */) 8919 { 8920 static const xcb_protocol_request_t xcb_req = { 8921 /* count */ 2, 8922 /* ext */ &xcb_glx_id, 8923 /* opcode */ XCB_GLX_GET_STRING, 8924 /* isvoid */ 0 8925 }; 8926 8927 struct iovec xcb_parts[4]; 8928 xcb_glx_get_string_cookie_t xcb_ret; 8929 xcb_glx_get_string_request_t xcb_out; 8930 8931 xcb_out.context_tag = context_tag; 8932 xcb_out.name = name; 8933 8934 xcb_parts[2].iov_base = (char *) &xcb_out; 8935 xcb_parts[2].iov_len = sizeof(xcb_out); 8936 xcb_parts[3].iov_base = 0; 8937 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8938 8939 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8940 return xcb_ret; 8941 } 8942 8943 8944 /***************************************************************************** 8945 ** 8946 ** xcb_glx_get_string_cookie_t xcb_glx_get_string_unchecked 8947 ** 8948 ** @param xcb_connection_t *c 8949 ** @param xcb_glx_context_tag_t context_tag 8950 ** @param uint32_t name 8951 ** @returns xcb_glx_get_string_cookie_t 8952 ** 8953 *****************************************************************************/ 8954 8955 xcb_glx_get_string_cookie_t 8956 xcb_glx_get_string_unchecked (xcb_connection_t *c /**< */, 8957 xcb_glx_context_tag_t context_tag /**< */, 8958 uint32_t name /**< */) 8959 { 8960 static const xcb_protocol_request_t xcb_req = { 8961 /* count */ 2, 8962 /* ext */ &xcb_glx_id, 8963 /* opcode */ XCB_GLX_GET_STRING, 8964 /* isvoid */ 0 8965 }; 8966 8967 struct iovec xcb_parts[4]; 8968 xcb_glx_get_string_cookie_t xcb_ret; 8969 xcb_glx_get_string_request_t xcb_out; 8970 8971 xcb_out.context_tag = context_tag; 8972 xcb_out.name = name; 8973 8974 xcb_parts[2].iov_base = (char *) &xcb_out; 8975 xcb_parts[2].iov_len = sizeof(xcb_out); 8976 xcb_parts[3].iov_base = 0; 8977 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8978 8979 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8980 return xcb_ret; 8981 } 8982 8983 8984 /***************************************************************************** 8985 ** 8986 ** char * xcb_glx_get_string_string 8987 ** 8988 ** @param const xcb_glx_get_string_reply_t *R 8989 ** @returns char * 8990 ** 8991 *****************************************************************************/ 8992 8993 char * 8994 xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R /**< */) 8995 { 8996 return (char *) (R + 1); 8997 } 8998 8999 9000 /***************************************************************************** 9001 ** 9002 ** int xcb_glx_get_string_string_length 9003 ** 9004 ** @param const xcb_glx_get_string_reply_t *R 9005 ** @returns int 9006 ** 9007 *****************************************************************************/ 9008 9009 int 9010 xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R /**< */) 9011 { 9012 return R->n; 9013 } 9014 9015 9016 /***************************************************************************** 9017 ** 9018 ** xcb_generic_iterator_t xcb_glx_get_string_string_end 9019 ** 9020 ** @param const xcb_glx_get_string_reply_t *R 9021 ** @returns xcb_generic_iterator_t 9022 ** 9023 *****************************************************************************/ 9024 9025 xcb_generic_iterator_t 9026 xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */) 9027 { 9028 xcb_generic_iterator_t i; 9029 i.data = ((char *) (R + 1)) + (R->n); 9030 i.rem = 0; 9031 i.index = (char *) i.data - (char *) R; 9032 return i; 9033 } 9034 9035 9036 /***************************************************************************** 9037 ** 9038 ** xcb_glx_get_string_reply_t * xcb_glx_get_string_reply 9039 ** 9040 ** @param xcb_connection_t *c 9041 ** @param xcb_glx_get_string_cookie_t cookie 9042 ** @param xcb_generic_error_t **e 9043 ** @returns xcb_glx_get_string_reply_t * 9044 ** 9045 *****************************************************************************/ 9046 9047 xcb_glx_get_string_reply_t * 9048 xcb_glx_get_string_reply (xcb_connection_t *c /**< */, 9049 xcb_glx_get_string_cookie_t cookie /**< */, 9050 xcb_generic_error_t **e /**< */) 9051 { 9052 return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9053 } 9054 9055 int 9056 xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */) 9057 { 9058 char *xcb_tmp = (char *)_buffer; 9059 const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer; 9060 unsigned int xcb_buffer_len = 0; 9061 unsigned int xcb_block_len = 0; 9062 unsigned int xcb_pad = 0; 9063 unsigned int xcb_align_to; 9064 9065 9066 xcb_block_len += sizeof(xcb_glx_get_tex_envfv_reply_t); 9067 xcb_tmp += xcb_block_len; 9068 /* data */ 9069 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9070 xcb_tmp += xcb_block_len; 9071 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9072 /* insert padding */ 9073 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9074 xcb_buffer_len += xcb_block_len + xcb_pad; 9075 if (0 != xcb_pad) { 9076 xcb_tmp += xcb_pad; 9077 xcb_pad = 0; 9078 } 9079 xcb_block_len = 0; 9080 9081 return xcb_buffer_len; 9082 } 9083 9084 9085 /***************************************************************************** 9086 ** 9087 ** xcb_glx_get_tex_envfv_cookie_t xcb_glx_get_tex_envfv 9088 ** 9089 ** @param xcb_connection_t *c 9090 ** @param xcb_glx_context_tag_t context_tag 9091 ** @param uint32_t target 9092 ** @param uint32_t pname 9093 ** @returns xcb_glx_get_tex_envfv_cookie_t 9094 ** 9095 *****************************************************************************/ 9096 9097 xcb_glx_get_tex_envfv_cookie_t 9098 xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, 9099 xcb_glx_context_tag_t context_tag /**< */, 9100 uint32_t target /**< */, 9101 uint32_t pname /**< */) 9102 { 9103 static const xcb_protocol_request_t xcb_req = { 9104 /* count */ 2, 9105 /* ext */ &xcb_glx_id, 9106 /* opcode */ XCB_GLX_GET_TEX_ENVFV, 9107 /* isvoid */ 0 9108 }; 9109 9110 struct iovec xcb_parts[4]; 9111 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 9112 xcb_glx_get_tex_envfv_request_t xcb_out; 9113 9114 xcb_out.context_tag = context_tag; 9115 xcb_out.target = target; 9116 xcb_out.pname = pname; 9117 9118 xcb_parts[2].iov_base = (char *) &xcb_out; 9119 xcb_parts[2].iov_len = sizeof(xcb_out); 9120 xcb_parts[3].iov_base = 0; 9121 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9122 9123 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9124 return xcb_ret; 9125 } 9126 9127 9128 /***************************************************************************** 9129 ** 9130 ** xcb_glx_get_tex_envfv_cookie_t xcb_glx_get_tex_envfv_unchecked 9131 ** 9132 ** @param xcb_connection_t *c 9133 ** @param xcb_glx_context_tag_t context_tag 9134 ** @param uint32_t target 9135 ** @param uint32_t pname 9136 ** @returns xcb_glx_get_tex_envfv_cookie_t 9137 ** 9138 *****************************************************************************/ 9139 9140 xcb_glx_get_tex_envfv_cookie_t 9141 xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c /**< */, 9142 xcb_glx_context_tag_t context_tag /**< */, 9143 uint32_t target /**< */, 9144 uint32_t pname /**< */) 9145 { 9146 static const xcb_protocol_request_t xcb_req = { 9147 /* count */ 2, 9148 /* ext */ &xcb_glx_id, 9149 /* opcode */ XCB_GLX_GET_TEX_ENVFV, 9150 /* isvoid */ 0 9151 }; 9152 9153 struct iovec xcb_parts[4]; 9154 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 9155 xcb_glx_get_tex_envfv_request_t xcb_out; 9156 9157 xcb_out.context_tag = context_tag; 9158 xcb_out.target = target; 9159 xcb_out.pname = pname; 9160 9161 xcb_parts[2].iov_base = (char *) &xcb_out; 9162 xcb_parts[2].iov_len = sizeof(xcb_out); 9163 xcb_parts[3].iov_base = 0; 9164 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9165 9166 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9167 return xcb_ret; 9168 } 9169 9170 9171 /***************************************************************************** 9172 ** 9173 ** xcb_glx_float32_t * xcb_glx_get_tex_envfv_data 9174 ** 9175 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9176 ** @returns xcb_glx_float32_t * 9177 ** 9178 *****************************************************************************/ 9179 9180 xcb_glx_float32_t * 9181 xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9182 { 9183 return (xcb_glx_float32_t *) (R + 1); 9184 } 9185 9186 9187 /***************************************************************************** 9188 ** 9189 ** int xcb_glx_get_tex_envfv_data_length 9190 ** 9191 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9192 ** @returns int 9193 ** 9194 *****************************************************************************/ 9195 9196 int 9197 xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9198 { 9199 return R->n; 9200 } 9201 9202 9203 /***************************************************************************** 9204 ** 9205 ** xcb_generic_iterator_t xcb_glx_get_tex_envfv_data_end 9206 ** 9207 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9208 ** @returns xcb_generic_iterator_t 9209 ** 9210 *****************************************************************************/ 9211 9212 xcb_generic_iterator_t 9213 xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9214 { 9215 xcb_generic_iterator_t i; 9216 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9217 i.rem = 0; 9218 i.index = (char *) i.data - (char *) R; 9219 return i; 9220 } 9221 9222 9223 /***************************************************************************** 9224 ** 9225 ** xcb_glx_get_tex_envfv_reply_t * xcb_glx_get_tex_envfv_reply 9226 ** 9227 ** @param xcb_connection_t *c 9228 ** @param xcb_glx_get_tex_envfv_cookie_t cookie 9229 ** @param xcb_generic_error_t **e 9230 ** @returns xcb_glx_get_tex_envfv_reply_t * 9231 ** 9232 *****************************************************************************/ 9233 9234 xcb_glx_get_tex_envfv_reply_t * 9235 xcb_glx_get_tex_envfv_reply (xcb_connection_t *c /**< */, 9236 xcb_glx_get_tex_envfv_cookie_t cookie /**< */, 9237 xcb_generic_error_t **e /**< */) 9238 { 9239 return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9240 } 9241 9242 int 9243 xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */) 9244 { 9245 char *xcb_tmp = (char *)_buffer; 9246 const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer; 9247 unsigned int xcb_buffer_len = 0; 9248 unsigned int xcb_block_len = 0; 9249 unsigned int xcb_pad = 0; 9250 unsigned int xcb_align_to; 9251 9252 9253 xcb_block_len += sizeof(xcb_glx_get_tex_enviv_reply_t); 9254 xcb_tmp += xcb_block_len; 9255 /* data */ 9256 xcb_block_len += _aux->n * sizeof(int32_t); 9257 xcb_tmp += xcb_block_len; 9258 xcb_align_to = ALIGNOF(int32_t); 9259 /* insert padding */ 9260 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9261 xcb_buffer_len += xcb_block_len + xcb_pad; 9262 if (0 != xcb_pad) { 9263 xcb_tmp += xcb_pad; 9264 xcb_pad = 0; 9265 } 9266 xcb_block_len = 0; 9267 9268 return xcb_buffer_len; 9269 } 9270 9271 9272 /***************************************************************************** 9273 ** 9274 ** xcb_glx_get_tex_enviv_cookie_t xcb_glx_get_tex_enviv 9275 ** 9276 ** @param xcb_connection_t *c 9277 ** @param xcb_glx_context_tag_t context_tag 9278 ** @param uint32_t target 9279 ** @param uint32_t pname 9280 ** @returns xcb_glx_get_tex_enviv_cookie_t 9281 ** 9282 *****************************************************************************/ 9283 9284 xcb_glx_get_tex_enviv_cookie_t 9285 xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, 9286 xcb_glx_context_tag_t context_tag /**< */, 9287 uint32_t target /**< */, 9288 uint32_t pname /**< */) 9289 { 9290 static const xcb_protocol_request_t xcb_req = { 9291 /* count */ 2, 9292 /* ext */ &xcb_glx_id, 9293 /* opcode */ XCB_GLX_GET_TEX_ENVIV, 9294 /* isvoid */ 0 9295 }; 9296 9297 struct iovec xcb_parts[4]; 9298 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 9299 xcb_glx_get_tex_enviv_request_t xcb_out; 9300 9301 xcb_out.context_tag = context_tag; 9302 xcb_out.target = target; 9303 xcb_out.pname = pname; 9304 9305 xcb_parts[2].iov_base = (char *) &xcb_out; 9306 xcb_parts[2].iov_len = sizeof(xcb_out); 9307 xcb_parts[3].iov_base = 0; 9308 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9309 9310 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9311 return xcb_ret; 9312 } 9313 9314 9315 /***************************************************************************** 9316 ** 9317 ** xcb_glx_get_tex_enviv_cookie_t xcb_glx_get_tex_enviv_unchecked 9318 ** 9319 ** @param xcb_connection_t *c 9320 ** @param xcb_glx_context_tag_t context_tag 9321 ** @param uint32_t target 9322 ** @param uint32_t pname 9323 ** @returns xcb_glx_get_tex_enviv_cookie_t 9324 ** 9325 *****************************************************************************/ 9326 9327 xcb_glx_get_tex_enviv_cookie_t 9328 xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c /**< */, 9329 xcb_glx_context_tag_t context_tag /**< */, 9330 uint32_t target /**< */, 9331 uint32_t pname /**< */) 9332 { 9333 static const xcb_protocol_request_t xcb_req = { 9334 /* count */ 2, 9335 /* ext */ &xcb_glx_id, 9336 /* opcode */ XCB_GLX_GET_TEX_ENVIV, 9337 /* isvoid */ 0 9338 }; 9339 9340 struct iovec xcb_parts[4]; 9341 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 9342 xcb_glx_get_tex_enviv_request_t xcb_out; 9343 9344 xcb_out.context_tag = context_tag; 9345 xcb_out.target = target; 9346 xcb_out.pname = pname; 9347 9348 xcb_parts[2].iov_base = (char *) &xcb_out; 9349 xcb_parts[2].iov_len = sizeof(xcb_out); 9350 xcb_parts[3].iov_base = 0; 9351 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9352 9353 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9354 return xcb_ret; 9355 } 9356 9357 9358 /***************************************************************************** 9359 ** 9360 ** int32_t * xcb_glx_get_tex_enviv_data 9361 ** 9362 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9363 ** @returns int32_t * 9364 ** 9365 *****************************************************************************/ 9366 9367 int32_t * 9368 xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9369 { 9370 return (int32_t *) (R + 1); 9371 } 9372 9373 9374 /***************************************************************************** 9375 ** 9376 ** int xcb_glx_get_tex_enviv_data_length 9377 ** 9378 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9379 ** @returns int 9380 ** 9381 *****************************************************************************/ 9382 9383 int 9384 xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9385 { 9386 return R->n; 9387 } 9388 9389 9390 /***************************************************************************** 9391 ** 9392 ** xcb_generic_iterator_t xcb_glx_get_tex_enviv_data_end 9393 ** 9394 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9395 ** @returns xcb_generic_iterator_t 9396 ** 9397 *****************************************************************************/ 9398 9399 xcb_generic_iterator_t 9400 xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9401 { 9402 xcb_generic_iterator_t i; 9403 i.data = ((int32_t *) (R + 1)) + (R->n); 9404 i.rem = 0; 9405 i.index = (char *) i.data - (char *) R; 9406 return i; 9407 } 9408 9409 9410 /***************************************************************************** 9411 ** 9412 ** xcb_glx_get_tex_enviv_reply_t * xcb_glx_get_tex_enviv_reply 9413 ** 9414 ** @param xcb_connection_t *c 9415 ** @param xcb_glx_get_tex_enviv_cookie_t cookie 9416 ** @param xcb_generic_error_t **e 9417 ** @returns xcb_glx_get_tex_enviv_reply_t * 9418 ** 9419 *****************************************************************************/ 9420 9421 xcb_glx_get_tex_enviv_reply_t * 9422 xcb_glx_get_tex_enviv_reply (xcb_connection_t *c /**< */, 9423 xcb_glx_get_tex_enviv_cookie_t cookie /**< */, 9424 xcb_generic_error_t **e /**< */) 9425 { 9426 return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9427 } 9428 9429 int 9430 xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */) 9431 { 9432 char *xcb_tmp = (char *)_buffer; 9433 const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer; 9434 unsigned int xcb_buffer_len = 0; 9435 unsigned int xcb_block_len = 0; 9436 unsigned int xcb_pad = 0; 9437 unsigned int xcb_align_to; 9438 9439 9440 xcb_block_len += sizeof(xcb_glx_get_tex_gendv_reply_t); 9441 xcb_tmp += xcb_block_len; 9442 /* data */ 9443 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 9444 xcb_tmp += xcb_block_len; 9445 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 9446 /* insert padding */ 9447 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9448 xcb_buffer_len += xcb_block_len + xcb_pad; 9449 if (0 != xcb_pad) { 9450 xcb_tmp += xcb_pad; 9451 xcb_pad = 0; 9452 } 9453 xcb_block_len = 0; 9454 9455 return xcb_buffer_len; 9456 } 9457 9458 9459 /***************************************************************************** 9460 ** 9461 ** xcb_glx_get_tex_gendv_cookie_t xcb_glx_get_tex_gendv 9462 ** 9463 ** @param xcb_connection_t *c 9464 ** @param xcb_glx_context_tag_t context_tag 9465 ** @param uint32_t coord 9466 ** @param uint32_t pname 9467 ** @returns xcb_glx_get_tex_gendv_cookie_t 9468 ** 9469 *****************************************************************************/ 9470 9471 xcb_glx_get_tex_gendv_cookie_t 9472 xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, 9473 xcb_glx_context_tag_t context_tag /**< */, 9474 uint32_t coord /**< */, 9475 uint32_t pname /**< */) 9476 { 9477 static const xcb_protocol_request_t xcb_req = { 9478 /* count */ 2, 9479 /* ext */ &xcb_glx_id, 9480 /* opcode */ XCB_GLX_GET_TEX_GENDV, 9481 /* isvoid */ 0 9482 }; 9483 9484 struct iovec xcb_parts[4]; 9485 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 9486 xcb_glx_get_tex_gendv_request_t xcb_out; 9487 9488 xcb_out.context_tag = context_tag; 9489 xcb_out.coord = coord; 9490 xcb_out.pname = pname; 9491 9492 xcb_parts[2].iov_base = (char *) &xcb_out; 9493 xcb_parts[2].iov_len = sizeof(xcb_out); 9494 xcb_parts[3].iov_base = 0; 9495 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9496 9497 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9498 return xcb_ret; 9499 } 9500 9501 9502 /***************************************************************************** 9503 ** 9504 ** xcb_glx_get_tex_gendv_cookie_t xcb_glx_get_tex_gendv_unchecked 9505 ** 9506 ** @param xcb_connection_t *c 9507 ** @param xcb_glx_context_tag_t context_tag 9508 ** @param uint32_t coord 9509 ** @param uint32_t pname 9510 ** @returns xcb_glx_get_tex_gendv_cookie_t 9511 ** 9512 *****************************************************************************/ 9513 9514 xcb_glx_get_tex_gendv_cookie_t 9515 xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c /**< */, 9516 xcb_glx_context_tag_t context_tag /**< */, 9517 uint32_t coord /**< */, 9518 uint32_t pname /**< */) 9519 { 9520 static const xcb_protocol_request_t xcb_req = { 9521 /* count */ 2, 9522 /* ext */ &xcb_glx_id, 9523 /* opcode */ XCB_GLX_GET_TEX_GENDV, 9524 /* isvoid */ 0 9525 }; 9526 9527 struct iovec xcb_parts[4]; 9528 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 9529 xcb_glx_get_tex_gendv_request_t xcb_out; 9530 9531 xcb_out.context_tag = context_tag; 9532 xcb_out.coord = coord; 9533 xcb_out.pname = pname; 9534 9535 xcb_parts[2].iov_base = (char *) &xcb_out; 9536 xcb_parts[2].iov_len = sizeof(xcb_out); 9537 xcb_parts[3].iov_base = 0; 9538 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9539 9540 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9541 return xcb_ret; 9542 } 9543 9544 9545 /***************************************************************************** 9546 ** 9547 ** xcb_glx_float64_t * xcb_glx_get_tex_gendv_data 9548 ** 9549 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9550 ** @returns xcb_glx_float64_t * 9551 ** 9552 *****************************************************************************/ 9553 9554 xcb_glx_float64_t * 9555 xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9556 { 9557 return (xcb_glx_float64_t *) (R + 1); 9558 } 9559 9560 9561 /***************************************************************************** 9562 ** 9563 ** int xcb_glx_get_tex_gendv_data_length 9564 ** 9565 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9566 ** @returns int 9567 ** 9568 *****************************************************************************/ 9569 9570 int 9571 xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9572 { 9573 return R->n; 9574 } 9575 9576 9577 /***************************************************************************** 9578 ** 9579 ** xcb_generic_iterator_t xcb_glx_get_tex_gendv_data_end 9580 ** 9581 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9582 ** @returns xcb_generic_iterator_t 9583 ** 9584 *****************************************************************************/ 9585 9586 xcb_generic_iterator_t 9587 xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9588 { 9589 xcb_generic_iterator_t i; 9590 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 9591 i.rem = 0; 9592 i.index = (char *) i.data - (char *) R; 9593 return i; 9594 } 9595 9596 9597 /***************************************************************************** 9598 ** 9599 ** xcb_glx_get_tex_gendv_reply_t * xcb_glx_get_tex_gendv_reply 9600 ** 9601 ** @param xcb_connection_t *c 9602 ** @param xcb_glx_get_tex_gendv_cookie_t cookie 9603 ** @param xcb_generic_error_t **e 9604 ** @returns xcb_glx_get_tex_gendv_reply_t * 9605 ** 9606 *****************************************************************************/ 9607 9608 xcb_glx_get_tex_gendv_reply_t * 9609 xcb_glx_get_tex_gendv_reply (xcb_connection_t *c /**< */, 9610 xcb_glx_get_tex_gendv_cookie_t cookie /**< */, 9611 xcb_generic_error_t **e /**< */) 9612 { 9613 return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9614 } 9615 9616 int 9617 xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */) 9618 { 9619 char *xcb_tmp = (char *)_buffer; 9620 const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer; 9621 unsigned int xcb_buffer_len = 0; 9622 unsigned int xcb_block_len = 0; 9623 unsigned int xcb_pad = 0; 9624 unsigned int xcb_align_to; 9625 9626 9627 xcb_block_len += sizeof(xcb_glx_get_tex_genfv_reply_t); 9628 xcb_tmp += xcb_block_len; 9629 /* data */ 9630 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9631 xcb_tmp += xcb_block_len; 9632 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9633 /* insert padding */ 9634 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9635 xcb_buffer_len += xcb_block_len + xcb_pad; 9636 if (0 != xcb_pad) { 9637 xcb_tmp += xcb_pad; 9638 xcb_pad = 0; 9639 } 9640 xcb_block_len = 0; 9641 9642 return xcb_buffer_len; 9643 } 9644 9645 9646 /***************************************************************************** 9647 ** 9648 ** xcb_glx_get_tex_genfv_cookie_t xcb_glx_get_tex_genfv 9649 ** 9650 ** @param xcb_connection_t *c 9651 ** @param xcb_glx_context_tag_t context_tag 9652 ** @param uint32_t coord 9653 ** @param uint32_t pname 9654 ** @returns xcb_glx_get_tex_genfv_cookie_t 9655 ** 9656 *****************************************************************************/ 9657 9658 xcb_glx_get_tex_genfv_cookie_t 9659 xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, 9660 xcb_glx_context_tag_t context_tag /**< */, 9661 uint32_t coord /**< */, 9662 uint32_t pname /**< */) 9663 { 9664 static const xcb_protocol_request_t xcb_req = { 9665 /* count */ 2, 9666 /* ext */ &xcb_glx_id, 9667 /* opcode */ XCB_GLX_GET_TEX_GENFV, 9668 /* isvoid */ 0 9669 }; 9670 9671 struct iovec xcb_parts[4]; 9672 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 9673 xcb_glx_get_tex_genfv_request_t xcb_out; 9674 9675 xcb_out.context_tag = context_tag; 9676 xcb_out.coord = coord; 9677 xcb_out.pname = pname; 9678 9679 xcb_parts[2].iov_base = (char *) &xcb_out; 9680 xcb_parts[2].iov_len = sizeof(xcb_out); 9681 xcb_parts[3].iov_base = 0; 9682 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9683 9684 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9685 return xcb_ret; 9686 } 9687 9688 9689 /***************************************************************************** 9690 ** 9691 ** xcb_glx_get_tex_genfv_cookie_t xcb_glx_get_tex_genfv_unchecked 9692 ** 9693 ** @param xcb_connection_t *c 9694 ** @param xcb_glx_context_tag_t context_tag 9695 ** @param uint32_t coord 9696 ** @param uint32_t pname 9697 ** @returns xcb_glx_get_tex_genfv_cookie_t 9698 ** 9699 *****************************************************************************/ 9700 9701 xcb_glx_get_tex_genfv_cookie_t 9702 xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c /**< */, 9703 xcb_glx_context_tag_t context_tag /**< */, 9704 uint32_t coord /**< */, 9705 uint32_t pname /**< */) 9706 { 9707 static const xcb_protocol_request_t xcb_req = { 9708 /* count */ 2, 9709 /* ext */ &xcb_glx_id, 9710 /* opcode */ XCB_GLX_GET_TEX_GENFV, 9711 /* isvoid */ 0 9712 }; 9713 9714 struct iovec xcb_parts[4]; 9715 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 9716 xcb_glx_get_tex_genfv_request_t xcb_out; 9717 9718 xcb_out.context_tag = context_tag; 9719 xcb_out.coord = coord; 9720 xcb_out.pname = pname; 9721 9722 xcb_parts[2].iov_base = (char *) &xcb_out; 9723 xcb_parts[2].iov_len = sizeof(xcb_out); 9724 xcb_parts[3].iov_base = 0; 9725 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9726 9727 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9728 return xcb_ret; 9729 } 9730 9731 9732 /***************************************************************************** 9733 ** 9734 ** xcb_glx_float32_t * xcb_glx_get_tex_genfv_data 9735 ** 9736 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9737 ** @returns xcb_glx_float32_t * 9738 ** 9739 *****************************************************************************/ 9740 9741 xcb_glx_float32_t * 9742 xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9743 { 9744 return (xcb_glx_float32_t *) (R + 1); 9745 } 9746 9747 9748 /***************************************************************************** 9749 ** 9750 ** int xcb_glx_get_tex_genfv_data_length 9751 ** 9752 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9753 ** @returns int 9754 ** 9755 *****************************************************************************/ 9756 9757 int 9758 xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9759 { 9760 return R->n; 9761 } 9762 9763 9764 /***************************************************************************** 9765 ** 9766 ** xcb_generic_iterator_t xcb_glx_get_tex_genfv_data_end 9767 ** 9768 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9769 ** @returns xcb_generic_iterator_t 9770 ** 9771 *****************************************************************************/ 9772 9773 xcb_generic_iterator_t 9774 xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9775 { 9776 xcb_generic_iterator_t i; 9777 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9778 i.rem = 0; 9779 i.index = (char *) i.data - (char *) R; 9780 return i; 9781 } 9782 9783 9784 /***************************************************************************** 9785 ** 9786 ** xcb_glx_get_tex_genfv_reply_t * xcb_glx_get_tex_genfv_reply 9787 ** 9788 ** @param xcb_connection_t *c 9789 ** @param xcb_glx_get_tex_genfv_cookie_t cookie 9790 ** @param xcb_generic_error_t **e 9791 ** @returns xcb_glx_get_tex_genfv_reply_t * 9792 ** 9793 *****************************************************************************/ 9794 9795 xcb_glx_get_tex_genfv_reply_t * 9796 xcb_glx_get_tex_genfv_reply (xcb_connection_t *c /**< */, 9797 xcb_glx_get_tex_genfv_cookie_t cookie /**< */, 9798 xcb_generic_error_t **e /**< */) 9799 { 9800 return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9801 } 9802 9803 int 9804 xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */) 9805 { 9806 char *xcb_tmp = (char *)_buffer; 9807 const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer; 9808 unsigned int xcb_buffer_len = 0; 9809 unsigned int xcb_block_len = 0; 9810 unsigned int xcb_pad = 0; 9811 unsigned int xcb_align_to; 9812 9813 9814 xcb_block_len += sizeof(xcb_glx_get_tex_geniv_reply_t); 9815 xcb_tmp += xcb_block_len; 9816 /* data */ 9817 xcb_block_len += _aux->n * sizeof(int32_t); 9818 xcb_tmp += xcb_block_len; 9819 xcb_align_to = ALIGNOF(int32_t); 9820 /* insert padding */ 9821 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9822 xcb_buffer_len += xcb_block_len + xcb_pad; 9823 if (0 != xcb_pad) { 9824 xcb_tmp += xcb_pad; 9825 xcb_pad = 0; 9826 } 9827 xcb_block_len = 0; 9828 9829 return xcb_buffer_len; 9830 } 9831 9832 9833 /***************************************************************************** 9834 ** 9835 ** xcb_glx_get_tex_geniv_cookie_t xcb_glx_get_tex_geniv 9836 ** 9837 ** @param xcb_connection_t *c 9838 ** @param xcb_glx_context_tag_t context_tag 9839 ** @param uint32_t coord 9840 ** @param uint32_t pname 9841 ** @returns xcb_glx_get_tex_geniv_cookie_t 9842 ** 9843 *****************************************************************************/ 9844 9845 xcb_glx_get_tex_geniv_cookie_t 9846 xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, 9847 xcb_glx_context_tag_t context_tag /**< */, 9848 uint32_t coord /**< */, 9849 uint32_t pname /**< */) 9850 { 9851 static const xcb_protocol_request_t xcb_req = { 9852 /* count */ 2, 9853 /* ext */ &xcb_glx_id, 9854 /* opcode */ XCB_GLX_GET_TEX_GENIV, 9855 /* isvoid */ 0 9856 }; 9857 9858 struct iovec xcb_parts[4]; 9859 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 9860 xcb_glx_get_tex_geniv_request_t xcb_out; 9861 9862 xcb_out.context_tag = context_tag; 9863 xcb_out.coord = coord; 9864 xcb_out.pname = pname; 9865 9866 xcb_parts[2].iov_base = (char *) &xcb_out; 9867 xcb_parts[2].iov_len = sizeof(xcb_out); 9868 xcb_parts[3].iov_base = 0; 9869 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9870 9871 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9872 return xcb_ret; 9873 } 9874 9875 9876 /***************************************************************************** 9877 ** 9878 ** xcb_glx_get_tex_geniv_cookie_t xcb_glx_get_tex_geniv_unchecked 9879 ** 9880 ** @param xcb_connection_t *c 9881 ** @param xcb_glx_context_tag_t context_tag 9882 ** @param uint32_t coord 9883 ** @param uint32_t pname 9884 ** @returns xcb_glx_get_tex_geniv_cookie_t 9885 ** 9886 *****************************************************************************/ 9887 9888 xcb_glx_get_tex_geniv_cookie_t 9889 xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c /**< */, 9890 xcb_glx_context_tag_t context_tag /**< */, 9891 uint32_t coord /**< */, 9892 uint32_t pname /**< */) 9893 { 9894 static const xcb_protocol_request_t xcb_req = { 9895 /* count */ 2, 9896 /* ext */ &xcb_glx_id, 9897 /* opcode */ XCB_GLX_GET_TEX_GENIV, 9898 /* isvoid */ 0 9899 }; 9900 9901 struct iovec xcb_parts[4]; 9902 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 9903 xcb_glx_get_tex_geniv_request_t xcb_out; 9904 9905 xcb_out.context_tag = context_tag; 9906 xcb_out.coord = coord; 9907 xcb_out.pname = pname; 9908 9909 xcb_parts[2].iov_base = (char *) &xcb_out; 9910 xcb_parts[2].iov_len = sizeof(xcb_out); 9911 xcb_parts[3].iov_base = 0; 9912 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9913 9914 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9915 return xcb_ret; 9916 } 9917 9918 9919 /***************************************************************************** 9920 ** 9921 ** int32_t * xcb_glx_get_tex_geniv_data 9922 ** 9923 ** @param const xcb_glx_get_tex_geniv_reply_t *R 9924 ** @returns int32_t * 9925 ** 9926 *****************************************************************************/ 9927 9928 int32_t * 9929 xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 9930 { 9931 return (int32_t *) (R + 1); 9932 } 9933 9934 9935 /***************************************************************************** 9936 ** 9937 ** int xcb_glx_get_tex_geniv_data_length 9938 ** 9939 ** @param const xcb_glx_get_tex_geniv_reply_t *R 9940 ** @returns int 9941 ** 9942 *****************************************************************************/ 9943 9944 int 9945 xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 9946 { 9947 return R->n; 9948 } 9949 9950 9951 /***************************************************************************** 9952 ** 9953 ** xcb_generic_iterator_t xcb_glx_get_tex_geniv_data_end 9954 ** 9955 ** @param const xcb_glx_get_tex_geniv_reply_t *R 9956 ** @returns xcb_generic_iterator_t 9957 ** 9958 *****************************************************************************/ 9959 9960 xcb_generic_iterator_t 9961 xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 9962 { 9963 xcb_generic_iterator_t i; 9964 i.data = ((int32_t *) (R + 1)) + (R->n); 9965 i.rem = 0; 9966 i.index = (char *) i.data - (char *) R; 9967 return i; 9968 } 9969 9970 9971 /***************************************************************************** 9972 ** 9973 ** xcb_glx_get_tex_geniv_reply_t * xcb_glx_get_tex_geniv_reply 9974 ** 9975 ** @param xcb_connection_t *c 9976 ** @param xcb_glx_get_tex_geniv_cookie_t cookie 9977 ** @param xcb_generic_error_t **e 9978 ** @returns xcb_glx_get_tex_geniv_reply_t * 9979 ** 9980 *****************************************************************************/ 9981 9982 xcb_glx_get_tex_geniv_reply_t * 9983 xcb_glx_get_tex_geniv_reply (xcb_connection_t *c /**< */, 9984 xcb_glx_get_tex_geniv_cookie_t cookie /**< */, 9985 xcb_generic_error_t **e /**< */) 9986 { 9987 return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9988 } 9989 9990 int 9991 xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */) 9992 { 9993 char *xcb_tmp = (char *)_buffer; 9994 const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer; 9995 unsigned int xcb_buffer_len = 0; 9996 unsigned int xcb_block_len = 0; 9997 unsigned int xcb_pad = 0; 9998 unsigned int xcb_align_to; 9999 10000 10001 xcb_block_len += sizeof(xcb_glx_get_tex_image_reply_t); 10002 xcb_tmp += xcb_block_len; 10003 /* data */ 10004 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 10005 xcb_tmp += xcb_block_len; 10006 xcb_align_to = ALIGNOF(uint8_t); 10007 /* insert padding */ 10008 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10009 xcb_buffer_len += xcb_block_len + xcb_pad; 10010 if (0 != xcb_pad) { 10011 xcb_tmp += xcb_pad; 10012 xcb_pad = 0; 10013 } 10014 xcb_block_len = 0; 10015 10016 return xcb_buffer_len; 10017 } 10018 10019 10020 /***************************************************************************** 10021 ** 10022 ** xcb_glx_get_tex_image_cookie_t xcb_glx_get_tex_image 10023 ** 10024 ** @param xcb_connection_t *c 10025 ** @param xcb_glx_context_tag_t context_tag 10026 ** @param uint32_t target 10027 ** @param int32_t level 10028 ** @param uint32_t format 10029 ** @param uint32_t type 10030 ** @param uint8_t swap_bytes 10031 ** @returns xcb_glx_get_tex_image_cookie_t 10032 ** 10033 *****************************************************************************/ 10034 10035 xcb_glx_get_tex_image_cookie_t 10036 xcb_glx_get_tex_image (xcb_connection_t *c /**< */, 10037 xcb_glx_context_tag_t context_tag /**< */, 10038 uint32_t target /**< */, 10039 int32_t level /**< */, 10040 uint32_t format /**< */, 10041 uint32_t type /**< */, 10042 uint8_t swap_bytes /**< */) 10043 { 10044 static const xcb_protocol_request_t xcb_req = { 10045 /* count */ 2, 10046 /* ext */ &xcb_glx_id, 10047 /* opcode */ XCB_GLX_GET_TEX_IMAGE, 10048 /* isvoid */ 0 10049 }; 10050 10051 struct iovec xcb_parts[4]; 10052 xcb_glx_get_tex_image_cookie_t xcb_ret; 10053 xcb_glx_get_tex_image_request_t xcb_out; 10054 10055 xcb_out.context_tag = context_tag; 10056 xcb_out.target = target; 10057 xcb_out.level = level; 10058 xcb_out.format = format; 10059 xcb_out.type = type; 10060 xcb_out.swap_bytes = swap_bytes; 10061 10062 xcb_parts[2].iov_base = (char *) &xcb_out; 10063 xcb_parts[2].iov_len = sizeof(xcb_out); 10064 xcb_parts[3].iov_base = 0; 10065 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10066 10067 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10068 return xcb_ret; 10069 } 10070 10071 10072 /***************************************************************************** 10073 ** 10074 ** xcb_glx_get_tex_image_cookie_t xcb_glx_get_tex_image_unchecked 10075 ** 10076 ** @param xcb_connection_t *c 10077 ** @param xcb_glx_context_tag_t context_tag 10078 ** @param uint32_t target 10079 ** @param int32_t level 10080 ** @param uint32_t format 10081 ** @param uint32_t type 10082 ** @param uint8_t swap_bytes 10083 ** @returns xcb_glx_get_tex_image_cookie_t 10084 ** 10085 *****************************************************************************/ 10086 10087 xcb_glx_get_tex_image_cookie_t 10088 xcb_glx_get_tex_image_unchecked (xcb_connection_t *c /**< */, 10089 xcb_glx_context_tag_t context_tag /**< */, 10090 uint32_t target /**< */, 10091 int32_t level /**< */, 10092 uint32_t format /**< */, 10093 uint32_t type /**< */, 10094 uint8_t swap_bytes /**< */) 10095 { 10096 static const xcb_protocol_request_t xcb_req = { 10097 /* count */ 2, 10098 /* ext */ &xcb_glx_id, 10099 /* opcode */ XCB_GLX_GET_TEX_IMAGE, 10100 /* isvoid */ 0 10101 }; 10102 10103 struct iovec xcb_parts[4]; 10104 xcb_glx_get_tex_image_cookie_t xcb_ret; 10105 xcb_glx_get_tex_image_request_t xcb_out; 10106 10107 xcb_out.context_tag = context_tag; 10108 xcb_out.target = target; 10109 xcb_out.level = level; 10110 xcb_out.format = format; 10111 xcb_out.type = type; 10112 xcb_out.swap_bytes = swap_bytes; 10113 10114 xcb_parts[2].iov_base = (char *) &xcb_out; 10115 xcb_parts[2].iov_len = sizeof(xcb_out); 10116 xcb_parts[3].iov_base = 0; 10117 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10118 10119 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10120 return xcb_ret; 10121 } 10122 10123 10124 /***************************************************************************** 10125 ** 10126 ** uint8_t * xcb_glx_get_tex_image_data 10127 ** 10128 ** @param const xcb_glx_get_tex_image_reply_t *R 10129 ** @returns uint8_t * 10130 ** 10131 *****************************************************************************/ 10132 10133 uint8_t * 10134 xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R /**< */) 10135 { 10136 return (uint8_t *) (R + 1); 10137 } 10138 10139 10140 /***************************************************************************** 10141 ** 10142 ** int xcb_glx_get_tex_image_data_length 10143 ** 10144 ** @param const xcb_glx_get_tex_image_reply_t *R 10145 ** @returns int 10146 ** 10147 *****************************************************************************/ 10148 10149 int 10150 xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R /**< */) 10151 { 10152 return (R->length * 4); 10153 } 10154 10155 10156 /***************************************************************************** 10157 ** 10158 ** xcb_generic_iterator_t xcb_glx_get_tex_image_data_end 10159 ** 10160 ** @param const xcb_glx_get_tex_image_reply_t *R 10161 ** @returns xcb_generic_iterator_t 10162 ** 10163 *****************************************************************************/ 10164 10165 xcb_generic_iterator_t 10166 xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */) 10167 { 10168 xcb_generic_iterator_t i; 10169 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 10170 i.rem = 0; 10171 i.index = (char *) i.data - (char *) R; 10172 return i; 10173 } 10174 10175 10176 /***************************************************************************** 10177 ** 10178 ** xcb_glx_get_tex_image_reply_t * xcb_glx_get_tex_image_reply 10179 ** 10180 ** @param xcb_connection_t *c 10181 ** @param xcb_glx_get_tex_image_cookie_t cookie 10182 ** @param xcb_generic_error_t **e 10183 ** @returns xcb_glx_get_tex_image_reply_t * 10184 ** 10185 *****************************************************************************/ 10186 10187 xcb_glx_get_tex_image_reply_t * 10188 xcb_glx_get_tex_image_reply (xcb_connection_t *c /**< */, 10189 xcb_glx_get_tex_image_cookie_t cookie /**< */, 10190 xcb_generic_error_t **e /**< */) 10191 { 10192 return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10193 } 10194 10195 int 10196 xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */) 10197 { 10198 char *xcb_tmp = (char *)_buffer; 10199 const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer; 10200 unsigned int xcb_buffer_len = 0; 10201 unsigned int xcb_block_len = 0; 10202 unsigned int xcb_pad = 0; 10203 unsigned int xcb_align_to; 10204 10205 10206 xcb_block_len += sizeof(xcb_glx_get_tex_parameterfv_reply_t); 10207 xcb_tmp += xcb_block_len; 10208 /* data */ 10209 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 10210 xcb_tmp += xcb_block_len; 10211 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 10212 /* insert padding */ 10213 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10214 xcb_buffer_len += xcb_block_len + xcb_pad; 10215 if (0 != xcb_pad) { 10216 xcb_tmp += xcb_pad; 10217 xcb_pad = 0; 10218 } 10219 xcb_block_len = 0; 10220 10221 return xcb_buffer_len; 10222 } 10223 10224 10225 /***************************************************************************** 10226 ** 10227 ** xcb_glx_get_tex_parameterfv_cookie_t xcb_glx_get_tex_parameterfv 10228 ** 10229 ** @param xcb_connection_t *c 10230 ** @param xcb_glx_context_tag_t context_tag 10231 ** @param uint32_t target 10232 ** @param uint32_t pname 10233 ** @returns xcb_glx_get_tex_parameterfv_cookie_t 10234 ** 10235 *****************************************************************************/ 10236 10237 xcb_glx_get_tex_parameterfv_cookie_t 10238 xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, 10239 xcb_glx_context_tag_t context_tag /**< */, 10240 uint32_t target /**< */, 10241 uint32_t pname /**< */) 10242 { 10243 static const xcb_protocol_request_t xcb_req = { 10244 /* count */ 2, 10245 /* ext */ &xcb_glx_id, 10246 /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, 10247 /* isvoid */ 0 10248 }; 10249 10250 struct iovec xcb_parts[4]; 10251 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 10252 xcb_glx_get_tex_parameterfv_request_t xcb_out; 10253 10254 xcb_out.context_tag = context_tag; 10255 xcb_out.target = target; 10256 xcb_out.pname = pname; 10257 10258 xcb_parts[2].iov_base = (char *) &xcb_out; 10259 xcb_parts[2].iov_len = sizeof(xcb_out); 10260 xcb_parts[3].iov_base = 0; 10261 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10262 10263 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10264 return xcb_ret; 10265 } 10266 10267 10268 /***************************************************************************** 10269 ** 10270 ** xcb_glx_get_tex_parameterfv_cookie_t xcb_glx_get_tex_parameterfv_unchecked 10271 ** 10272 ** @param xcb_connection_t *c 10273 ** @param xcb_glx_context_tag_t context_tag 10274 ** @param uint32_t target 10275 ** @param uint32_t pname 10276 ** @returns xcb_glx_get_tex_parameterfv_cookie_t 10277 ** 10278 *****************************************************************************/ 10279 10280 xcb_glx_get_tex_parameterfv_cookie_t 10281 xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c /**< */, 10282 xcb_glx_context_tag_t context_tag /**< */, 10283 uint32_t target /**< */, 10284 uint32_t pname /**< */) 10285 { 10286 static const xcb_protocol_request_t xcb_req = { 10287 /* count */ 2, 10288 /* ext */ &xcb_glx_id, 10289 /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, 10290 /* isvoid */ 0 10291 }; 10292 10293 struct iovec xcb_parts[4]; 10294 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 10295 xcb_glx_get_tex_parameterfv_request_t xcb_out; 10296 10297 xcb_out.context_tag = context_tag; 10298 xcb_out.target = target; 10299 xcb_out.pname = pname; 10300 10301 xcb_parts[2].iov_base = (char *) &xcb_out; 10302 xcb_parts[2].iov_len = sizeof(xcb_out); 10303 xcb_parts[3].iov_base = 0; 10304 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10305 10306 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10307 return xcb_ret; 10308 } 10309 10310 10311 /***************************************************************************** 10312 ** 10313 ** xcb_glx_float32_t * xcb_glx_get_tex_parameterfv_data 10314 ** 10315 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10316 ** @returns xcb_glx_float32_t * 10317 ** 10318 *****************************************************************************/ 10319 10320 xcb_glx_float32_t * 10321 xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10322 { 10323 return (xcb_glx_float32_t *) (R + 1); 10324 } 10325 10326 10327 /***************************************************************************** 10328 ** 10329 ** int xcb_glx_get_tex_parameterfv_data_length 10330 ** 10331 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10332 ** @returns int 10333 ** 10334 *****************************************************************************/ 10335 10336 int 10337 xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10338 { 10339 return R->n; 10340 } 10341 10342 10343 /***************************************************************************** 10344 ** 10345 ** xcb_generic_iterator_t xcb_glx_get_tex_parameterfv_data_end 10346 ** 10347 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10348 ** @returns xcb_generic_iterator_t 10349 ** 10350 *****************************************************************************/ 10351 10352 xcb_generic_iterator_t 10353 xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10354 { 10355 xcb_generic_iterator_t i; 10356 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 10357 i.rem = 0; 10358 i.index = (char *) i.data - (char *) R; 10359 return i; 10360 } 10361 10362 10363 /***************************************************************************** 10364 ** 10365 ** xcb_glx_get_tex_parameterfv_reply_t * xcb_glx_get_tex_parameterfv_reply 10366 ** 10367 ** @param xcb_connection_t *c 10368 ** @param xcb_glx_get_tex_parameterfv_cookie_t cookie 10369 ** @param xcb_generic_error_t **e 10370 ** @returns xcb_glx_get_tex_parameterfv_reply_t * 10371 ** 10372 *****************************************************************************/ 10373 10374 xcb_glx_get_tex_parameterfv_reply_t * 10375 xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c /**< */, 10376 xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, 10377 xcb_generic_error_t **e /**< */) 10378 { 10379 return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10380 } 10381 10382 int 10383 xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */) 10384 { 10385 char *xcb_tmp = (char *)_buffer; 10386 const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer; 10387 unsigned int xcb_buffer_len = 0; 10388 unsigned int xcb_block_len = 0; 10389 unsigned int xcb_pad = 0; 10390 unsigned int xcb_align_to; 10391 10392 10393 xcb_block_len += sizeof(xcb_glx_get_tex_parameteriv_reply_t); 10394 xcb_tmp += xcb_block_len; 10395 /* data */ 10396 xcb_block_len += _aux->n * sizeof(int32_t); 10397 xcb_tmp += xcb_block_len; 10398 xcb_align_to = ALIGNOF(int32_t); 10399 /* insert padding */ 10400 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10401 xcb_buffer_len += xcb_block_len + xcb_pad; 10402 if (0 != xcb_pad) { 10403 xcb_tmp += xcb_pad; 10404 xcb_pad = 0; 10405 } 10406 xcb_block_len = 0; 10407 10408 return xcb_buffer_len; 10409 } 10410 10411 10412 /***************************************************************************** 10413 ** 10414 ** xcb_glx_get_tex_parameteriv_cookie_t xcb_glx_get_tex_parameteriv 10415 ** 10416 ** @param xcb_connection_t *c 10417 ** @param xcb_glx_context_tag_t context_tag 10418 ** @param uint32_t target 10419 ** @param uint32_t pname 10420 ** @returns xcb_glx_get_tex_parameteriv_cookie_t 10421 ** 10422 *****************************************************************************/ 10423 10424 xcb_glx_get_tex_parameteriv_cookie_t 10425 xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, 10426 xcb_glx_context_tag_t context_tag /**< */, 10427 uint32_t target /**< */, 10428 uint32_t pname /**< */) 10429 { 10430 static const xcb_protocol_request_t xcb_req = { 10431 /* count */ 2, 10432 /* ext */ &xcb_glx_id, 10433 /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, 10434 /* isvoid */ 0 10435 }; 10436 10437 struct iovec xcb_parts[4]; 10438 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 10439 xcb_glx_get_tex_parameteriv_request_t xcb_out; 10440 10441 xcb_out.context_tag = context_tag; 10442 xcb_out.target = target; 10443 xcb_out.pname = pname; 10444 10445 xcb_parts[2].iov_base = (char *) &xcb_out; 10446 xcb_parts[2].iov_len = sizeof(xcb_out); 10447 xcb_parts[3].iov_base = 0; 10448 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10449 10450 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10451 return xcb_ret; 10452 } 10453 10454 10455 /***************************************************************************** 10456 ** 10457 ** xcb_glx_get_tex_parameteriv_cookie_t xcb_glx_get_tex_parameteriv_unchecked 10458 ** 10459 ** @param xcb_connection_t *c 10460 ** @param xcb_glx_context_tag_t context_tag 10461 ** @param uint32_t target 10462 ** @param uint32_t pname 10463 ** @returns xcb_glx_get_tex_parameteriv_cookie_t 10464 ** 10465 *****************************************************************************/ 10466 10467 xcb_glx_get_tex_parameteriv_cookie_t 10468 xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c /**< */, 10469 xcb_glx_context_tag_t context_tag /**< */, 10470 uint32_t target /**< */, 10471 uint32_t pname /**< */) 10472 { 10473 static const xcb_protocol_request_t xcb_req = { 10474 /* count */ 2, 10475 /* ext */ &xcb_glx_id, 10476 /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, 10477 /* isvoid */ 0 10478 }; 10479 10480 struct iovec xcb_parts[4]; 10481 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 10482 xcb_glx_get_tex_parameteriv_request_t xcb_out; 10483 10484 xcb_out.context_tag = context_tag; 10485 xcb_out.target = target; 10486 xcb_out.pname = pname; 10487 10488 xcb_parts[2].iov_base = (char *) &xcb_out; 10489 xcb_parts[2].iov_len = sizeof(xcb_out); 10490 xcb_parts[3].iov_base = 0; 10491 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10492 10493 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10494 return xcb_ret; 10495 } 10496 10497 10498 /***************************************************************************** 10499 ** 10500 ** int32_t * xcb_glx_get_tex_parameteriv_data 10501 ** 10502 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10503 ** @returns int32_t * 10504 ** 10505 *****************************************************************************/ 10506 10507 int32_t * 10508 xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10509 { 10510 return (int32_t *) (R + 1); 10511 } 10512 10513 10514 /***************************************************************************** 10515 ** 10516 ** int xcb_glx_get_tex_parameteriv_data_length 10517 ** 10518 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10519 ** @returns int 10520 ** 10521 *****************************************************************************/ 10522 10523 int 10524 xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10525 { 10526 return R->n; 10527 } 10528 10529 10530 /***************************************************************************** 10531 ** 10532 ** xcb_generic_iterator_t xcb_glx_get_tex_parameteriv_data_end 10533 ** 10534 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10535 ** @returns xcb_generic_iterator_t 10536 ** 10537 *****************************************************************************/ 10538 10539 xcb_generic_iterator_t 10540 xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10541 { 10542 xcb_generic_iterator_t i; 10543 i.data = ((int32_t *) (R + 1)) + (R->n); 10544 i.rem = 0; 10545 i.index = (char *) i.data - (char *) R; 10546 return i; 10547 } 10548 10549 10550 /***************************************************************************** 10551 ** 10552 ** xcb_glx_get_tex_parameteriv_reply_t * xcb_glx_get_tex_parameteriv_reply 10553 ** 10554 ** @param xcb_connection_t *c 10555 ** @param xcb_glx_get_tex_parameteriv_cookie_t cookie 10556 ** @param xcb_generic_error_t **e 10557 ** @returns xcb_glx_get_tex_parameteriv_reply_t * 10558 ** 10559 *****************************************************************************/ 10560 10561 xcb_glx_get_tex_parameteriv_reply_t * 10562 xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c /**< */, 10563 xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, 10564 xcb_generic_error_t **e /**< */) 10565 { 10566 return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10567 } 10568 10569 int 10570 xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */) 10571 { 10572 char *xcb_tmp = (char *)_buffer; 10573 const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer; 10574 unsigned int xcb_buffer_len = 0; 10575 unsigned int xcb_block_len = 0; 10576 unsigned int xcb_pad = 0; 10577 unsigned int xcb_align_to; 10578 10579 10580 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameterfv_reply_t); 10581 xcb_tmp += xcb_block_len; 10582 /* data */ 10583 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 10584 xcb_tmp += xcb_block_len; 10585 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 10586 /* insert padding */ 10587 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10588 xcb_buffer_len += xcb_block_len + xcb_pad; 10589 if (0 != xcb_pad) { 10590 xcb_tmp += xcb_pad; 10591 xcb_pad = 0; 10592 } 10593 xcb_block_len = 0; 10594 10595 return xcb_buffer_len; 10596 } 10597 10598 10599 /***************************************************************************** 10600 ** 10601 ** xcb_glx_get_tex_level_parameterfv_cookie_t xcb_glx_get_tex_level_parameterfv 10602 ** 10603 ** @param xcb_connection_t *c 10604 ** @param xcb_glx_context_tag_t context_tag 10605 ** @param uint32_t target 10606 ** @param int32_t level 10607 ** @param uint32_t pname 10608 ** @returns xcb_glx_get_tex_level_parameterfv_cookie_t 10609 ** 10610 *****************************************************************************/ 10611 10612 xcb_glx_get_tex_level_parameterfv_cookie_t 10613 xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, 10614 xcb_glx_context_tag_t context_tag /**< */, 10615 uint32_t target /**< */, 10616 int32_t level /**< */, 10617 uint32_t pname /**< */) 10618 { 10619 static const xcb_protocol_request_t xcb_req = { 10620 /* count */ 2, 10621 /* ext */ &xcb_glx_id, 10622 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 10623 /* isvoid */ 0 10624 }; 10625 10626 struct iovec xcb_parts[4]; 10627 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 10628 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 10629 10630 xcb_out.context_tag = context_tag; 10631 xcb_out.target = target; 10632 xcb_out.level = level; 10633 xcb_out.pname = pname; 10634 10635 xcb_parts[2].iov_base = (char *) &xcb_out; 10636 xcb_parts[2].iov_len = sizeof(xcb_out); 10637 xcb_parts[3].iov_base = 0; 10638 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10639 10640 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10641 return xcb_ret; 10642 } 10643 10644 10645 /***************************************************************************** 10646 ** 10647 ** xcb_glx_get_tex_level_parameterfv_cookie_t xcb_glx_get_tex_level_parameterfv_unchecked 10648 ** 10649 ** @param xcb_connection_t *c 10650 ** @param xcb_glx_context_tag_t context_tag 10651 ** @param uint32_t target 10652 ** @param int32_t level 10653 ** @param uint32_t pname 10654 ** @returns xcb_glx_get_tex_level_parameterfv_cookie_t 10655 ** 10656 *****************************************************************************/ 10657 10658 xcb_glx_get_tex_level_parameterfv_cookie_t 10659 xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c /**< */, 10660 xcb_glx_context_tag_t context_tag /**< */, 10661 uint32_t target /**< */, 10662 int32_t level /**< */, 10663 uint32_t pname /**< */) 10664 { 10665 static const xcb_protocol_request_t xcb_req = { 10666 /* count */ 2, 10667 /* ext */ &xcb_glx_id, 10668 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 10669 /* isvoid */ 0 10670 }; 10671 10672 struct iovec xcb_parts[4]; 10673 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 10674 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 10675 10676 xcb_out.context_tag = context_tag; 10677 xcb_out.target = target; 10678 xcb_out.level = level; 10679 xcb_out.pname = pname; 10680 10681 xcb_parts[2].iov_base = (char *) &xcb_out; 10682 xcb_parts[2].iov_len = sizeof(xcb_out); 10683 xcb_parts[3].iov_base = 0; 10684 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10685 10686 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10687 return xcb_ret; 10688 } 10689 10690 10691 /***************************************************************************** 10692 ** 10693 ** xcb_glx_float32_t * xcb_glx_get_tex_level_parameterfv_data 10694 ** 10695 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10696 ** @returns xcb_glx_float32_t * 10697 ** 10698 *****************************************************************************/ 10699 10700 xcb_glx_float32_t * 10701 xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10702 { 10703 return (xcb_glx_float32_t *) (R + 1); 10704 } 10705 10706 10707 /***************************************************************************** 10708 ** 10709 ** int xcb_glx_get_tex_level_parameterfv_data_length 10710 ** 10711 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10712 ** @returns int 10713 ** 10714 *****************************************************************************/ 10715 10716 int 10717 xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10718 { 10719 return R->n; 10720 } 10721 10722 10723 /***************************************************************************** 10724 ** 10725 ** xcb_generic_iterator_t xcb_glx_get_tex_level_parameterfv_data_end 10726 ** 10727 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10728 ** @returns xcb_generic_iterator_t 10729 ** 10730 *****************************************************************************/ 10731 10732 xcb_generic_iterator_t 10733 xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10734 { 10735 xcb_generic_iterator_t i; 10736 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 10737 i.rem = 0; 10738 i.index = (char *) i.data - (char *) R; 10739 return i; 10740 } 10741 10742 10743 /***************************************************************************** 10744 ** 10745 ** xcb_glx_get_tex_level_parameterfv_reply_t * xcb_glx_get_tex_level_parameterfv_reply 10746 ** 10747 ** @param xcb_connection_t *c 10748 ** @param xcb_glx_get_tex_level_parameterfv_cookie_t cookie 10749 ** @param xcb_generic_error_t **e 10750 ** @returns xcb_glx_get_tex_level_parameterfv_reply_t * 10751 ** 10752 *****************************************************************************/ 10753 10754 xcb_glx_get_tex_level_parameterfv_reply_t * 10755 xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c /**< */, 10756 xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, 10757 xcb_generic_error_t **e /**< */) 10758 { 10759 return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10760 } 10761 10762 int 10763 xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */) 10764 { 10765 char *xcb_tmp = (char *)_buffer; 10766 const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer; 10767 unsigned int xcb_buffer_len = 0; 10768 unsigned int xcb_block_len = 0; 10769 unsigned int xcb_pad = 0; 10770 unsigned int xcb_align_to; 10771 10772 10773 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameteriv_reply_t); 10774 xcb_tmp += xcb_block_len; 10775 /* data */ 10776 xcb_block_len += _aux->n * sizeof(int32_t); 10777 xcb_tmp += xcb_block_len; 10778 xcb_align_to = ALIGNOF(int32_t); 10779 /* insert padding */ 10780 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10781 xcb_buffer_len += xcb_block_len + xcb_pad; 10782 if (0 != xcb_pad) { 10783 xcb_tmp += xcb_pad; 10784 xcb_pad = 0; 10785 } 10786 xcb_block_len = 0; 10787 10788 return xcb_buffer_len; 10789 } 10790 10791 10792 /***************************************************************************** 10793 ** 10794 ** xcb_glx_get_tex_level_parameteriv_cookie_t xcb_glx_get_tex_level_parameteriv 10795 ** 10796 ** @param xcb_connection_t *c 10797 ** @param xcb_glx_context_tag_t context_tag 10798 ** @param uint32_t target 10799 ** @param int32_t level 10800 ** @param uint32_t pname 10801 ** @returns xcb_glx_get_tex_level_parameteriv_cookie_t 10802 ** 10803 *****************************************************************************/ 10804 10805 xcb_glx_get_tex_level_parameteriv_cookie_t 10806 xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, 10807 xcb_glx_context_tag_t context_tag /**< */, 10808 uint32_t target /**< */, 10809 int32_t level /**< */, 10810 uint32_t pname /**< */) 10811 { 10812 static const xcb_protocol_request_t xcb_req = { 10813 /* count */ 2, 10814 /* ext */ &xcb_glx_id, 10815 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 10816 /* isvoid */ 0 10817 }; 10818 10819 struct iovec xcb_parts[4]; 10820 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 10821 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 10822 10823 xcb_out.context_tag = context_tag; 10824 xcb_out.target = target; 10825 xcb_out.level = level; 10826 xcb_out.pname = pname; 10827 10828 xcb_parts[2].iov_base = (char *) &xcb_out; 10829 xcb_parts[2].iov_len = sizeof(xcb_out); 10830 xcb_parts[3].iov_base = 0; 10831 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10832 10833 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10834 return xcb_ret; 10835 } 10836 10837 10838 /***************************************************************************** 10839 ** 10840 ** xcb_glx_get_tex_level_parameteriv_cookie_t xcb_glx_get_tex_level_parameteriv_unchecked 10841 ** 10842 ** @param xcb_connection_t *c 10843 ** @param xcb_glx_context_tag_t context_tag 10844 ** @param uint32_t target 10845 ** @param int32_t level 10846 ** @param uint32_t pname 10847 ** @returns xcb_glx_get_tex_level_parameteriv_cookie_t 10848 ** 10849 *****************************************************************************/ 10850 10851 xcb_glx_get_tex_level_parameteriv_cookie_t 10852 xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c /**< */, 10853 xcb_glx_context_tag_t context_tag /**< */, 10854 uint32_t target /**< */, 10855 int32_t level /**< */, 10856 uint32_t pname /**< */) 10857 { 10858 static const xcb_protocol_request_t xcb_req = { 10859 /* count */ 2, 10860 /* ext */ &xcb_glx_id, 10861 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 10862 /* isvoid */ 0 10863 }; 10864 10865 struct iovec xcb_parts[4]; 10866 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 10867 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 10868 10869 xcb_out.context_tag = context_tag; 10870 xcb_out.target = target; 10871 xcb_out.level = level; 10872 xcb_out.pname = pname; 10873 10874 xcb_parts[2].iov_base = (char *) &xcb_out; 10875 xcb_parts[2].iov_len = sizeof(xcb_out); 10876 xcb_parts[3].iov_base = 0; 10877 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10878 10879 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10880 return xcb_ret; 10881 } 10882 10883 10884 /***************************************************************************** 10885 ** 10886 ** int32_t * xcb_glx_get_tex_level_parameteriv_data 10887 ** 10888 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 10889 ** @returns int32_t * 10890 ** 10891 *****************************************************************************/ 10892 10893 int32_t * 10894 xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 10895 { 10896 return (int32_t *) (R + 1); 10897 } 10898 10899 10900 /***************************************************************************** 10901 ** 10902 ** int xcb_glx_get_tex_level_parameteriv_data_length 10903 ** 10904 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 10905 ** @returns int 10906 ** 10907 *****************************************************************************/ 10908 10909 int 10910 xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 10911 { 10912 return R->n; 10913 } 10914 10915 10916 /***************************************************************************** 10917 ** 10918 ** xcb_generic_iterator_t xcb_glx_get_tex_level_parameteriv_data_end 10919 ** 10920 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 10921 ** @returns xcb_generic_iterator_t 10922 ** 10923 *****************************************************************************/ 10924 10925 xcb_generic_iterator_t 10926 xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 10927 { 10928 xcb_generic_iterator_t i; 10929 i.data = ((int32_t *) (R + 1)) + (R->n); 10930 i.rem = 0; 10931 i.index = (char *) i.data - (char *) R; 10932 return i; 10933 } 10934 10935 10936 /***************************************************************************** 10937 ** 10938 ** xcb_glx_get_tex_level_parameteriv_reply_t * xcb_glx_get_tex_level_parameteriv_reply 10939 ** 10940 ** @param xcb_connection_t *c 10941 ** @param xcb_glx_get_tex_level_parameteriv_cookie_t cookie 10942 ** @param xcb_generic_error_t **e 10943 ** @returns xcb_glx_get_tex_level_parameteriv_reply_t * 10944 ** 10945 *****************************************************************************/ 10946 10947 xcb_glx_get_tex_level_parameteriv_reply_t * 10948 xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c /**< */, 10949 xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, 10950 xcb_generic_error_t **e /**< */) 10951 { 10952 return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10953 } 10954 10955 10956 /***************************************************************************** 10957 ** 10958 ** xcb_glx_is_list_cookie_t xcb_glx_is_list 10959 ** 10960 ** @param xcb_connection_t *c 10961 ** @param xcb_glx_context_tag_t context_tag 10962 ** @param uint32_t list 10963 ** @returns xcb_glx_is_list_cookie_t 10964 ** 10965 *****************************************************************************/ 10966 10967 xcb_glx_is_list_cookie_t 10968 xcb_glx_is_list (xcb_connection_t *c /**< */, 10969 xcb_glx_context_tag_t context_tag /**< */, 10970 uint32_t list /**< */) 10971 { 10972 static const xcb_protocol_request_t xcb_req = { 10973 /* count */ 2, 10974 /* ext */ &xcb_glx_id, 10975 /* opcode */ XCB_GLX_IS_LIST, 10976 /* isvoid */ 0 10977 }; 10978 10979 struct iovec xcb_parts[4]; 10980 xcb_glx_is_list_cookie_t xcb_ret; 10981 xcb_glx_is_list_request_t xcb_out; 10982 10983 xcb_out.context_tag = context_tag; 10984 xcb_out.list = list; 10985 10986 xcb_parts[2].iov_base = (char *) &xcb_out; 10987 xcb_parts[2].iov_len = sizeof(xcb_out); 10988 xcb_parts[3].iov_base = 0; 10989 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10990 10991 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10992 return xcb_ret; 10993 } 10994 10995 10996 /***************************************************************************** 10997 ** 10998 ** xcb_glx_is_list_cookie_t xcb_glx_is_list_unchecked 10999 ** 11000 ** @param xcb_connection_t *c 11001 ** @param xcb_glx_context_tag_t context_tag 11002 ** @param uint32_t list 11003 ** @returns xcb_glx_is_list_cookie_t 11004 ** 11005 *****************************************************************************/ 11006 11007 xcb_glx_is_list_cookie_t 11008 xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, 11009 xcb_glx_context_tag_t context_tag /**< */, 11010 uint32_t list /**< */) 11011 { 11012 static const xcb_protocol_request_t xcb_req = { 11013 /* count */ 2, 11014 /* ext */ &xcb_glx_id, 11015 /* opcode */ XCB_GLX_IS_LIST, 11016 /* isvoid */ 0 11017 }; 11018 11019 struct iovec xcb_parts[4]; 11020 xcb_glx_is_list_cookie_t xcb_ret; 11021 xcb_glx_is_list_request_t xcb_out; 11022 11023 xcb_out.context_tag = context_tag; 11024 xcb_out.list = list; 11025 11026 xcb_parts[2].iov_base = (char *) &xcb_out; 11027 xcb_parts[2].iov_len = sizeof(xcb_out); 11028 xcb_parts[3].iov_base = 0; 11029 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11030 11031 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11032 return xcb_ret; 11033 } 11034 11035 11036 /***************************************************************************** 11037 ** 11038 ** xcb_glx_is_list_reply_t * xcb_glx_is_list_reply 11039 ** 11040 ** @param xcb_connection_t *c 11041 ** @param xcb_glx_is_list_cookie_t cookie 11042 ** @param xcb_generic_error_t **e 11043 ** @returns xcb_glx_is_list_reply_t * 11044 ** 11045 *****************************************************************************/ 11046 11047 xcb_glx_is_list_reply_t * 11048 xcb_glx_is_list_reply (xcb_connection_t *c /**< */, 11049 xcb_glx_is_list_cookie_t cookie /**< */, 11050 xcb_generic_error_t **e /**< */) 11051 { 11052 return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11053 } 11054 11055 11056 /***************************************************************************** 11057 ** 11058 ** xcb_void_cookie_t xcb_glx_flush_checked 11059 ** 11060 ** @param xcb_connection_t *c 11061 ** @param xcb_glx_context_tag_t context_tag 11062 ** @returns xcb_void_cookie_t 11063 ** 11064 *****************************************************************************/ 11065 11066 xcb_void_cookie_t 11067 xcb_glx_flush_checked (xcb_connection_t *c /**< */, 11068 xcb_glx_context_tag_t context_tag /**< */) 11069 { 11070 static const xcb_protocol_request_t xcb_req = { 11071 /* count */ 2, 11072 /* ext */ &xcb_glx_id, 11073 /* opcode */ XCB_GLX_FLUSH, 11074 /* isvoid */ 1 11075 }; 11076 11077 struct iovec xcb_parts[4]; 11078 xcb_void_cookie_t xcb_ret; 11079 xcb_glx_flush_request_t xcb_out; 11080 11081 xcb_out.context_tag = context_tag; 11082 11083 xcb_parts[2].iov_base = (char *) &xcb_out; 11084 xcb_parts[2].iov_len = sizeof(xcb_out); 11085 xcb_parts[3].iov_base = 0; 11086 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11087 11088 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11089 return xcb_ret; 11090 } 11091 11092 11093 /***************************************************************************** 11094 ** 11095 ** xcb_void_cookie_t xcb_glx_flush 11096 ** 11097 ** @param xcb_connection_t *c 11098 ** @param xcb_glx_context_tag_t context_tag 11099 ** @returns xcb_void_cookie_t 11100 ** 11101 *****************************************************************************/ 11102 11103 xcb_void_cookie_t 11104 xcb_glx_flush (xcb_connection_t *c /**< */, 11105 xcb_glx_context_tag_t context_tag /**< */) 11106 { 11107 static const xcb_protocol_request_t xcb_req = { 11108 /* count */ 2, 11109 /* ext */ &xcb_glx_id, 11110 /* opcode */ XCB_GLX_FLUSH, 11111 /* isvoid */ 1 11112 }; 11113 11114 struct iovec xcb_parts[4]; 11115 xcb_void_cookie_t xcb_ret; 11116 xcb_glx_flush_request_t xcb_out; 11117 11118 xcb_out.context_tag = context_tag; 11119 11120 xcb_parts[2].iov_base = (char *) &xcb_out; 11121 xcb_parts[2].iov_len = sizeof(xcb_out); 11122 xcb_parts[3].iov_base = 0; 11123 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11124 11125 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11126 return xcb_ret; 11127 } 11128 11129 int 11130 xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */) 11131 { 11132 char *xcb_tmp = (char *)_buffer; 11133 const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer; 11134 unsigned int xcb_buffer_len = 0; 11135 unsigned int xcb_block_len = 0; 11136 unsigned int xcb_pad = 0; 11137 unsigned int xcb_align_to; 11138 11139 11140 xcb_block_len += sizeof(xcb_glx_are_textures_resident_request_t); 11141 xcb_tmp += xcb_block_len; 11142 /* textures */ 11143 xcb_block_len += _aux->n * sizeof(uint32_t); 11144 xcb_tmp += xcb_block_len; 11145 xcb_align_to = ALIGNOF(uint32_t); 11146 /* insert padding */ 11147 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11148 xcb_buffer_len += xcb_block_len + xcb_pad; 11149 if (0 != xcb_pad) { 11150 xcb_tmp += xcb_pad; 11151 xcb_pad = 0; 11152 } 11153 xcb_block_len = 0; 11154 11155 return xcb_buffer_len; 11156 } 11157 11158 11159 /***************************************************************************** 11160 ** 11161 ** xcb_glx_are_textures_resident_cookie_t xcb_glx_are_textures_resident 11162 ** 11163 ** @param xcb_connection_t *c 11164 ** @param xcb_glx_context_tag_t context_tag 11165 ** @param int32_t n 11166 ** @param const uint32_t *textures 11167 ** @returns xcb_glx_are_textures_resident_cookie_t 11168 ** 11169 *****************************************************************************/ 11170 11171 xcb_glx_are_textures_resident_cookie_t 11172 xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, 11173 xcb_glx_context_tag_t context_tag /**< */, 11174 int32_t n /**< */, 11175 const uint32_t *textures /**< */) 11176 { 11177 static const xcb_protocol_request_t xcb_req = { 11178 /* count */ 4, 11179 /* ext */ &xcb_glx_id, 11180 /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, 11181 /* isvoid */ 0 11182 }; 11183 11184 struct iovec xcb_parts[6]; 11185 xcb_glx_are_textures_resident_cookie_t xcb_ret; 11186 xcb_glx_are_textures_resident_request_t xcb_out; 11187 11188 xcb_out.context_tag = context_tag; 11189 xcb_out.n = n; 11190 11191 xcb_parts[2].iov_base = (char *) &xcb_out; 11192 xcb_parts[2].iov_len = sizeof(xcb_out); 11193 xcb_parts[3].iov_base = 0; 11194 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11195 /* uint32_t textures */ 11196 xcb_parts[4].iov_base = (char *) textures; 11197 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 11198 xcb_parts[5].iov_base = 0; 11199 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11200 11201 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11202 return xcb_ret; 11203 } 11204 11205 11206 /***************************************************************************** 11207 ** 11208 ** xcb_glx_are_textures_resident_cookie_t xcb_glx_are_textures_resident_unchecked 11209 ** 11210 ** @param xcb_connection_t *c 11211 ** @param xcb_glx_context_tag_t context_tag 11212 ** @param int32_t n 11213 ** @param const uint32_t *textures 11214 ** @returns xcb_glx_are_textures_resident_cookie_t 11215 ** 11216 *****************************************************************************/ 11217 11218 xcb_glx_are_textures_resident_cookie_t 11219 xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c /**< */, 11220 xcb_glx_context_tag_t context_tag /**< */, 11221 int32_t n /**< */, 11222 const uint32_t *textures /**< */) 11223 { 11224 static const xcb_protocol_request_t xcb_req = { 11225 /* count */ 4, 11226 /* ext */ &xcb_glx_id, 11227 /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, 11228 /* isvoid */ 0 11229 }; 11230 11231 struct iovec xcb_parts[6]; 11232 xcb_glx_are_textures_resident_cookie_t xcb_ret; 11233 xcb_glx_are_textures_resident_request_t xcb_out; 11234 11235 xcb_out.context_tag = context_tag; 11236 xcb_out.n = n; 11237 11238 xcb_parts[2].iov_base = (char *) &xcb_out; 11239 xcb_parts[2].iov_len = sizeof(xcb_out); 11240 xcb_parts[3].iov_base = 0; 11241 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11242 /* uint32_t textures */ 11243 xcb_parts[4].iov_base = (char *) textures; 11244 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 11245 xcb_parts[5].iov_base = 0; 11246 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11247 11248 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11249 return xcb_ret; 11250 } 11251 11252 11253 /***************************************************************************** 11254 ** 11255 ** uint8_t * xcb_glx_are_textures_resident_data 11256 ** 11257 ** @param const xcb_glx_are_textures_resident_reply_t *R 11258 ** @returns uint8_t * 11259 ** 11260 *****************************************************************************/ 11261 11262 uint8_t * 11263 xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11264 { 11265 return (uint8_t *) (R + 1); 11266 } 11267 11268 11269 /***************************************************************************** 11270 ** 11271 ** int xcb_glx_are_textures_resident_data_length 11272 ** 11273 ** @param const xcb_glx_are_textures_resident_reply_t *R 11274 ** @returns int 11275 ** 11276 *****************************************************************************/ 11277 11278 int 11279 xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11280 { 11281 return (R->length * 4); 11282 } 11283 11284 11285 /***************************************************************************** 11286 ** 11287 ** xcb_generic_iterator_t xcb_glx_are_textures_resident_data_end 11288 ** 11289 ** @param const xcb_glx_are_textures_resident_reply_t *R 11290 ** @returns xcb_generic_iterator_t 11291 ** 11292 *****************************************************************************/ 11293 11294 xcb_generic_iterator_t 11295 xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11296 { 11297 xcb_generic_iterator_t i; 11298 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 11299 i.rem = 0; 11300 i.index = (char *) i.data - (char *) R; 11301 return i; 11302 } 11303 11304 11305 /***************************************************************************** 11306 ** 11307 ** xcb_glx_are_textures_resident_reply_t * xcb_glx_are_textures_resident_reply 11308 ** 11309 ** @param xcb_connection_t *c 11310 ** @param xcb_glx_are_textures_resident_cookie_t cookie 11311 ** @param xcb_generic_error_t **e 11312 ** @returns xcb_glx_are_textures_resident_reply_t * 11313 ** 11314 *****************************************************************************/ 11315 11316 xcb_glx_are_textures_resident_reply_t * 11317 xcb_glx_are_textures_resident_reply (xcb_connection_t *c /**< */, 11318 xcb_glx_are_textures_resident_cookie_t cookie /**< */, 11319 xcb_generic_error_t **e /**< */) 11320 { 11321 return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11322 } 11323 11324 int 11325 xcb_glx_delete_textures_sizeof (const void *_buffer /**< */) 11326 { 11327 char *xcb_tmp = (char *)_buffer; 11328 const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer; 11329 unsigned int xcb_buffer_len = 0; 11330 unsigned int xcb_block_len = 0; 11331 unsigned int xcb_pad = 0; 11332 unsigned int xcb_align_to; 11333 11334 11335 xcb_block_len += sizeof(xcb_glx_delete_textures_request_t); 11336 xcb_tmp += xcb_block_len; 11337 /* textures */ 11338 xcb_block_len += _aux->n * sizeof(uint32_t); 11339 xcb_tmp += xcb_block_len; 11340 xcb_align_to = ALIGNOF(uint32_t); 11341 /* insert padding */ 11342 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11343 xcb_buffer_len += xcb_block_len + xcb_pad; 11344 if (0 != xcb_pad) { 11345 xcb_tmp += xcb_pad; 11346 xcb_pad = 0; 11347 } 11348 xcb_block_len = 0; 11349 11350 return xcb_buffer_len; 11351 } 11352 11353 11354 /***************************************************************************** 11355 ** 11356 ** xcb_void_cookie_t xcb_glx_delete_textures_checked 11357 ** 11358 ** @param xcb_connection_t *c 11359 ** @param xcb_glx_context_tag_t context_tag 11360 ** @param int32_t n 11361 ** @param const uint32_t *textures 11362 ** @returns xcb_void_cookie_t 11363 ** 11364 *****************************************************************************/ 11365 11366 xcb_void_cookie_t 11367 xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, 11368 xcb_glx_context_tag_t context_tag /**< */, 11369 int32_t n /**< */, 11370 const uint32_t *textures /**< */) 11371 { 11372 static const xcb_protocol_request_t xcb_req = { 11373 /* count */ 4, 11374 /* ext */ &xcb_glx_id, 11375 /* opcode */ XCB_GLX_DELETE_TEXTURES, 11376 /* isvoid */ 1 11377 }; 11378 11379 struct iovec xcb_parts[6]; 11380 xcb_void_cookie_t xcb_ret; 11381 xcb_glx_delete_textures_request_t xcb_out; 11382 11383 xcb_out.context_tag = context_tag; 11384 xcb_out.n = n; 11385 11386 xcb_parts[2].iov_base = (char *) &xcb_out; 11387 xcb_parts[2].iov_len = sizeof(xcb_out); 11388 xcb_parts[3].iov_base = 0; 11389 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11390 /* uint32_t textures */ 11391 xcb_parts[4].iov_base = (char *) textures; 11392 xcb_parts[4].iov_len = n * sizeof(uint32_t); 11393 xcb_parts[5].iov_base = 0; 11394 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11395 11396 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11397 return xcb_ret; 11398 } 11399 11400 11401 /***************************************************************************** 11402 ** 11403 ** xcb_void_cookie_t xcb_glx_delete_textures 11404 ** 11405 ** @param xcb_connection_t *c 11406 ** @param xcb_glx_context_tag_t context_tag 11407 ** @param int32_t n 11408 ** @param const uint32_t *textures 11409 ** @returns xcb_void_cookie_t 11410 ** 11411 *****************************************************************************/ 11412 11413 xcb_void_cookie_t 11414 xcb_glx_delete_textures (xcb_connection_t *c /**< */, 11415 xcb_glx_context_tag_t context_tag /**< */, 11416 int32_t n /**< */, 11417 const uint32_t *textures /**< */) 11418 { 11419 static const xcb_protocol_request_t xcb_req = { 11420 /* count */ 4, 11421 /* ext */ &xcb_glx_id, 11422 /* opcode */ XCB_GLX_DELETE_TEXTURES, 11423 /* isvoid */ 1 11424 }; 11425 11426 struct iovec xcb_parts[6]; 11427 xcb_void_cookie_t xcb_ret; 11428 xcb_glx_delete_textures_request_t xcb_out; 11429 11430 xcb_out.context_tag = context_tag; 11431 xcb_out.n = n; 11432 11433 xcb_parts[2].iov_base = (char *) &xcb_out; 11434 xcb_parts[2].iov_len = sizeof(xcb_out); 11435 xcb_parts[3].iov_base = 0; 11436 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11437 /* uint32_t textures */ 11438 xcb_parts[4].iov_base = (char *) textures; 11439 xcb_parts[4].iov_len = n * sizeof(uint32_t); 11440 xcb_parts[5].iov_base = 0; 11441 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11442 11443 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11444 return xcb_ret; 11445 } 11446 11447 int 11448 xcb_glx_gen_textures_sizeof (const void *_buffer /**< */) 11449 { 11450 char *xcb_tmp = (char *)_buffer; 11451 const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer; 11452 unsigned int xcb_buffer_len = 0; 11453 unsigned int xcb_block_len = 0; 11454 unsigned int xcb_pad = 0; 11455 unsigned int xcb_align_to; 11456 11457 11458 xcb_block_len += sizeof(xcb_glx_gen_textures_reply_t); 11459 xcb_tmp += xcb_block_len; 11460 /* data */ 11461 xcb_block_len += _aux->length * sizeof(uint32_t); 11462 xcb_tmp += xcb_block_len; 11463 xcb_align_to = ALIGNOF(uint32_t); 11464 /* insert padding */ 11465 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11466 xcb_buffer_len += xcb_block_len + xcb_pad; 11467 if (0 != xcb_pad) { 11468 xcb_tmp += xcb_pad; 11469 xcb_pad = 0; 11470 } 11471 xcb_block_len = 0; 11472 11473 return xcb_buffer_len; 11474 } 11475 11476 11477 /***************************************************************************** 11478 ** 11479 ** xcb_glx_gen_textures_cookie_t xcb_glx_gen_textures 11480 ** 11481 ** @param xcb_connection_t *c 11482 ** @param xcb_glx_context_tag_t context_tag 11483 ** @param int32_t n 11484 ** @returns xcb_glx_gen_textures_cookie_t 11485 ** 11486 *****************************************************************************/ 11487 11488 xcb_glx_gen_textures_cookie_t 11489 xcb_glx_gen_textures (xcb_connection_t *c /**< */, 11490 xcb_glx_context_tag_t context_tag /**< */, 11491 int32_t n /**< */) 11492 { 11493 static const xcb_protocol_request_t xcb_req = { 11494 /* count */ 2, 11495 /* ext */ &xcb_glx_id, 11496 /* opcode */ XCB_GLX_GEN_TEXTURES, 11497 /* isvoid */ 0 11498 }; 11499 11500 struct iovec xcb_parts[4]; 11501 xcb_glx_gen_textures_cookie_t xcb_ret; 11502 xcb_glx_gen_textures_request_t xcb_out; 11503 11504 xcb_out.context_tag = context_tag; 11505 xcb_out.n = n; 11506 11507 xcb_parts[2].iov_base = (char *) &xcb_out; 11508 xcb_parts[2].iov_len = sizeof(xcb_out); 11509 xcb_parts[3].iov_base = 0; 11510 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11511 11512 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11513 return xcb_ret; 11514 } 11515 11516 11517 /***************************************************************************** 11518 ** 11519 ** xcb_glx_gen_textures_cookie_t xcb_glx_gen_textures_unchecked 11520 ** 11521 ** @param xcb_connection_t *c 11522 ** @param xcb_glx_context_tag_t context_tag 11523 ** @param int32_t n 11524 ** @returns xcb_glx_gen_textures_cookie_t 11525 ** 11526 *****************************************************************************/ 11527 11528 xcb_glx_gen_textures_cookie_t 11529 xcb_glx_gen_textures_unchecked (xcb_connection_t *c /**< */, 11530 xcb_glx_context_tag_t context_tag /**< */, 11531 int32_t n /**< */) 11532 { 11533 static const xcb_protocol_request_t xcb_req = { 11534 /* count */ 2, 11535 /* ext */ &xcb_glx_id, 11536 /* opcode */ XCB_GLX_GEN_TEXTURES, 11537 /* isvoid */ 0 11538 }; 11539 11540 struct iovec xcb_parts[4]; 11541 xcb_glx_gen_textures_cookie_t xcb_ret; 11542 xcb_glx_gen_textures_request_t xcb_out; 11543 11544 xcb_out.context_tag = context_tag; 11545 xcb_out.n = n; 11546 11547 xcb_parts[2].iov_base = (char *) &xcb_out; 11548 xcb_parts[2].iov_len = sizeof(xcb_out); 11549 xcb_parts[3].iov_base = 0; 11550 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11551 11552 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11553 return xcb_ret; 11554 } 11555 11556 11557 /***************************************************************************** 11558 ** 11559 ** uint32_t * xcb_glx_gen_textures_data 11560 ** 11561 ** @param const xcb_glx_gen_textures_reply_t *R 11562 ** @returns uint32_t * 11563 ** 11564 *****************************************************************************/ 11565 11566 uint32_t * 11567 xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R /**< */) 11568 { 11569 return (uint32_t *) (R + 1); 11570 } 11571 11572 11573 /***************************************************************************** 11574 ** 11575 ** int xcb_glx_gen_textures_data_length 11576 ** 11577 ** @param const xcb_glx_gen_textures_reply_t *R 11578 ** @returns int 11579 ** 11580 *****************************************************************************/ 11581 11582 int 11583 xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R /**< */) 11584 { 11585 return R->length; 11586 } 11587 11588 11589 /***************************************************************************** 11590 ** 11591 ** xcb_generic_iterator_t xcb_glx_gen_textures_data_end 11592 ** 11593 ** @param const xcb_glx_gen_textures_reply_t *R 11594 ** @returns xcb_generic_iterator_t 11595 ** 11596 *****************************************************************************/ 11597 11598 xcb_generic_iterator_t 11599 xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */) 11600 { 11601 xcb_generic_iterator_t i; 11602 i.data = ((uint32_t *) (R + 1)) + (R->length); 11603 i.rem = 0; 11604 i.index = (char *) i.data - (char *) R; 11605 return i; 11606 } 11607 11608 11609 /***************************************************************************** 11610 ** 11611 ** xcb_glx_gen_textures_reply_t * xcb_glx_gen_textures_reply 11612 ** 11613 ** @param xcb_connection_t *c 11614 ** @param xcb_glx_gen_textures_cookie_t cookie 11615 ** @param xcb_generic_error_t **e 11616 ** @returns xcb_glx_gen_textures_reply_t * 11617 ** 11618 *****************************************************************************/ 11619 11620 xcb_glx_gen_textures_reply_t * 11621 xcb_glx_gen_textures_reply (xcb_connection_t *c /**< */, 11622 xcb_glx_gen_textures_cookie_t cookie /**< */, 11623 xcb_generic_error_t **e /**< */) 11624 { 11625 return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11626 } 11627 11628 11629 /***************************************************************************** 11630 ** 11631 ** xcb_glx_is_texture_cookie_t xcb_glx_is_texture 11632 ** 11633 ** @param xcb_connection_t *c 11634 ** @param xcb_glx_context_tag_t context_tag 11635 ** @param uint32_t texture 11636 ** @returns xcb_glx_is_texture_cookie_t 11637 ** 11638 *****************************************************************************/ 11639 11640 xcb_glx_is_texture_cookie_t 11641 xcb_glx_is_texture (xcb_connection_t *c /**< */, 11642 xcb_glx_context_tag_t context_tag /**< */, 11643 uint32_t texture /**< */) 11644 { 11645 static const xcb_protocol_request_t xcb_req = { 11646 /* count */ 2, 11647 /* ext */ &xcb_glx_id, 11648 /* opcode */ XCB_GLX_IS_TEXTURE, 11649 /* isvoid */ 0 11650 }; 11651 11652 struct iovec xcb_parts[4]; 11653 xcb_glx_is_texture_cookie_t xcb_ret; 11654 xcb_glx_is_texture_request_t xcb_out; 11655 11656 xcb_out.context_tag = context_tag; 11657 xcb_out.texture = texture; 11658 11659 xcb_parts[2].iov_base = (char *) &xcb_out; 11660 xcb_parts[2].iov_len = sizeof(xcb_out); 11661 xcb_parts[3].iov_base = 0; 11662 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11663 11664 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11665 return xcb_ret; 11666 } 11667 11668 11669 /***************************************************************************** 11670 ** 11671 ** xcb_glx_is_texture_cookie_t xcb_glx_is_texture_unchecked 11672 ** 11673 ** @param xcb_connection_t *c 11674 ** @param xcb_glx_context_tag_t context_tag 11675 ** @param uint32_t texture 11676 ** @returns xcb_glx_is_texture_cookie_t 11677 ** 11678 *****************************************************************************/ 11679 11680 xcb_glx_is_texture_cookie_t 11681 xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, 11682 xcb_glx_context_tag_t context_tag /**< */, 11683 uint32_t texture /**< */) 11684 { 11685 static const xcb_protocol_request_t xcb_req = { 11686 /* count */ 2, 11687 /* ext */ &xcb_glx_id, 11688 /* opcode */ XCB_GLX_IS_TEXTURE, 11689 /* isvoid */ 0 11690 }; 11691 11692 struct iovec xcb_parts[4]; 11693 xcb_glx_is_texture_cookie_t xcb_ret; 11694 xcb_glx_is_texture_request_t xcb_out; 11695 11696 xcb_out.context_tag = context_tag; 11697 xcb_out.texture = texture; 11698 11699 xcb_parts[2].iov_base = (char *) &xcb_out; 11700 xcb_parts[2].iov_len = sizeof(xcb_out); 11701 xcb_parts[3].iov_base = 0; 11702 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11703 11704 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11705 return xcb_ret; 11706 } 11707 11708 11709 /***************************************************************************** 11710 ** 11711 ** xcb_glx_is_texture_reply_t * xcb_glx_is_texture_reply 11712 ** 11713 ** @param xcb_connection_t *c 11714 ** @param xcb_glx_is_texture_cookie_t cookie 11715 ** @param xcb_generic_error_t **e 11716 ** @returns xcb_glx_is_texture_reply_t * 11717 ** 11718 *****************************************************************************/ 11719 11720 xcb_glx_is_texture_reply_t * 11721 xcb_glx_is_texture_reply (xcb_connection_t *c /**< */, 11722 xcb_glx_is_texture_cookie_t cookie /**< */, 11723 xcb_generic_error_t **e /**< */) 11724 { 11725 return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11726 } 11727 11728 int 11729 xcb_glx_get_color_table_sizeof (const void *_buffer /**< */) 11730 { 11731 char *xcb_tmp = (char *)_buffer; 11732 const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer; 11733 unsigned int xcb_buffer_len = 0; 11734 unsigned int xcb_block_len = 0; 11735 unsigned int xcb_pad = 0; 11736 unsigned int xcb_align_to; 11737 11738 11739 xcb_block_len += sizeof(xcb_glx_get_color_table_reply_t); 11740 xcb_tmp += xcb_block_len; 11741 /* data */ 11742 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 11743 xcb_tmp += xcb_block_len; 11744 xcb_align_to = ALIGNOF(uint8_t); 11745 /* insert padding */ 11746 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11747 xcb_buffer_len += xcb_block_len + xcb_pad; 11748 if (0 != xcb_pad) { 11749 xcb_tmp += xcb_pad; 11750 xcb_pad = 0; 11751 } 11752 xcb_block_len = 0; 11753 11754 return xcb_buffer_len; 11755 } 11756 11757 11758 /***************************************************************************** 11759 ** 11760 ** xcb_glx_get_color_table_cookie_t xcb_glx_get_color_table 11761 ** 11762 ** @param xcb_connection_t *c 11763 ** @param xcb_glx_context_tag_t context_tag 11764 ** @param uint32_t target 11765 ** @param uint32_t format 11766 ** @param uint32_t type 11767 ** @param uint8_t swap_bytes 11768 ** @returns xcb_glx_get_color_table_cookie_t 11769 ** 11770 *****************************************************************************/ 11771 11772 xcb_glx_get_color_table_cookie_t 11773 xcb_glx_get_color_table (xcb_connection_t *c /**< */, 11774 xcb_glx_context_tag_t context_tag /**< */, 11775 uint32_t target /**< */, 11776 uint32_t format /**< */, 11777 uint32_t type /**< */, 11778 uint8_t swap_bytes /**< */) 11779 { 11780 static const xcb_protocol_request_t xcb_req = { 11781 /* count */ 2, 11782 /* ext */ &xcb_glx_id, 11783 /* opcode */ XCB_GLX_GET_COLOR_TABLE, 11784 /* isvoid */ 0 11785 }; 11786 11787 struct iovec xcb_parts[4]; 11788 xcb_glx_get_color_table_cookie_t xcb_ret; 11789 xcb_glx_get_color_table_request_t xcb_out; 11790 11791 xcb_out.context_tag = context_tag; 11792 xcb_out.target = target; 11793 xcb_out.format = format; 11794 xcb_out.type = type; 11795 xcb_out.swap_bytes = swap_bytes; 11796 11797 xcb_parts[2].iov_base = (char *) &xcb_out; 11798 xcb_parts[2].iov_len = sizeof(xcb_out); 11799 xcb_parts[3].iov_base = 0; 11800 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11801 11802 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11803 return xcb_ret; 11804 } 11805 11806 11807 /***************************************************************************** 11808 ** 11809 ** xcb_glx_get_color_table_cookie_t xcb_glx_get_color_table_unchecked 11810 ** 11811 ** @param xcb_connection_t *c 11812 ** @param xcb_glx_context_tag_t context_tag 11813 ** @param uint32_t target 11814 ** @param uint32_t format 11815 ** @param uint32_t type 11816 ** @param uint8_t swap_bytes 11817 ** @returns xcb_glx_get_color_table_cookie_t 11818 ** 11819 *****************************************************************************/ 11820 11821 xcb_glx_get_color_table_cookie_t 11822 xcb_glx_get_color_table_unchecked (xcb_connection_t *c /**< */, 11823 xcb_glx_context_tag_t context_tag /**< */, 11824 uint32_t target /**< */, 11825 uint32_t format /**< */, 11826 uint32_t type /**< */, 11827 uint8_t swap_bytes /**< */) 11828 { 11829 static const xcb_protocol_request_t xcb_req = { 11830 /* count */ 2, 11831 /* ext */ &xcb_glx_id, 11832 /* opcode */ XCB_GLX_GET_COLOR_TABLE, 11833 /* isvoid */ 0 11834 }; 11835 11836 struct iovec xcb_parts[4]; 11837 xcb_glx_get_color_table_cookie_t xcb_ret; 11838 xcb_glx_get_color_table_request_t xcb_out; 11839 11840 xcb_out.context_tag = context_tag; 11841 xcb_out.target = target; 11842 xcb_out.format = format; 11843 xcb_out.type = type; 11844 xcb_out.swap_bytes = swap_bytes; 11845 11846 xcb_parts[2].iov_base = (char *) &xcb_out; 11847 xcb_parts[2].iov_len = sizeof(xcb_out); 11848 xcb_parts[3].iov_base = 0; 11849 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11850 11851 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11852 return xcb_ret; 11853 } 11854 11855 11856 /***************************************************************************** 11857 ** 11858 ** uint8_t * xcb_glx_get_color_table_data 11859 ** 11860 ** @param const xcb_glx_get_color_table_reply_t *R 11861 ** @returns uint8_t * 11862 ** 11863 *****************************************************************************/ 11864 11865 uint8_t * 11866 xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R /**< */) 11867 { 11868 return (uint8_t *) (R + 1); 11869 } 11870 11871 11872 /***************************************************************************** 11873 ** 11874 ** int xcb_glx_get_color_table_data_length 11875 ** 11876 ** @param const xcb_glx_get_color_table_reply_t *R 11877 ** @returns int 11878 ** 11879 *****************************************************************************/ 11880 11881 int 11882 xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R /**< */) 11883 { 11884 return (R->length * 4); 11885 } 11886 11887 11888 /***************************************************************************** 11889 ** 11890 ** xcb_generic_iterator_t xcb_glx_get_color_table_data_end 11891 ** 11892 ** @param const xcb_glx_get_color_table_reply_t *R 11893 ** @returns xcb_generic_iterator_t 11894 ** 11895 *****************************************************************************/ 11896 11897 xcb_generic_iterator_t 11898 xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< */) 11899 { 11900 xcb_generic_iterator_t i; 11901 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 11902 i.rem = 0; 11903 i.index = (char *) i.data - (char *) R; 11904 return i; 11905 } 11906 11907 11908 /***************************************************************************** 11909 ** 11910 ** xcb_glx_get_color_table_reply_t * xcb_glx_get_color_table_reply 11911 ** 11912 ** @param xcb_connection_t *c 11913 ** @param xcb_glx_get_color_table_cookie_t cookie 11914 ** @param xcb_generic_error_t **e 11915 ** @returns xcb_glx_get_color_table_reply_t * 11916 ** 11917 *****************************************************************************/ 11918 11919 xcb_glx_get_color_table_reply_t * 11920 xcb_glx_get_color_table_reply (xcb_connection_t *c /**< */, 11921 xcb_glx_get_color_table_cookie_t cookie /**< */, 11922 xcb_generic_error_t **e /**< */) 11923 { 11924 return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11925 } 11926 11927 int 11928 xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */) 11929 { 11930 char *xcb_tmp = (char *)_buffer; 11931 const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer; 11932 unsigned int xcb_buffer_len = 0; 11933 unsigned int xcb_block_len = 0; 11934 unsigned int xcb_pad = 0; 11935 unsigned int xcb_align_to; 11936 11937 11938 xcb_block_len += sizeof(xcb_glx_get_color_table_parameterfv_reply_t); 11939 xcb_tmp += xcb_block_len; 11940 /* data */ 11941 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 11942 xcb_tmp += xcb_block_len; 11943 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 11944 /* insert padding */ 11945 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11946 xcb_buffer_len += xcb_block_len + xcb_pad; 11947 if (0 != xcb_pad) { 11948 xcb_tmp += xcb_pad; 11949 xcb_pad = 0; 11950 } 11951 xcb_block_len = 0; 11952 11953 return xcb_buffer_len; 11954 } 11955 11956 11957 /***************************************************************************** 11958 ** 11959 ** xcb_glx_get_color_table_parameterfv_cookie_t xcb_glx_get_color_table_parameterfv 11960 ** 11961 ** @param xcb_connection_t *c 11962 ** @param xcb_glx_context_tag_t context_tag 11963 ** @param uint32_t target 11964 ** @param uint32_t pname 11965 ** @returns xcb_glx_get_color_table_parameterfv_cookie_t 11966 ** 11967 *****************************************************************************/ 11968 11969 xcb_glx_get_color_table_parameterfv_cookie_t 11970 xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, 11971 xcb_glx_context_tag_t context_tag /**< */, 11972 uint32_t target /**< */, 11973 uint32_t pname /**< */) 11974 { 11975 static const xcb_protocol_request_t xcb_req = { 11976 /* count */ 2, 11977 /* ext */ &xcb_glx_id, 11978 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 11979 /* isvoid */ 0 11980 }; 11981 11982 struct iovec xcb_parts[4]; 11983 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 11984 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 11985 11986 xcb_out.context_tag = context_tag; 11987 xcb_out.target = target; 11988 xcb_out.pname = pname; 11989 11990 xcb_parts[2].iov_base = (char *) &xcb_out; 11991 xcb_parts[2].iov_len = sizeof(xcb_out); 11992 xcb_parts[3].iov_base = 0; 11993 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11994 11995 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11996 return xcb_ret; 11997 } 11998 11999 12000 /***************************************************************************** 12001 ** 12002 ** xcb_glx_get_color_table_parameterfv_cookie_t xcb_glx_get_color_table_parameterfv_unchecked 12003 ** 12004 ** @param xcb_connection_t *c 12005 ** @param xcb_glx_context_tag_t context_tag 12006 ** @param uint32_t target 12007 ** @param uint32_t pname 12008 ** @returns xcb_glx_get_color_table_parameterfv_cookie_t 12009 ** 12010 *****************************************************************************/ 12011 12012 xcb_glx_get_color_table_parameterfv_cookie_t 12013 xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c /**< */, 12014 xcb_glx_context_tag_t context_tag /**< */, 12015 uint32_t target /**< */, 12016 uint32_t pname /**< */) 12017 { 12018 static const xcb_protocol_request_t xcb_req = { 12019 /* count */ 2, 12020 /* ext */ &xcb_glx_id, 12021 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 12022 /* isvoid */ 0 12023 }; 12024 12025 struct iovec xcb_parts[4]; 12026 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 12027 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 12028 12029 xcb_out.context_tag = context_tag; 12030 xcb_out.target = target; 12031 xcb_out.pname = pname; 12032 12033 xcb_parts[2].iov_base = (char *) &xcb_out; 12034 xcb_parts[2].iov_len = sizeof(xcb_out); 12035 xcb_parts[3].iov_base = 0; 12036 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12037 12038 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12039 return xcb_ret; 12040 } 12041 12042 12043 /***************************************************************************** 12044 ** 12045 ** xcb_glx_float32_t * xcb_glx_get_color_table_parameterfv_data 12046 ** 12047 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12048 ** @returns xcb_glx_float32_t * 12049 ** 12050 *****************************************************************************/ 12051 12052 xcb_glx_float32_t * 12053 xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12054 { 12055 return (xcb_glx_float32_t *) (R + 1); 12056 } 12057 12058 12059 /***************************************************************************** 12060 ** 12061 ** int xcb_glx_get_color_table_parameterfv_data_length 12062 ** 12063 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12064 ** @returns int 12065 ** 12066 *****************************************************************************/ 12067 12068 int 12069 xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12070 { 12071 return R->n; 12072 } 12073 12074 12075 /***************************************************************************** 12076 ** 12077 ** xcb_generic_iterator_t xcb_glx_get_color_table_parameterfv_data_end 12078 ** 12079 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12080 ** @returns xcb_generic_iterator_t 12081 ** 12082 *****************************************************************************/ 12083 12084 xcb_generic_iterator_t 12085 xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12086 { 12087 xcb_generic_iterator_t i; 12088 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 12089 i.rem = 0; 12090 i.index = (char *) i.data - (char *) R; 12091 return i; 12092 } 12093 12094 12095 /***************************************************************************** 12096 ** 12097 ** xcb_glx_get_color_table_parameterfv_reply_t * xcb_glx_get_color_table_parameterfv_reply 12098 ** 12099 ** @param xcb_connection_t *c 12100 ** @param xcb_glx_get_color_table_parameterfv_cookie_t cookie 12101 ** @param xcb_generic_error_t **e 12102 ** @returns xcb_glx_get_color_table_parameterfv_reply_t * 12103 ** 12104 *****************************************************************************/ 12105 12106 xcb_glx_get_color_table_parameterfv_reply_t * 12107 xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c /**< */, 12108 xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, 12109 xcb_generic_error_t **e /**< */) 12110 { 12111 return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12112 } 12113 12114 int 12115 xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */) 12116 { 12117 char *xcb_tmp = (char *)_buffer; 12118 const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer; 12119 unsigned int xcb_buffer_len = 0; 12120 unsigned int xcb_block_len = 0; 12121 unsigned int xcb_pad = 0; 12122 unsigned int xcb_align_to; 12123 12124 12125 xcb_block_len += sizeof(xcb_glx_get_color_table_parameteriv_reply_t); 12126 xcb_tmp += xcb_block_len; 12127 /* data */ 12128 xcb_block_len += _aux->n * sizeof(int32_t); 12129 xcb_tmp += xcb_block_len; 12130 xcb_align_to = ALIGNOF(int32_t); 12131 /* insert padding */ 12132 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12133 xcb_buffer_len += xcb_block_len + xcb_pad; 12134 if (0 != xcb_pad) { 12135 xcb_tmp += xcb_pad; 12136 xcb_pad = 0; 12137 } 12138 xcb_block_len = 0; 12139 12140 return xcb_buffer_len; 12141 } 12142 12143 12144 /***************************************************************************** 12145 ** 12146 ** xcb_glx_get_color_table_parameteriv_cookie_t xcb_glx_get_color_table_parameteriv 12147 ** 12148 ** @param xcb_connection_t *c 12149 ** @param xcb_glx_context_tag_t context_tag 12150 ** @param uint32_t target 12151 ** @param uint32_t pname 12152 ** @returns xcb_glx_get_color_table_parameteriv_cookie_t 12153 ** 12154 *****************************************************************************/ 12155 12156 xcb_glx_get_color_table_parameteriv_cookie_t 12157 xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, 12158 xcb_glx_context_tag_t context_tag /**< */, 12159 uint32_t target /**< */, 12160 uint32_t pname /**< */) 12161 { 12162 static const xcb_protocol_request_t xcb_req = { 12163 /* count */ 2, 12164 /* ext */ &xcb_glx_id, 12165 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 12166 /* isvoid */ 0 12167 }; 12168 12169 struct iovec xcb_parts[4]; 12170 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 12171 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 12172 12173 xcb_out.context_tag = context_tag; 12174 xcb_out.target = target; 12175 xcb_out.pname = pname; 12176 12177 xcb_parts[2].iov_base = (char *) &xcb_out; 12178 xcb_parts[2].iov_len = sizeof(xcb_out); 12179 xcb_parts[3].iov_base = 0; 12180 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12181 12182 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12183 return xcb_ret; 12184 } 12185 12186 12187 /***************************************************************************** 12188 ** 12189 ** xcb_glx_get_color_table_parameteriv_cookie_t xcb_glx_get_color_table_parameteriv_unchecked 12190 ** 12191 ** @param xcb_connection_t *c 12192 ** @param xcb_glx_context_tag_t context_tag 12193 ** @param uint32_t target 12194 ** @param uint32_t pname 12195 ** @returns xcb_glx_get_color_table_parameteriv_cookie_t 12196 ** 12197 *****************************************************************************/ 12198 12199 xcb_glx_get_color_table_parameteriv_cookie_t 12200 xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c /**< */, 12201 xcb_glx_context_tag_t context_tag /**< */, 12202 uint32_t target /**< */, 12203 uint32_t pname /**< */) 12204 { 12205 static const xcb_protocol_request_t xcb_req = { 12206 /* count */ 2, 12207 /* ext */ &xcb_glx_id, 12208 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 12209 /* isvoid */ 0 12210 }; 12211 12212 struct iovec xcb_parts[4]; 12213 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 12214 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 12215 12216 xcb_out.context_tag = context_tag; 12217 xcb_out.target = target; 12218 xcb_out.pname = pname; 12219 12220 xcb_parts[2].iov_base = (char *) &xcb_out; 12221 xcb_parts[2].iov_len = sizeof(xcb_out); 12222 xcb_parts[3].iov_base = 0; 12223 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12224 12225 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12226 return xcb_ret; 12227 } 12228 12229 12230 /***************************************************************************** 12231 ** 12232 ** int32_t * xcb_glx_get_color_table_parameteriv_data 12233 ** 12234 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12235 ** @returns int32_t * 12236 ** 12237 *****************************************************************************/ 12238 12239 int32_t * 12240 xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12241 { 12242 return (int32_t *) (R + 1); 12243 } 12244 12245 12246 /***************************************************************************** 12247 ** 12248 ** int xcb_glx_get_color_table_parameteriv_data_length 12249 ** 12250 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12251 ** @returns int 12252 ** 12253 *****************************************************************************/ 12254 12255 int 12256 xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12257 { 12258 return R->n; 12259 } 12260 12261 12262 /***************************************************************************** 12263 ** 12264 ** xcb_generic_iterator_t xcb_glx_get_color_table_parameteriv_data_end 12265 ** 12266 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12267 ** @returns xcb_generic_iterator_t 12268 ** 12269 *****************************************************************************/ 12270 12271 xcb_generic_iterator_t 12272 xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12273 { 12274 xcb_generic_iterator_t i; 12275 i.data = ((int32_t *) (R + 1)) + (R->n); 12276 i.rem = 0; 12277 i.index = (char *) i.data - (char *) R; 12278 return i; 12279 } 12280 12281 12282 /***************************************************************************** 12283 ** 12284 ** xcb_glx_get_color_table_parameteriv_reply_t * xcb_glx_get_color_table_parameteriv_reply 12285 ** 12286 ** @param xcb_connection_t *c 12287 ** @param xcb_glx_get_color_table_parameteriv_cookie_t cookie 12288 ** @param xcb_generic_error_t **e 12289 ** @returns xcb_glx_get_color_table_parameteriv_reply_t * 12290 ** 12291 *****************************************************************************/ 12292 12293 xcb_glx_get_color_table_parameteriv_reply_t * 12294 xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c /**< */, 12295 xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, 12296 xcb_generic_error_t **e /**< */) 12297 { 12298 return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12299 } 12300 12301 int 12302 xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */) 12303 { 12304 char *xcb_tmp = (char *)_buffer; 12305 const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer; 12306 unsigned int xcb_buffer_len = 0; 12307 unsigned int xcb_block_len = 0; 12308 unsigned int xcb_pad = 0; 12309 unsigned int xcb_align_to; 12310 12311 12312 xcb_block_len += sizeof(xcb_glx_get_convolution_filter_reply_t); 12313 xcb_tmp += xcb_block_len; 12314 /* data */ 12315 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 12316 xcb_tmp += xcb_block_len; 12317 xcb_align_to = ALIGNOF(uint8_t); 12318 /* insert padding */ 12319 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12320 xcb_buffer_len += xcb_block_len + xcb_pad; 12321 if (0 != xcb_pad) { 12322 xcb_tmp += xcb_pad; 12323 xcb_pad = 0; 12324 } 12325 xcb_block_len = 0; 12326 12327 return xcb_buffer_len; 12328 } 12329 12330 12331 /***************************************************************************** 12332 ** 12333 ** xcb_glx_get_convolution_filter_cookie_t xcb_glx_get_convolution_filter 12334 ** 12335 ** @param xcb_connection_t *c 12336 ** @param xcb_glx_context_tag_t context_tag 12337 ** @param uint32_t target 12338 ** @param uint32_t format 12339 ** @param uint32_t type 12340 ** @param uint8_t swap_bytes 12341 ** @returns xcb_glx_get_convolution_filter_cookie_t 12342 ** 12343 *****************************************************************************/ 12344 12345 xcb_glx_get_convolution_filter_cookie_t 12346 xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, 12347 xcb_glx_context_tag_t context_tag /**< */, 12348 uint32_t target /**< */, 12349 uint32_t format /**< */, 12350 uint32_t type /**< */, 12351 uint8_t swap_bytes /**< */) 12352 { 12353 static const xcb_protocol_request_t xcb_req = { 12354 /* count */ 2, 12355 /* ext */ &xcb_glx_id, 12356 /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, 12357 /* isvoid */ 0 12358 }; 12359 12360 struct iovec xcb_parts[4]; 12361 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 12362 xcb_glx_get_convolution_filter_request_t xcb_out; 12363 12364 xcb_out.context_tag = context_tag; 12365 xcb_out.target = target; 12366 xcb_out.format = format; 12367 xcb_out.type = type; 12368 xcb_out.swap_bytes = swap_bytes; 12369 12370 xcb_parts[2].iov_base = (char *) &xcb_out; 12371 xcb_parts[2].iov_len = sizeof(xcb_out); 12372 xcb_parts[3].iov_base = 0; 12373 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12374 12375 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12376 return xcb_ret; 12377 } 12378 12379 12380 /***************************************************************************** 12381 ** 12382 ** xcb_glx_get_convolution_filter_cookie_t xcb_glx_get_convolution_filter_unchecked 12383 ** 12384 ** @param xcb_connection_t *c 12385 ** @param xcb_glx_context_tag_t context_tag 12386 ** @param uint32_t target 12387 ** @param uint32_t format 12388 ** @param uint32_t type 12389 ** @param uint8_t swap_bytes 12390 ** @returns xcb_glx_get_convolution_filter_cookie_t 12391 ** 12392 *****************************************************************************/ 12393 12394 xcb_glx_get_convolution_filter_cookie_t 12395 xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c /**< */, 12396 xcb_glx_context_tag_t context_tag /**< */, 12397 uint32_t target /**< */, 12398 uint32_t format /**< */, 12399 uint32_t type /**< */, 12400 uint8_t swap_bytes /**< */) 12401 { 12402 static const xcb_protocol_request_t xcb_req = { 12403 /* count */ 2, 12404 /* ext */ &xcb_glx_id, 12405 /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, 12406 /* isvoid */ 0 12407 }; 12408 12409 struct iovec xcb_parts[4]; 12410 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 12411 xcb_glx_get_convolution_filter_request_t xcb_out; 12412 12413 xcb_out.context_tag = context_tag; 12414 xcb_out.target = target; 12415 xcb_out.format = format; 12416 xcb_out.type = type; 12417 xcb_out.swap_bytes = swap_bytes; 12418 12419 xcb_parts[2].iov_base = (char *) &xcb_out; 12420 xcb_parts[2].iov_len = sizeof(xcb_out); 12421 xcb_parts[3].iov_base = 0; 12422 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12423 12424 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12425 return xcb_ret; 12426 } 12427 12428 12429 /***************************************************************************** 12430 ** 12431 ** uint8_t * xcb_glx_get_convolution_filter_data 12432 ** 12433 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12434 ** @returns uint8_t * 12435 ** 12436 *****************************************************************************/ 12437 12438 uint8_t * 12439 xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12440 { 12441 return (uint8_t *) (R + 1); 12442 } 12443 12444 12445 /***************************************************************************** 12446 ** 12447 ** int xcb_glx_get_convolution_filter_data_length 12448 ** 12449 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12450 ** @returns int 12451 ** 12452 *****************************************************************************/ 12453 12454 int 12455 xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12456 { 12457 return (R->length * 4); 12458 } 12459 12460 12461 /***************************************************************************** 12462 ** 12463 ** xcb_generic_iterator_t xcb_glx_get_convolution_filter_data_end 12464 ** 12465 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12466 ** @returns xcb_generic_iterator_t 12467 ** 12468 *****************************************************************************/ 12469 12470 xcb_generic_iterator_t 12471 xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12472 { 12473 xcb_generic_iterator_t i; 12474 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 12475 i.rem = 0; 12476 i.index = (char *) i.data - (char *) R; 12477 return i; 12478 } 12479 12480 12481 /***************************************************************************** 12482 ** 12483 ** xcb_glx_get_convolution_filter_reply_t * xcb_glx_get_convolution_filter_reply 12484 ** 12485 ** @param xcb_connection_t *c 12486 ** @param xcb_glx_get_convolution_filter_cookie_t cookie 12487 ** @param xcb_generic_error_t **e 12488 ** @returns xcb_glx_get_convolution_filter_reply_t * 12489 ** 12490 *****************************************************************************/ 12491 12492 xcb_glx_get_convolution_filter_reply_t * 12493 xcb_glx_get_convolution_filter_reply (xcb_connection_t *c /**< */, 12494 xcb_glx_get_convolution_filter_cookie_t cookie /**< */, 12495 xcb_generic_error_t **e /**< */) 12496 { 12497 return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12498 } 12499 12500 int 12501 xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */) 12502 { 12503 char *xcb_tmp = (char *)_buffer; 12504 const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer; 12505 unsigned int xcb_buffer_len = 0; 12506 unsigned int xcb_block_len = 0; 12507 unsigned int xcb_pad = 0; 12508 unsigned int xcb_align_to; 12509 12510 12511 xcb_block_len += sizeof(xcb_glx_get_convolution_parameterfv_reply_t); 12512 xcb_tmp += xcb_block_len; 12513 /* data */ 12514 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 12515 xcb_tmp += xcb_block_len; 12516 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 12517 /* insert padding */ 12518 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12519 xcb_buffer_len += xcb_block_len + xcb_pad; 12520 if (0 != xcb_pad) { 12521 xcb_tmp += xcb_pad; 12522 xcb_pad = 0; 12523 } 12524 xcb_block_len = 0; 12525 12526 return xcb_buffer_len; 12527 } 12528 12529 12530 /***************************************************************************** 12531 ** 12532 ** xcb_glx_get_convolution_parameterfv_cookie_t xcb_glx_get_convolution_parameterfv 12533 ** 12534 ** @param xcb_connection_t *c 12535 ** @param xcb_glx_context_tag_t context_tag 12536 ** @param uint32_t target 12537 ** @param uint32_t pname 12538 ** @returns xcb_glx_get_convolution_parameterfv_cookie_t 12539 ** 12540 *****************************************************************************/ 12541 12542 xcb_glx_get_convolution_parameterfv_cookie_t 12543 xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, 12544 xcb_glx_context_tag_t context_tag /**< */, 12545 uint32_t target /**< */, 12546 uint32_t pname /**< */) 12547 { 12548 static const xcb_protocol_request_t xcb_req = { 12549 /* count */ 2, 12550 /* ext */ &xcb_glx_id, 12551 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 12552 /* isvoid */ 0 12553 }; 12554 12555 struct iovec xcb_parts[4]; 12556 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 12557 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 12558 12559 xcb_out.context_tag = context_tag; 12560 xcb_out.target = target; 12561 xcb_out.pname = pname; 12562 12563 xcb_parts[2].iov_base = (char *) &xcb_out; 12564 xcb_parts[2].iov_len = sizeof(xcb_out); 12565 xcb_parts[3].iov_base = 0; 12566 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12567 12568 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12569 return xcb_ret; 12570 } 12571 12572 12573 /***************************************************************************** 12574 ** 12575 ** xcb_glx_get_convolution_parameterfv_cookie_t xcb_glx_get_convolution_parameterfv_unchecked 12576 ** 12577 ** @param xcb_connection_t *c 12578 ** @param xcb_glx_context_tag_t context_tag 12579 ** @param uint32_t target 12580 ** @param uint32_t pname 12581 ** @returns xcb_glx_get_convolution_parameterfv_cookie_t 12582 ** 12583 *****************************************************************************/ 12584 12585 xcb_glx_get_convolution_parameterfv_cookie_t 12586 xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c /**< */, 12587 xcb_glx_context_tag_t context_tag /**< */, 12588 uint32_t target /**< */, 12589 uint32_t pname /**< */) 12590 { 12591 static const xcb_protocol_request_t xcb_req = { 12592 /* count */ 2, 12593 /* ext */ &xcb_glx_id, 12594 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 12595 /* isvoid */ 0 12596 }; 12597 12598 struct iovec xcb_parts[4]; 12599 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 12600 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 12601 12602 xcb_out.context_tag = context_tag; 12603 xcb_out.target = target; 12604 xcb_out.pname = pname; 12605 12606 xcb_parts[2].iov_base = (char *) &xcb_out; 12607 xcb_parts[2].iov_len = sizeof(xcb_out); 12608 xcb_parts[3].iov_base = 0; 12609 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12610 12611 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12612 return xcb_ret; 12613 } 12614 12615 12616 /***************************************************************************** 12617 ** 12618 ** xcb_glx_float32_t * xcb_glx_get_convolution_parameterfv_data 12619 ** 12620 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12621 ** @returns xcb_glx_float32_t * 12622 ** 12623 *****************************************************************************/ 12624 12625 xcb_glx_float32_t * 12626 xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12627 { 12628 return (xcb_glx_float32_t *) (R + 1); 12629 } 12630 12631 12632 /***************************************************************************** 12633 ** 12634 ** int xcb_glx_get_convolution_parameterfv_data_length 12635 ** 12636 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12637 ** @returns int 12638 ** 12639 *****************************************************************************/ 12640 12641 int 12642 xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12643 { 12644 return R->n; 12645 } 12646 12647 12648 /***************************************************************************** 12649 ** 12650 ** xcb_generic_iterator_t xcb_glx_get_convolution_parameterfv_data_end 12651 ** 12652 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12653 ** @returns xcb_generic_iterator_t 12654 ** 12655 *****************************************************************************/ 12656 12657 xcb_generic_iterator_t 12658 xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12659 { 12660 xcb_generic_iterator_t i; 12661 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 12662 i.rem = 0; 12663 i.index = (char *) i.data - (char *) R; 12664 return i; 12665 } 12666 12667 12668 /***************************************************************************** 12669 ** 12670 ** xcb_glx_get_convolution_parameterfv_reply_t * xcb_glx_get_convolution_parameterfv_reply 12671 ** 12672 ** @param xcb_connection_t *c 12673 ** @param xcb_glx_get_convolution_parameterfv_cookie_t cookie 12674 ** @param xcb_generic_error_t **e 12675 ** @returns xcb_glx_get_convolution_parameterfv_reply_t * 12676 ** 12677 *****************************************************************************/ 12678 12679 xcb_glx_get_convolution_parameterfv_reply_t * 12680 xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c /**< */, 12681 xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, 12682 xcb_generic_error_t **e /**< */) 12683 { 12684 return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12685 } 12686 12687 int 12688 xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */) 12689 { 12690 char *xcb_tmp = (char *)_buffer; 12691 const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer; 12692 unsigned int xcb_buffer_len = 0; 12693 unsigned int xcb_block_len = 0; 12694 unsigned int xcb_pad = 0; 12695 unsigned int xcb_align_to; 12696 12697 12698 xcb_block_len += sizeof(xcb_glx_get_convolution_parameteriv_reply_t); 12699 xcb_tmp += xcb_block_len; 12700 /* data */ 12701 xcb_block_len += _aux->n * sizeof(int32_t); 12702 xcb_tmp += xcb_block_len; 12703 xcb_align_to = ALIGNOF(int32_t); 12704 /* insert padding */ 12705 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12706 xcb_buffer_len += xcb_block_len + xcb_pad; 12707 if (0 != xcb_pad) { 12708 xcb_tmp += xcb_pad; 12709 xcb_pad = 0; 12710 } 12711 xcb_block_len = 0; 12712 12713 return xcb_buffer_len; 12714 } 12715 12716 12717 /***************************************************************************** 12718 ** 12719 ** xcb_glx_get_convolution_parameteriv_cookie_t xcb_glx_get_convolution_parameteriv 12720 ** 12721 ** @param xcb_connection_t *c 12722 ** @param xcb_glx_context_tag_t context_tag 12723 ** @param uint32_t target 12724 ** @param uint32_t pname 12725 ** @returns xcb_glx_get_convolution_parameteriv_cookie_t 12726 ** 12727 *****************************************************************************/ 12728 12729 xcb_glx_get_convolution_parameteriv_cookie_t 12730 xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, 12731 xcb_glx_context_tag_t context_tag /**< */, 12732 uint32_t target /**< */, 12733 uint32_t pname /**< */) 12734 { 12735 static const xcb_protocol_request_t xcb_req = { 12736 /* count */ 2, 12737 /* ext */ &xcb_glx_id, 12738 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 12739 /* isvoid */ 0 12740 }; 12741 12742 struct iovec xcb_parts[4]; 12743 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 12744 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 12745 12746 xcb_out.context_tag = context_tag; 12747 xcb_out.target = target; 12748 xcb_out.pname = pname; 12749 12750 xcb_parts[2].iov_base = (char *) &xcb_out; 12751 xcb_parts[2].iov_len = sizeof(xcb_out); 12752 xcb_parts[3].iov_base = 0; 12753 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12754 12755 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12756 return xcb_ret; 12757 } 12758 12759 12760 /***************************************************************************** 12761 ** 12762 ** xcb_glx_get_convolution_parameteriv_cookie_t xcb_glx_get_convolution_parameteriv_unchecked 12763 ** 12764 ** @param xcb_connection_t *c 12765 ** @param xcb_glx_context_tag_t context_tag 12766 ** @param uint32_t target 12767 ** @param uint32_t pname 12768 ** @returns xcb_glx_get_convolution_parameteriv_cookie_t 12769 ** 12770 *****************************************************************************/ 12771 12772 xcb_glx_get_convolution_parameteriv_cookie_t 12773 xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c /**< */, 12774 xcb_glx_context_tag_t context_tag /**< */, 12775 uint32_t target /**< */, 12776 uint32_t pname /**< */) 12777 { 12778 static const xcb_protocol_request_t xcb_req = { 12779 /* count */ 2, 12780 /* ext */ &xcb_glx_id, 12781 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 12782 /* isvoid */ 0 12783 }; 12784 12785 struct iovec xcb_parts[4]; 12786 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 12787 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 12788 12789 xcb_out.context_tag = context_tag; 12790 xcb_out.target = target; 12791 xcb_out.pname = pname; 12792 12793 xcb_parts[2].iov_base = (char *) &xcb_out; 12794 xcb_parts[2].iov_len = sizeof(xcb_out); 12795 xcb_parts[3].iov_base = 0; 12796 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12797 12798 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12799 return xcb_ret; 12800 } 12801 12802 12803 /***************************************************************************** 12804 ** 12805 ** int32_t * xcb_glx_get_convolution_parameteriv_data 12806 ** 12807 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12808 ** @returns int32_t * 12809 ** 12810 *****************************************************************************/ 12811 12812 int32_t * 12813 xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12814 { 12815 return (int32_t *) (R + 1); 12816 } 12817 12818 12819 /***************************************************************************** 12820 ** 12821 ** int xcb_glx_get_convolution_parameteriv_data_length 12822 ** 12823 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12824 ** @returns int 12825 ** 12826 *****************************************************************************/ 12827 12828 int 12829 xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12830 { 12831 return R->n; 12832 } 12833 12834 12835 /***************************************************************************** 12836 ** 12837 ** xcb_generic_iterator_t xcb_glx_get_convolution_parameteriv_data_end 12838 ** 12839 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12840 ** @returns xcb_generic_iterator_t 12841 ** 12842 *****************************************************************************/ 12843 12844 xcb_generic_iterator_t 12845 xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12846 { 12847 xcb_generic_iterator_t i; 12848 i.data = ((int32_t *) (R + 1)) + (R->n); 12849 i.rem = 0; 12850 i.index = (char *) i.data - (char *) R; 12851 return i; 12852 } 12853 12854 12855 /***************************************************************************** 12856 ** 12857 ** xcb_glx_get_convolution_parameteriv_reply_t * xcb_glx_get_convolution_parameteriv_reply 12858 ** 12859 ** @param xcb_connection_t *c 12860 ** @param xcb_glx_get_convolution_parameteriv_cookie_t cookie 12861 ** @param xcb_generic_error_t **e 12862 ** @returns xcb_glx_get_convolution_parameteriv_reply_t * 12863 ** 12864 *****************************************************************************/ 12865 12866 xcb_glx_get_convolution_parameteriv_reply_t * 12867 xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c /**< */, 12868 xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, 12869 xcb_generic_error_t **e /**< */) 12870 { 12871 return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12872 } 12873 12874 int 12875 xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */) 12876 { 12877 char *xcb_tmp = (char *)_buffer; 12878 const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer; 12879 unsigned int xcb_buffer_len = 0; 12880 unsigned int xcb_block_len = 0; 12881 unsigned int xcb_pad = 0; 12882 unsigned int xcb_align_to; 12883 12884 12885 xcb_block_len += sizeof(xcb_glx_get_separable_filter_reply_t); 12886 xcb_tmp += xcb_block_len; 12887 /* rows_and_cols */ 12888 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 12889 xcb_tmp += xcb_block_len; 12890 xcb_align_to = ALIGNOF(uint8_t); 12891 /* insert padding */ 12892 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12893 xcb_buffer_len += xcb_block_len + xcb_pad; 12894 if (0 != xcb_pad) { 12895 xcb_tmp += xcb_pad; 12896 xcb_pad = 0; 12897 } 12898 xcb_block_len = 0; 12899 12900 return xcb_buffer_len; 12901 } 12902 12903 12904 /***************************************************************************** 12905 ** 12906 ** xcb_glx_get_separable_filter_cookie_t xcb_glx_get_separable_filter 12907 ** 12908 ** @param xcb_connection_t *c 12909 ** @param xcb_glx_context_tag_t context_tag 12910 ** @param uint32_t target 12911 ** @param uint32_t format 12912 ** @param uint32_t type 12913 ** @param uint8_t swap_bytes 12914 ** @returns xcb_glx_get_separable_filter_cookie_t 12915 ** 12916 *****************************************************************************/ 12917 12918 xcb_glx_get_separable_filter_cookie_t 12919 xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, 12920 xcb_glx_context_tag_t context_tag /**< */, 12921 uint32_t target /**< */, 12922 uint32_t format /**< */, 12923 uint32_t type /**< */, 12924 uint8_t swap_bytes /**< */) 12925 { 12926 static const xcb_protocol_request_t xcb_req = { 12927 /* count */ 2, 12928 /* ext */ &xcb_glx_id, 12929 /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, 12930 /* isvoid */ 0 12931 }; 12932 12933 struct iovec xcb_parts[4]; 12934 xcb_glx_get_separable_filter_cookie_t xcb_ret; 12935 xcb_glx_get_separable_filter_request_t xcb_out; 12936 12937 xcb_out.context_tag = context_tag; 12938 xcb_out.target = target; 12939 xcb_out.format = format; 12940 xcb_out.type = type; 12941 xcb_out.swap_bytes = swap_bytes; 12942 12943 xcb_parts[2].iov_base = (char *) &xcb_out; 12944 xcb_parts[2].iov_len = sizeof(xcb_out); 12945 xcb_parts[3].iov_base = 0; 12946 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12947 12948 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12949 return xcb_ret; 12950 } 12951 12952 12953 /***************************************************************************** 12954 ** 12955 ** xcb_glx_get_separable_filter_cookie_t xcb_glx_get_separable_filter_unchecked 12956 ** 12957 ** @param xcb_connection_t *c 12958 ** @param xcb_glx_context_tag_t context_tag 12959 ** @param uint32_t target 12960 ** @param uint32_t format 12961 ** @param uint32_t type 12962 ** @param uint8_t swap_bytes 12963 ** @returns xcb_glx_get_separable_filter_cookie_t 12964 ** 12965 *****************************************************************************/ 12966 12967 xcb_glx_get_separable_filter_cookie_t 12968 xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c /**< */, 12969 xcb_glx_context_tag_t context_tag /**< */, 12970 uint32_t target /**< */, 12971 uint32_t format /**< */, 12972 uint32_t type /**< */, 12973 uint8_t swap_bytes /**< */) 12974 { 12975 static const xcb_protocol_request_t xcb_req = { 12976 /* count */ 2, 12977 /* ext */ &xcb_glx_id, 12978 /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, 12979 /* isvoid */ 0 12980 }; 12981 12982 struct iovec xcb_parts[4]; 12983 xcb_glx_get_separable_filter_cookie_t xcb_ret; 12984 xcb_glx_get_separable_filter_request_t xcb_out; 12985 12986 xcb_out.context_tag = context_tag; 12987 xcb_out.target = target; 12988 xcb_out.format = format; 12989 xcb_out.type = type; 12990 xcb_out.swap_bytes = swap_bytes; 12991 12992 xcb_parts[2].iov_base = (char *) &xcb_out; 12993 xcb_parts[2].iov_len = sizeof(xcb_out); 12994 xcb_parts[3].iov_base = 0; 12995 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12996 12997 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12998 return xcb_ret; 12999 } 13000 13001 13002 /***************************************************************************** 13003 ** 13004 ** uint8_t * xcb_glx_get_separable_filter_rows_and_cols 13005 ** 13006 ** @param const xcb_glx_get_separable_filter_reply_t *R 13007 ** @returns uint8_t * 13008 ** 13009 *****************************************************************************/ 13010 13011 uint8_t * 13012 xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13013 { 13014 return (uint8_t *) (R + 1); 13015 } 13016 13017 13018 /***************************************************************************** 13019 ** 13020 ** int xcb_glx_get_separable_filter_rows_and_cols_length 13021 ** 13022 ** @param const xcb_glx_get_separable_filter_reply_t *R 13023 ** @returns int 13024 ** 13025 *****************************************************************************/ 13026 13027 int 13028 xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13029 { 13030 return (R->length * 4); 13031 } 13032 13033 13034 /***************************************************************************** 13035 ** 13036 ** xcb_generic_iterator_t xcb_glx_get_separable_filter_rows_and_cols_end 13037 ** 13038 ** @param const xcb_glx_get_separable_filter_reply_t *R 13039 ** @returns xcb_generic_iterator_t 13040 ** 13041 *****************************************************************************/ 13042 13043 xcb_generic_iterator_t 13044 xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13045 { 13046 xcb_generic_iterator_t i; 13047 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13048 i.rem = 0; 13049 i.index = (char *) i.data - (char *) R; 13050 return i; 13051 } 13052 13053 13054 /***************************************************************************** 13055 ** 13056 ** xcb_glx_get_separable_filter_reply_t * xcb_glx_get_separable_filter_reply 13057 ** 13058 ** @param xcb_connection_t *c 13059 ** @param xcb_glx_get_separable_filter_cookie_t cookie 13060 ** @param xcb_generic_error_t **e 13061 ** @returns xcb_glx_get_separable_filter_reply_t * 13062 ** 13063 *****************************************************************************/ 13064 13065 xcb_glx_get_separable_filter_reply_t * 13066 xcb_glx_get_separable_filter_reply (xcb_connection_t *c /**< */, 13067 xcb_glx_get_separable_filter_cookie_t cookie /**< */, 13068 xcb_generic_error_t **e /**< */) 13069 { 13070 return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13071 } 13072 13073 int 13074 xcb_glx_get_histogram_sizeof (const void *_buffer /**< */) 13075 { 13076 char *xcb_tmp = (char *)_buffer; 13077 const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer; 13078 unsigned int xcb_buffer_len = 0; 13079 unsigned int xcb_block_len = 0; 13080 unsigned int xcb_pad = 0; 13081 unsigned int xcb_align_to; 13082 13083 13084 xcb_block_len += sizeof(xcb_glx_get_histogram_reply_t); 13085 xcb_tmp += xcb_block_len; 13086 /* data */ 13087 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 13088 xcb_tmp += xcb_block_len; 13089 xcb_align_to = ALIGNOF(uint8_t); 13090 /* insert padding */ 13091 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13092 xcb_buffer_len += xcb_block_len + xcb_pad; 13093 if (0 != xcb_pad) { 13094 xcb_tmp += xcb_pad; 13095 xcb_pad = 0; 13096 } 13097 xcb_block_len = 0; 13098 13099 return xcb_buffer_len; 13100 } 13101 13102 13103 /***************************************************************************** 13104 ** 13105 ** xcb_glx_get_histogram_cookie_t xcb_glx_get_histogram 13106 ** 13107 ** @param xcb_connection_t *c 13108 ** @param xcb_glx_context_tag_t context_tag 13109 ** @param uint32_t target 13110 ** @param uint32_t format 13111 ** @param uint32_t type 13112 ** @param uint8_t swap_bytes 13113 ** @param uint8_t reset 13114 ** @returns xcb_glx_get_histogram_cookie_t 13115 ** 13116 *****************************************************************************/ 13117 13118 xcb_glx_get_histogram_cookie_t 13119 xcb_glx_get_histogram (xcb_connection_t *c /**< */, 13120 xcb_glx_context_tag_t context_tag /**< */, 13121 uint32_t target /**< */, 13122 uint32_t format /**< */, 13123 uint32_t type /**< */, 13124 uint8_t swap_bytes /**< */, 13125 uint8_t reset /**< */) 13126 { 13127 static const xcb_protocol_request_t xcb_req = { 13128 /* count */ 2, 13129 /* ext */ &xcb_glx_id, 13130 /* opcode */ XCB_GLX_GET_HISTOGRAM, 13131 /* isvoid */ 0 13132 }; 13133 13134 struct iovec xcb_parts[4]; 13135 xcb_glx_get_histogram_cookie_t xcb_ret; 13136 xcb_glx_get_histogram_request_t xcb_out; 13137 13138 xcb_out.context_tag = context_tag; 13139 xcb_out.target = target; 13140 xcb_out.format = format; 13141 xcb_out.type = type; 13142 xcb_out.swap_bytes = swap_bytes; 13143 xcb_out.reset = reset; 13144 13145 xcb_parts[2].iov_base = (char *) &xcb_out; 13146 xcb_parts[2].iov_len = sizeof(xcb_out); 13147 xcb_parts[3].iov_base = 0; 13148 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13149 13150 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13151 return xcb_ret; 13152 } 13153 13154 13155 /***************************************************************************** 13156 ** 13157 ** xcb_glx_get_histogram_cookie_t xcb_glx_get_histogram_unchecked 13158 ** 13159 ** @param xcb_connection_t *c 13160 ** @param xcb_glx_context_tag_t context_tag 13161 ** @param uint32_t target 13162 ** @param uint32_t format 13163 ** @param uint32_t type 13164 ** @param uint8_t swap_bytes 13165 ** @param uint8_t reset 13166 ** @returns xcb_glx_get_histogram_cookie_t 13167 ** 13168 *****************************************************************************/ 13169 13170 xcb_glx_get_histogram_cookie_t 13171 xcb_glx_get_histogram_unchecked (xcb_connection_t *c /**< */, 13172 xcb_glx_context_tag_t context_tag /**< */, 13173 uint32_t target /**< */, 13174 uint32_t format /**< */, 13175 uint32_t type /**< */, 13176 uint8_t swap_bytes /**< */, 13177 uint8_t reset /**< */) 13178 { 13179 static const xcb_protocol_request_t xcb_req = { 13180 /* count */ 2, 13181 /* ext */ &xcb_glx_id, 13182 /* opcode */ XCB_GLX_GET_HISTOGRAM, 13183 /* isvoid */ 0 13184 }; 13185 13186 struct iovec xcb_parts[4]; 13187 xcb_glx_get_histogram_cookie_t xcb_ret; 13188 xcb_glx_get_histogram_request_t xcb_out; 13189 13190 xcb_out.context_tag = context_tag; 13191 xcb_out.target = target; 13192 xcb_out.format = format; 13193 xcb_out.type = type; 13194 xcb_out.swap_bytes = swap_bytes; 13195 xcb_out.reset = reset; 13196 13197 xcb_parts[2].iov_base = (char *) &xcb_out; 13198 xcb_parts[2].iov_len = sizeof(xcb_out); 13199 xcb_parts[3].iov_base = 0; 13200 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13201 13202 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13203 return xcb_ret; 13204 } 13205 13206 13207 /***************************************************************************** 13208 ** 13209 ** uint8_t * xcb_glx_get_histogram_data 13210 ** 13211 ** @param const xcb_glx_get_histogram_reply_t *R 13212 ** @returns uint8_t * 13213 ** 13214 *****************************************************************************/ 13215 13216 uint8_t * 13217 xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R /**< */) 13218 { 13219 return (uint8_t *) (R + 1); 13220 } 13221 13222 13223 /***************************************************************************** 13224 ** 13225 ** int xcb_glx_get_histogram_data_length 13226 ** 13227 ** @param const xcb_glx_get_histogram_reply_t *R 13228 ** @returns int 13229 ** 13230 *****************************************************************************/ 13231 13232 int 13233 xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R /**< */) 13234 { 13235 return (R->length * 4); 13236 } 13237 13238 13239 /***************************************************************************** 13240 ** 13241 ** xcb_generic_iterator_t xcb_glx_get_histogram_data_end 13242 ** 13243 ** @param const xcb_glx_get_histogram_reply_t *R 13244 ** @returns xcb_generic_iterator_t 13245 ** 13246 *****************************************************************************/ 13247 13248 xcb_generic_iterator_t 13249 xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */) 13250 { 13251 xcb_generic_iterator_t i; 13252 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13253 i.rem = 0; 13254 i.index = (char *) i.data - (char *) R; 13255 return i; 13256 } 13257 13258 13259 /***************************************************************************** 13260 ** 13261 ** xcb_glx_get_histogram_reply_t * xcb_glx_get_histogram_reply 13262 ** 13263 ** @param xcb_connection_t *c 13264 ** @param xcb_glx_get_histogram_cookie_t cookie 13265 ** @param xcb_generic_error_t **e 13266 ** @returns xcb_glx_get_histogram_reply_t * 13267 ** 13268 *****************************************************************************/ 13269 13270 xcb_glx_get_histogram_reply_t * 13271 xcb_glx_get_histogram_reply (xcb_connection_t *c /**< */, 13272 xcb_glx_get_histogram_cookie_t cookie /**< */, 13273 xcb_generic_error_t **e /**< */) 13274 { 13275 return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13276 } 13277 13278 int 13279 xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */) 13280 { 13281 char *xcb_tmp = (char *)_buffer; 13282 const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer; 13283 unsigned int xcb_buffer_len = 0; 13284 unsigned int xcb_block_len = 0; 13285 unsigned int xcb_pad = 0; 13286 unsigned int xcb_align_to; 13287 13288 13289 xcb_block_len += sizeof(xcb_glx_get_histogram_parameterfv_reply_t); 13290 xcb_tmp += xcb_block_len; 13291 /* data */ 13292 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 13293 xcb_tmp += xcb_block_len; 13294 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 13295 /* insert padding */ 13296 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13297 xcb_buffer_len += xcb_block_len + xcb_pad; 13298 if (0 != xcb_pad) { 13299 xcb_tmp += xcb_pad; 13300 xcb_pad = 0; 13301 } 13302 xcb_block_len = 0; 13303 13304 return xcb_buffer_len; 13305 } 13306 13307 13308 /***************************************************************************** 13309 ** 13310 ** xcb_glx_get_histogram_parameterfv_cookie_t xcb_glx_get_histogram_parameterfv 13311 ** 13312 ** @param xcb_connection_t *c 13313 ** @param xcb_glx_context_tag_t context_tag 13314 ** @param uint32_t target 13315 ** @param uint32_t pname 13316 ** @returns xcb_glx_get_histogram_parameterfv_cookie_t 13317 ** 13318 *****************************************************************************/ 13319 13320 xcb_glx_get_histogram_parameterfv_cookie_t 13321 xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, 13322 xcb_glx_context_tag_t context_tag /**< */, 13323 uint32_t target /**< */, 13324 uint32_t pname /**< */) 13325 { 13326 static const xcb_protocol_request_t xcb_req = { 13327 /* count */ 2, 13328 /* ext */ &xcb_glx_id, 13329 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 13330 /* isvoid */ 0 13331 }; 13332 13333 struct iovec xcb_parts[4]; 13334 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 13335 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 13336 13337 xcb_out.context_tag = context_tag; 13338 xcb_out.target = target; 13339 xcb_out.pname = pname; 13340 13341 xcb_parts[2].iov_base = (char *) &xcb_out; 13342 xcb_parts[2].iov_len = sizeof(xcb_out); 13343 xcb_parts[3].iov_base = 0; 13344 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13345 13346 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13347 return xcb_ret; 13348 } 13349 13350 13351 /***************************************************************************** 13352 ** 13353 ** xcb_glx_get_histogram_parameterfv_cookie_t xcb_glx_get_histogram_parameterfv_unchecked 13354 ** 13355 ** @param xcb_connection_t *c 13356 ** @param xcb_glx_context_tag_t context_tag 13357 ** @param uint32_t target 13358 ** @param uint32_t pname 13359 ** @returns xcb_glx_get_histogram_parameterfv_cookie_t 13360 ** 13361 *****************************************************************************/ 13362 13363 xcb_glx_get_histogram_parameterfv_cookie_t 13364 xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c /**< */, 13365 xcb_glx_context_tag_t context_tag /**< */, 13366 uint32_t target /**< */, 13367 uint32_t pname /**< */) 13368 { 13369 static const xcb_protocol_request_t xcb_req = { 13370 /* count */ 2, 13371 /* ext */ &xcb_glx_id, 13372 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 13373 /* isvoid */ 0 13374 }; 13375 13376 struct iovec xcb_parts[4]; 13377 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 13378 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 13379 13380 xcb_out.context_tag = context_tag; 13381 xcb_out.target = target; 13382 xcb_out.pname = pname; 13383 13384 xcb_parts[2].iov_base = (char *) &xcb_out; 13385 xcb_parts[2].iov_len = sizeof(xcb_out); 13386 xcb_parts[3].iov_base = 0; 13387 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13388 13389 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13390 return xcb_ret; 13391 } 13392 13393 13394 /***************************************************************************** 13395 ** 13396 ** xcb_glx_float32_t * xcb_glx_get_histogram_parameterfv_data 13397 ** 13398 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13399 ** @returns xcb_glx_float32_t * 13400 ** 13401 *****************************************************************************/ 13402 13403 xcb_glx_float32_t * 13404 xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13405 { 13406 return (xcb_glx_float32_t *) (R + 1); 13407 } 13408 13409 13410 /***************************************************************************** 13411 ** 13412 ** int xcb_glx_get_histogram_parameterfv_data_length 13413 ** 13414 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13415 ** @returns int 13416 ** 13417 *****************************************************************************/ 13418 13419 int 13420 xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13421 { 13422 return R->n; 13423 } 13424 13425 13426 /***************************************************************************** 13427 ** 13428 ** xcb_generic_iterator_t xcb_glx_get_histogram_parameterfv_data_end 13429 ** 13430 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13431 ** @returns xcb_generic_iterator_t 13432 ** 13433 *****************************************************************************/ 13434 13435 xcb_generic_iterator_t 13436 xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13437 { 13438 xcb_generic_iterator_t i; 13439 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 13440 i.rem = 0; 13441 i.index = (char *) i.data - (char *) R; 13442 return i; 13443 } 13444 13445 13446 /***************************************************************************** 13447 ** 13448 ** xcb_glx_get_histogram_parameterfv_reply_t * xcb_glx_get_histogram_parameterfv_reply 13449 ** 13450 ** @param xcb_connection_t *c 13451 ** @param xcb_glx_get_histogram_parameterfv_cookie_t cookie 13452 ** @param xcb_generic_error_t **e 13453 ** @returns xcb_glx_get_histogram_parameterfv_reply_t * 13454 ** 13455 *****************************************************************************/ 13456 13457 xcb_glx_get_histogram_parameterfv_reply_t * 13458 xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c /**< */, 13459 xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, 13460 xcb_generic_error_t **e /**< */) 13461 { 13462 return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13463 } 13464 13465 int 13466 xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */) 13467 { 13468 char *xcb_tmp = (char *)_buffer; 13469 const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer; 13470 unsigned int xcb_buffer_len = 0; 13471 unsigned int xcb_block_len = 0; 13472 unsigned int xcb_pad = 0; 13473 unsigned int xcb_align_to; 13474 13475 13476 xcb_block_len += sizeof(xcb_glx_get_histogram_parameteriv_reply_t); 13477 xcb_tmp += xcb_block_len; 13478 /* data */ 13479 xcb_block_len += _aux->n * sizeof(int32_t); 13480 xcb_tmp += xcb_block_len; 13481 xcb_align_to = ALIGNOF(int32_t); 13482 /* insert padding */ 13483 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13484 xcb_buffer_len += xcb_block_len + xcb_pad; 13485 if (0 != xcb_pad) { 13486 xcb_tmp += xcb_pad; 13487 xcb_pad = 0; 13488 } 13489 xcb_block_len = 0; 13490 13491 return xcb_buffer_len; 13492 } 13493 13494 13495 /***************************************************************************** 13496 ** 13497 ** xcb_glx_get_histogram_parameteriv_cookie_t xcb_glx_get_histogram_parameteriv 13498 ** 13499 ** @param xcb_connection_t *c 13500 ** @param xcb_glx_context_tag_t context_tag 13501 ** @param uint32_t target 13502 ** @param uint32_t pname 13503 ** @returns xcb_glx_get_histogram_parameteriv_cookie_t 13504 ** 13505 *****************************************************************************/ 13506 13507 xcb_glx_get_histogram_parameteriv_cookie_t 13508 xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, 13509 xcb_glx_context_tag_t context_tag /**< */, 13510 uint32_t target /**< */, 13511 uint32_t pname /**< */) 13512 { 13513 static const xcb_protocol_request_t xcb_req = { 13514 /* count */ 2, 13515 /* ext */ &xcb_glx_id, 13516 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 13517 /* isvoid */ 0 13518 }; 13519 13520 struct iovec xcb_parts[4]; 13521 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 13522 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 13523 13524 xcb_out.context_tag = context_tag; 13525 xcb_out.target = target; 13526 xcb_out.pname = pname; 13527 13528 xcb_parts[2].iov_base = (char *) &xcb_out; 13529 xcb_parts[2].iov_len = sizeof(xcb_out); 13530 xcb_parts[3].iov_base = 0; 13531 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13532 13533 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13534 return xcb_ret; 13535 } 13536 13537 13538 /***************************************************************************** 13539 ** 13540 ** xcb_glx_get_histogram_parameteriv_cookie_t xcb_glx_get_histogram_parameteriv_unchecked 13541 ** 13542 ** @param xcb_connection_t *c 13543 ** @param xcb_glx_context_tag_t context_tag 13544 ** @param uint32_t target 13545 ** @param uint32_t pname 13546 ** @returns xcb_glx_get_histogram_parameteriv_cookie_t 13547 ** 13548 *****************************************************************************/ 13549 13550 xcb_glx_get_histogram_parameteriv_cookie_t 13551 xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c /**< */, 13552 xcb_glx_context_tag_t context_tag /**< */, 13553 uint32_t target /**< */, 13554 uint32_t pname /**< */) 13555 { 13556 static const xcb_protocol_request_t xcb_req = { 13557 /* count */ 2, 13558 /* ext */ &xcb_glx_id, 13559 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 13560 /* isvoid */ 0 13561 }; 13562 13563 struct iovec xcb_parts[4]; 13564 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 13565 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 13566 13567 xcb_out.context_tag = context_tag; 13568 xcb_out.target = target; 13569 xcb_out.pname = pname; 13570 13571 xcb_parts[2].iov_base = (char *) &xcb_out; 13572 xcb_parts[2].iov_len = sizeof(xcb_out); 13573 xcb_parts[3].iov_base = 0; 13574 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13575 13576 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13577 return xcb_ret; 13578 } 13579 13580 13581 /***************************************************************************** 13582 ** 13583 ** int32_t * xcb_glx_get_histogram_parameteriv_data 13584 ** 13585 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13586 ** @returns int32_t * 13587 ** 13588 *****************************************************************************/ 13589 13590 int32_t * 13591 xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13592 { 13593 return (int32_t *) (R + 1); 13594 } 13595 13596 13597 /***************************************************************************** 13598 ** 13599 ** int xcb_glx_get_histogram_parameteriv_data_length 13600 ** 13601 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13602 ** @returns int 13603 ** 13604 *****************************************************************************/ 13605 13606 int 13607 xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13608 { 13609 return R->n; 13610 } 13611 13612 13613 /***************************************************************************** 13614 ** 13615 ** xcb_generic_iterator_t xcb_glx_get_histogram_parameteriv_data_end 13616 ** 13617 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13618 ** @returns xcb_generic_iterator_t 13619 ** 13620 *****************************************************************************/ 13621 13622 xcb_generic_iterator_t 13623 xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13624 { 13625 xcb_generic_iterator_t i; 13626 i.data = ((int32_t *) (R + 1)) + (R->n); 13627 i.rem = 0; 13628 i.index = (char *) i.data - (char *) R; 13629 return i; 13630 } 13631 13632 13633 /***************************************************************************** 13634 ** 13635 ** xcb_glx_get_histogram_parameteriv_reply_t * xcb_glx_get_histogram_parameteriv_reply 13636 ** 13637 ** @param xcb_connection_t *c 13638 ** @param xcb_glx_get_histogram_parameteriv_cookie_t cookie 13639 ** @param xcb_generic_error_t **e 13640 ** @returns xcb_glx_get_histogram_parameteriv_reply_t * 13641 ** 13642 *****************************************************************************/ 13643 13644 xcb_glx_get_histogram_parameteriv_reply_t * 13645 xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c /**< */, 13646 xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, 13647 xcb_generic_error_t **e /**< */) 13648 { 13649 return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13650 } 13651 13652 int 13653 xcb_glx_get_minmax_sizeof (const void *_buffer /**< */) 13654 { 13655 char *xcb_tmp = (char *)_buffer; 13656 const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer; 13657 unsigned int xcb_buffer_len = 0; 13658 unsigned int xcb_block_len = 0; 13659 unsigned int xcb_pad = 0; 13660 unsigned int xcb_align_to; 13661 13662 13663 xcb_block_len += sizeof(xcb_glx_get_minmax_reply_t); 13664 xcb_tmp += xcb_block_len; 13665 /* data */ 13666 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 13667 xcb_tmp += xcb_block_len; 13668 xcb_align_to = ALIGNOF(uint8_t); 13669 /* insert padding */ 13670 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13671 xcb_buffer_len += xcb_block_len + xcb_pad; 13672 if (0 != xcb_pad) { 13673 xcb_tmp += xcb_pad; 13674 xcb_pad = 0; 13675 } 13676 xcb_block_len = 0; 13677 13678 return xcb_buffer_len; 13679 } 13680 13681 13682 /***************************************************************************** 13683 ** 13684 ** xcb_glx_get_minmax_cookie_t xcb_glx_get_minmax 13685 ** 13686 ** @param xcb_connection_t *c 13687 ** @param xcb_glx_context_tag_t context_tag 13688 ** @param uint32_t target 13689 ** @param uint32_t format 13690 ** @param uint32_t type 13691 ** @param uint8_t swap_bytes 13692 ** @param uint8_t reset 13693 ** @returns xcb_glx_get_minmax_cookie_t 13694 ** 13695 *****************************************************************************/ 13696 13697 xcb_glx_get_minmax_cookie_t 13698 xcb_glx_get_minmax (xcb_connection_t *c /**< */, 13699 xcb_glx_context_tag_t context_tag /**< */, 13700 uint32_t target /**< */, 13701 uint32_t format /**< */, 13702 uint32_t type /**< */, 13703 uint8_t swap_bytes /**< */, 13704 uint8_t reset /**< */) 13705 { 13706 static const xcb_protocol_request_t xcb_req = { 13707 /* count */ 2, 13708 /* ext */ &xcb_glx_id, 13709 /* opcode */ XCB_GLX_GET_MINMAX, 13710 /* isvoid */ 0 13711 }; 13712 13713 struct iovec xcb_parts[4]; 13714 xcb_glx_get_minmax_cookie_t xcb_ret; 13715 xcb_glx_get_minmax_request_t xcb_out; 13716 13717 xcb_out.context_tag = context_tag; 13718 xcb_out.target = target; 13719 xcb_out.format = format; 13720 xcb_out.type = type; 13721 xcb_out.swap_bytes = swap_bytes; 13722 xcb_out.reset = reset; 13723 13724 xcb_parts[2].iov_base = (char *) &xcb_out; 13725 xcb_parts[2].iov_len = sizeof(xcb_out); 13726 xcb_parts[3].iov_base = 0; 13727 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13728 13729 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13730 return xcb_ret; 13731 } 13732 13733 13734 /***************************************************************************** 13735 ** 13736 ** xcb_glx_get_minmax_cookie_t xcb_glx_get_minmax_unchecked 13737 ** 13738 ** @param xcb_connection_t *c 13739 ** @param xcb_glx_context_tag_t context_tag 13740 ** @param uint32_t target 13741 ** @param uint32_t format 13742 ** @param uint32_t type 13743 ** @param uint8_t swap_bytes 13744 ** @param uint8_t reset 13745 ** @returns xcb_glx_get_minmax_cookie_t 13746 ** 13747 *****************************************************************************/ 13748 13749 xcb_glx_get_minmax_cookie_t 13750 xcb_glx_get_minmax_unchecked (xcb_connection_t *c /**< */, 13751 xcb_glx_context_tag_t context_tag /**< */, 13752 uint32_t target /**< */, 13753 uint32_t format /**< */, 13754 uint32_t type /**< */, 13755 uint8_t swap_bytes /**< */, 13756 uint8_t reset /**< */) 13757 { 13758 static const xcb_protocol_request_t xcb_req = { 13759 /* count */ 2, 13760 /* ext */ &xcb_glx_id, 13761 /* opcode */ XCB_GLX_GET_MINMAX, 13762 /* isvoid */ 0 13763 }; 13764 13765 struct iovec xcb_parts[4]; 13766 xcb_glx_get_minmax_cookie_t xcb_ret; 13767 xcb_glx_get_minmax_request_t xcb_out; 13768 13769 xcb_out.context_tag = context_tag; 13770 xcb_out.target = target; 13771 xcb_out.format = format; 13772 xcb_out.type = type; 13773 xcb_out.swap_bytes = swap_bytes; 13774 xcb_out.reset = reset; 13775 13776 xcb_parts[2].iov_base = (char *) &xcb_out; 13777 xcb_parts[2].iov_len = sizeof(xcb_out); 13778 xcb_parts[3].iov_base = 0; 13779 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13780 13781 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13782 return xcb_ret; 13783 } 13784 13785 13786 /***************************************************************************** 13787 ** 13788 ** uint8_t * xcb_glx_get_minmax_data 13789 ** 13790 ** @param const xcb_glx_get_minmax_reply_t *R 13791 ** @returns uint8_t * 13792 ** 13793 *****************************************************************************/ 13794 13795 uint8_t * 13796 xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R /**< */) 13797 { 13798 return (uint8_t *) (R + 1); 13799 } 13800 13801 13802 /***************************************************************************** 13803 ** 13804 ** int xcb_glx_get_minmax_data_length 13805 ** 13806 ** @param const xcb_glx_get_minmax_reply_t *R 13807 ** @returns int 13808 ** 13809 *****************************************************************************/ 13810 13811 int 13812 xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R /**< */) 13813 { 13814 return (R->length * 4); 13815 } 13816 13817 13818 /***************************************************************************** 13819 ** 13820 ** xcb_generic_iterator_t xcb_glx_get_minmax_data_end 13821 ** 13822 ** @param const xcb_glx_get_minmax_reply_t *R 13823 ** @returns xcb_generic_iterator_t 13824 ** 13825 *****************************************************************************/ 13826 13827 xcb_generic_iterator_t 13828 xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */) 13829 { 13830 xcb_generic_iterator_t i; 13831 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13832 i.rem = 0; 13833 i.index = (char *) i.data - (char *) R; 13834 return i; 13835 } 13836 13837 13838 /***************************************************************************** 13839 ** 13840 ** xcb_glx_get_minmax_reply_t * xcb_glx_get_minmax_reply 13841 ** 13842 ** @param xcb_connection_t *c 13843 ** @param xcb_glx_get_minmax_cookie_t cookie 13844 ** @param xcb_generic_error_t **e 13845 ** @returns xcb_glx_get_minmax_reply_t * 13846 ** 13847 *****************************************************************************/ 13848 13849 xcb_glx_get_minmax_reply_t * 13850 xcb_glx_get_minmax_reply (xcb_connection_t *c /**< */, 13851 xcb_glx_get_minmax_cookie_t cookie /**< */, 13852 xcb_generic_error_t **e /**< */) 13853 { 13854 return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13855 } 13856 13857 int 13858 xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */) 13859 { 13860 char *xcb_tmp = (char *)_buffer; 13861 const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer; 13862 unsigned int xcb_buffer_len = 0; 13863 unsigned int xcb_block_len = 0; 13864 unsigned int xcb_pad = 0; 13865 unsigned int xcb_align_to; 13866 13867 13868 xcb_block_len += sizeof(xcb_glx_get_minmax_parameterfv_reply_t); 13869 xcb_tmp += xcb_block_len; 13870 /* data */ 13871 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 13872 xcb_tmp += xcb_block_len; 13873 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 13874 /* insert padding */ 13875 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13876 xcb_buffer_len += xcb_block_len + xcb_pad; 13877 if (0 != xcb_pad) { 13878 xcb_tmp += xcb_pad; 13879 xcb_pad = 0; 13880 } 13881 xcb_block_len = 0; 13882 13883 return xcb_buffer_len; 13884 } 13885 13886 13887 /***************************************************************************** 13888 ** 13889 ** xcb_glx_get_minmax_parameterfv_cookie_t xcb_glx_get_minmax_parameterfv 13890 ** 13891 ** @param xcb_connection_t *c 13892 ** @param xcb_glx_context_tag_t context_tag 13893 ** @param uint32_t target 13894 ** @param uint32_t pname 13895 ** @returns xcb_glx_get_minmax_parameterfv_cookie_t 13896 ** 13897 *****************************************************************************/ 13898 13899 xcb_glx_get_minmax_parameterfv_cookie_t 13900 xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, 13901 xcb_glx_context_tag_t context_tag /**< */, 13902 uint32_t target /**< */, 13903 uint32_t pname /**< */) 13904 { 13905 static const xcb_protocol_request_t xcb_req = { 13906 /* count */ 2, 13907 /* ext */ &xcb_glx_id, 13908 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, 13909 /* isvoid */ 0 13910 }; 13911 13912 struct iovec xcb_parts[4]; 13913 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 13914 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 13915 13916 xcb_out.context_tag = context_tag; 13917 xcb_out.target = target; 13918 xcb_out.pname = pname; 13919 13920 xcb_parts[2].iov_base = (char *) &xcb_out; 13921 xcb_parts[2].iov_len = sizeof(xcb_out); 13922 xcb_parts[3].iov_base = 0; 13923 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13924 13925 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13926 return xcb_ret; 13927 } 13928 13929 13930 /***************************************************************************** 13931 ** 13932 ** xcb_glx_get_minmax_parameterfv_cookie_t xcb_glx_get_minmax_parameterfv_unchecked 13933 ** 13934 ** @param xcb_connection_t *c 13935 ** @param xcb_glx_context_tag_t context_tag 13936 ** @param uint32_t target 13937 ** @param uint32_t pname 13938 ** @returns xcb_glx_get_minmax_parameterfv_cookie_t 13939 ** 13940 *****************************************************************************/ 13941 13942 xcb_glx_get_minmax_parameterfv_cookie_t 13943 xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c /**< */, 13944 xcb_glx_context_tag_t context_tag /**< */, 13945 uint32_t target /**< */, 13946 uint32_t pname /**< */) 13947 { 13948 static const xcb_protocol_request_t xcb_req = { 13949 /* count */ 2, 13950 /* ext */ &xcb_glx_id, 13951 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, 13952 /* isvoid */ 0 13953 }; 13954 13955 struct iovec xcb_parts[4]; 13956 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 13957 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 13958 13959 xcb_out.context_tag = context_tag; 13960 xcb_out.target = target; 13961 xcb_out.pname = pname; 13962 13963 xcb_parts[2].iov_base = (char *) &xcb_out; 13964 xcb_parts[2].iov_len = sizeof(xcb_out); 13965 xcb_parts[3].iov_base = 0; 13966 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13967 13968 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13969 return xcb_ret; 13970 } 13971 13972 13973 /***************************************************************************** 13974 ** 13975 ** xcb_glx_float32_t * xcb_glx_get_minmax_parameterfv_data 13976 ** 13977 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 13978 ** @returns xcb_glx_float32_t * 13979 ** 13980 *****************************************************************************/ 13981 13982 xcb_glx_float32_t * 13983 xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 13984 { 13985 return (xcb_glx_float32_t *) (R + 1); 13986 } 13987 13988 13989 /***************************************************************************** 13990 ** 13991 ** int xcb_glx_get_minmax_parameterfv_data_length 13992 ** 13993 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 13994 ** @returns int 13995 ** 13996 *****************************************************************************/ 13997 13998 int 13999 xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 14000 { 14001 return R->n; 14002 } 14003 14004 14005 /***************************************************************************** 14006 ** 14007 ** xcb_generic_iterator_t xcb_glx_get_minmax_parameterfv_data_end 14008 ** 14009 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 14010 ** @returns xcb_generic_iterator_t 14011 ** 14012 *****************************************************************************/ 14013 14014 xcb_generic_iterator_t 14015 xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 14016 { 14017 xcb_generic_iterator_t i; 14018 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 14019 i.rem = 0; 14020 i.index = (char *) i.data - (char *) R; 14021 return i; 14022 } 14023 14024 14025 /***************************************************************************** 14026 ** 14027 ** xcb_glx_get_minmax_parameterfv_reply_t * xcb_glx_get_minmax_parameterfv_reply 14028 ** 14029 ** @param xcb_connection_t *c 14030 ** @param xcb_glx_get_minmax_parameterfv_cookie_t cookie 14031 ** @param xcb_generic_error_t **e 14032 ** @returns xcb_glx_get_minmax_parameterfv_reply_t * 14033 ** 14034 *****************************************************************************/ 14035 14036 xcb_glx_get_minmax_parameterfv_reply_t * 14037 xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c /**< */, 14038 xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, 14039 xcb_generic_error_t **e /**< */) 14040 { 14041 return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14042 } 14043 14044 int 14045 xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */) 14046 { 14047 char *xcb_tmp = (char *)_buffer; 14048 const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer; 14049 unsigned int xcb_buffer_len = 0; 14050 unsigned int xcb_block_len = 0; 14051 unsigned int xcb_pad = 0; 14052 unsigned int xcb_align_to; 14053 14054 14055 xcb_block_len += sizeof(xcb_glx_get_minmax_parameteriv_reply_t); 14056 xcb_tmp += xcb_block_len; 14057 /* data */ 14058 xcb_block_len += _aux->n * sizeof(int32_t); 14059 xcb_tmp += xcb_block_len; 14060 xcb_align_to = ALIGNOF(int32_t); 14061 /* insert padding */ 14062 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14063 xcb_buffer_len += xcb_block_len + xcb_pad; 14064 if (0 != xcb_pad) { 14065 xcb_tmp += xcb_pad; 14066 xcb_pad = 0; 14067 } 14068 xcb_block_len = 0; 14069 14070 return xcb_buffer_len; 14071 } 14072 14073 14074 /***************************************************************************** 14075 ** 14076 ** xcb_glx_get_minmax_parameteriv_cookie_t xcb_glx_get_minmax_parameteriv 14077 ** 14078 ** @param xcb_connection_t *c 14079 ** @param xcb_glx_context_tag_t context_tag 14080 ** @param uint32_t target 14081 ** @param uint32_t pname 14082 ** @returns xcb_glx_get_minmax_parameteriv_cookie_t 14083 ** 14084 *****************************************************************************/ 14085 14086 xcb_glx_get_minmax_parameteriv_cookie_t 14087 xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, 14088 xcb_glx_context_tag_t context_tag /**< */, 14089 uint32_t target /**< */, 14090 uint32_t pname /**< */) 14091 { 14092 static const xcb_protocol_request_t xcb_req = { 14093 /* count */ 2, 14094 /* ext */ &xcb_glx_id, 14095 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, 14096 /* isvoid */ 0 14097 }; 14098 14099 struct iovec xcb_parts[4]; 14100 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 14101 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 14102 14103 xcb_out.context_tag = context_tag; 14104 xcb_out.target = target; 14105 xcb_out.pname = pname; 14106 14107 xcb_parts[2].iov_base = (char *) &xcb_out; 14108 xcb_parts[2].iov_len = sizeof(xcb_out); 14109 xcb_parts[3].iov_base = 0; 14110 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14111 14112 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14113 return xcb_ret; 14114 } 14115 14116 14117 /***************************************************************************** 14118 ** 14119 ** xcb_glx_get_minmax_parameteriv_cookie_t xcb_glx_get_minmax_parameteriv_unchecked 14120 ** 14121 ** @param xcb_connection_t *c 14122 ** @param xcb_glx_context_tag_t context_tag 14123 ** @param uint32_t target 14124 ** @param uint32_t pname 14125 ** @returns xcb_glx_get_minmax_parameteriv_cookie_t 14126 ** 14127 *****************************************************************************/ 14128 14129 xcb_glx_get_minmax_parameteriv_cookie_t 14130 xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c /**< */, 14131 xcb_glx_context_tag_t context_tag /**< */, 14132 uint32_t target /**< */, 14133 uint32_t pname /**< */) 14134 { 14135 static const xcb_protocol_request_t xcb_req = { 14136 /* count */ 2, 14137 /* ext */ &xcb_glx_id, 14138 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, 14139 /* isvoid */ 0 14140 }; 14141 14142 struct iovec xcb_parts[4]; 14143 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 14144 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 14145 14146 xcb_out.context_tag = context_tag; 14147 xcb_out.target = target; 14148 xcb_out.pname = pname; 14149 14150 xcb_parts[2].iov_base = (char *) &xcb_out; 14151 xcb_parts[2].iov_len = sizeof(xcb_out); 14152 xcb_parts[3].iov_base = 0; 14153 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14154 14155 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14156 return xcb_ret; 14157 } 14158 14159 14160 /***************************************************************************** 14161 ** 14162 ** int32_t * xcb_glx_get_minmax_parameteriv_data 14163 ** 14164 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14165 ** @returns int32_t * 14166 ** 14167 *****************************************************************************/ 14168 14169 int32_t * 14170 xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14171 { 14172 return (int32_t *) (R + 1); 14173 } 14174 14175 14176 /***************************************************************************** 14177 ** 14178 ** int xcb_glx_get_minmax_parameteriv_data_length 14179 ** 14180 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14181 ** @returns int 14182 ** 14183 *****************************************************************************/ 14184 14185 int 14186 xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14187 { 14188 return R->n; 14189 } 14190 14191 14192 /***************************************************************************** 14193 ** 14194 ** xcb_generic_iterator_t xcb_glx_get_minmax_parameteriv_data_end 14195 ** 14196 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14197 ** @returns xcb_generic_iterator_t 14198 ** 14199 *****************************************************************************/ 14200 14201 xcb_generic_iterator_t 14202 xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14203 { 14204 xcb_generic_iterator_t i; 14205 i.data = ((int32_t *) (R + 1)) + (R->n); 14206 i.rem = 0; 14207 i.index = (char *) i.data - (char *) R; 14208 return i; 14209 } 14210 14211 14212 /***************************************************************************** 14213 ** 14214 ** xcb_glx_get_minmax_parameteriv_reply_t * xcb_glx_get_minmax_parameteriv_reply 14215 ** 14216 ** @param xcb_connection_t *c 14217 ** @param xcb_glx_get_minmax_parameteriv_cookie_t cookie 14218 ** @param xcb_generic_error_t **e 14219 ** @returns xcb_glx_get_minmax_parameteriv_reply_t * 14220 ** 14221 *****************************************************************************/ 14222 14223 xcb_glx_get_minmax_parameteriv_reply_t * 14224 xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c /**< */, 14225 xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, 14226 xcb_generic_error_t **e /**< */) 14227 { 14228 return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14229 } 14230 14231 int 14232 xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */) 14233 { 14234 char *xcb_tmp = (char *)_buffer; 14235 const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer; 14236 unsigned int xcb_buffer_len = 0; 14237 unsigned int xcb_block_len = 0; 14238 unsigned int xcb_pad = 0; 14239 unsigned int xcb_align_to; 14240 14241 14242 xcb_block_len += sizeof(xcb_glx_get_compressed_tex_image_arb_reply_t); 14243 xcb_tmp += xcb_block_len; 14244 /* data */ 14245 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 14246 xcb_tmp += xcb_block_len; 14247 xcb_align_to = ALIGNOF(uint8_t); 14248 /* insert padding */ 14249 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14250 xcb_buffer_len += xcb_block_len + xcb_pad; 14251 if (0 != xcb_pad) { 14252 xcb_tmp += xcb_pad; 14253 xcb_pad = 0; 14254 } 14255 xcb_block_len = 0; 14256 14257 return xcb_buffer_len; 14258 } 14259 14260 14261 /***************************************************************************** 14262 ** 14263 ** xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_glx_get_compressed_tex_image_arb 14264 ** 14265 ** @param xcb_connection_t *c 14266 ** @param xcb_glx_context_tag_t context_tag 14267 ** @param uint32_t target 14268 ** @param int32_t level 14269 ** @returns xcb_glx_get_compressed_tex_image_arb_cookie_t 14270 ** 14271 *****************************************************************************/ 14272 14273 xcb_glx_get_compressed_tex_image_arb_cookie_t 14274 xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, 14275 xcb_glx_context_tag_t context_tag /**< */, 14276 uint32_t target /**< */, 14277 int32_t level /**< */) 14278 { 14279 static const xcb_protocol_request_t xcb_req = { 14280 /* count */ 2, 14281 /* ext */ &xcb_glx_id, 14282 /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 14283 /* isvoid */ 0 14284 }; 14285 14286 struct iovec xcb_parts[4]; 14287 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 14288 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 14289 14290 xcb_out.context_tag = context_tag; 14291 xcb_out.target = target; 14292 xcb_out.level = level; 14293 14294 xcb_parts[2].iov_base = (char *) &xcb_out; 14295 xcb_parts[2].iov_len = sizeof(xcb_out); 14296 xcb_parts[3].iov_base = 0; 14297 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14298 14299 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14300 return xcb_ret; 14301 } 14302 14303 14304 /***************************************************************************** 14305 ** 14306 ** xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_glx_get_compressed_tex_image_arb_unchecked 14307 ** 14308 ** @param xcb_connection_t *c 14309 ** @param xcb_glx_context_tag_t context_tag 14310 ** @param uint32_t target 14311 ** @param int32_t level 14312 ** @returns xcb_glx_get_compressed_tex_image_arb_cookie_t 14313 ** 14314 *****************************************************************************/ 14315 14316 xcb_glx_get_compressed_tex_image_arb_cookie_t 14317 xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c /**< */, 14318 xcb_glx_context_tag_t context_tag /**< */, 14319 uint32_t target /**< */, 14320 int32_t level /**< */) 14321 { 14322 static const xcb_protocol_request_t xcb_req = { 14323 /* count */ 2, 14324 /* ext */ &xcb_glx_id, 14325 /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 14326 /* isvoid */ 0 14327 }; 14328 14329 struct iovec xcb_parts[4]; 14330 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 14331 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 14332 14333 xcb_out.context_tag = context_tag; 14334 xcb_out.target = target; 14335 xcb_out.level = level; 14336 14337 xcb_parts[2].iov_base = (char *) &xcb_out; 14338 xcb_parts[2].iov_len = sizeof(xcb_out); 14339 xcb_parts[3].iov_base = 0; 14340 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14341 14342 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14343 return xcb_ret; 14344 } 14345 14346 14347 /***************************************************************************** 14348 ** 14349 ** uint8_t * xcb_glx_get_compressed_tex_image_arb_data 14350 ** 14351 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14352 ** @returns uint8_t * 14353 ** 14354 *****************************************************************************/ 14355 14356 uint8_t * 14357 xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14358 { 14359 return (uint8_t *) (R + 1); 14360 } 14361 14362 14363 /***************************************************************************** 14364 ** 14365 ** int xcb_glx_get_compressed_tex_image_arb_data_length 14366 ** 14367 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14368 ** @returns int 14369 ** 14370 *****************************************************************************/ 14371 14372 int 14373 xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14374 { 14375 return (R->length * 4); 14376 } 14377 14378 14379 /***************************************************************************** 14380 ** 14381 ** xcb_generic_iterator_t xcb_glx_get_compressed_tex_image_arb_data_end 14382 ** 14383 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14384 ** @returns xcb_generic_iterator_t 14385 ** 14386 *****************************************************************************/ 14387 14388 xcb_generic_iterator_t 14389 xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14390 { 14391 xcb_generic_iterator_t i; 14392 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 14393 i.rem = 0; 14394 i.index = (char *) i.data - (char *) R; 14395 return i; 14396 } 14397 14398 14399 /***************************************************************************** 14400 ** 14401 ** xcb_glx_get_compressed_tex_image_arb_reply_t * xcb_glx_get_compressed_tex_image_arb_reply 14402 ** 14403 ** @param xcb_connection_t *c 14404 ** @param xcb_glx_get_compressed_tex_image_arb_cookie_t cookie 14405 ** @param xcb_generic_error_t **e 14406 ** @returns xcb_glx_get_compressed_tex_image_arb_reply_t * 14407 ** 14408 *****************************************************************************/ 14409 14410 xcb_glx_get_compressed_tex_image_arb_reply_t * 14411 xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c /**< */, 14412 xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, 14413 xcb_generic_error_t **e /**< */) 14414 { 14415 return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14416 } 14417 14418 int 14419 xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */) 14420 { 14421 char *xcb_tmp = (char *)_buffer; 14422 const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer; 14423 unsigned int xcb_buffer_len = 0; 14424 unsigned int xcb_block_len = 0; 14425 unsigned int xcb_pad = 0; 14426 unsigned int xcb_align_to; 14427 14428 14429 xcb_block_len += sizeof(xcb_glx_delete_queries_arb_request_t); 14430 xcb_tmp += xcb_block_len; 14431 /* ids */ 14432 xcb_block_len += _aux->n * sizeof(uint32_t); 14433 xcb_tmp += xcb_block_len; 14434 xcb_align_to = ALIGNOF(uint32_t); 14435 /* insert padding */ 14436 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14437 xcb_buffer_len += xcb_block_len + xcb_pad; 14438 if (0 != xcb_pad) { 14439 xcb_tmp += xcb_pad; 14440 xcb_pad = 0; 14441 } 14442 xcb_block_len = 0; 14443 14444 return xcb_buffer_len; 14445 } 14446 14447 14448 /***************************************************************************** 14449 ** 14450 ** xcb_void_cookie_t xcb_glx_delete_queries_arb_checked 14451 ** 14452 ** @param xcb_connection_t *c 14453 ** @param xcb_glx_context_tag_t context_tag 14454 ** @param int32_t n 14455 ** @param const uint32_t *ids 14456 ** @returns xcb_void_cookie_t 14457 ** 14458 *****************************************************************************/ 14459 14460 xcb_void_cookie_t 14461 xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, 14462 xcb_glx_context_tag_t context_tag /**< */, 14463 int32_t n /**< */, 14464 const uint32_t *ids /**< */) 14465 { 14466 static const xcb_protocol_request_t xcb_req = { 14467 /* count */ 4, 14468 /* ext */ &xcb_glx_id, 14469 /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, 14470 /* isvoid */ 1 14471 }; 14472 14473 struct iovec xcb_parts[6]; 14474 xcb_void_cookie_t xcb_ret; 14475 xcb_glx_delete_queries_arb_request_t xcb_out; 14476 14477 xcb_out.context_tag = context_tag; 14478 xcb_out.n = n; 14479 14480 xcb_parts[2].iov_base = (char *) &xcb_out; 14481 xcb_parts[2].iov_len = sizeof(xcb_out); 14482 xcb_parts[3].iov_base = 0; 14483 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14484 /* uint32_t ids */ 14485 xcb_parts[4].iov_base = (char *) ids; 14486 xcb_parts[4].iov_len = n * sizeof(uint32_t); 14487 xcb_parts[5].iov_base = 0; 14488 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14489 14490 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14491 return xcb_ret; 14492 } 14493 14494 14495 /***************************************************************************** 14496 ** 14497 ** xcb_void_cookie_t xcb_glx_delete_queries_arb 14498 ** 14499 ** @param xcb_connection_t *c 14500 ** @param xcb_glx_context_tag_t context_tag 14501 ** @param int32_t n 14502 ** @param const uint32_t *ids 14503 ** @returns xcb_void_cookie_t 14504 ** 14505 *****************************************************************************/ 14506 14507 xcb_void_cookie_t 14508 xcb_glx_delete_queries_arb (xcb_connection_t *c /**< */, 14509 xcb_glx_context_tag_t context_tag /**< */, 14510 int32_t n /**< */, 14511 const uint32_t *ids /**< */) 14512 { 14513 static const xcb_protocol_request_t xcb_req = { 14514 /* count */ 4, 14515 /* ext */ &xcb_glx_id, 14516 /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, 14517 /* isvoid */ 1 14518 }; 14519 14520 struct iovec xcb_parts[6]; 14521 xcb_void_cookie_t xcb_ret; 14522 xcb_glx_delete_queries_arb_request_t xcb_out; 14523 14524 xcb_out.context_tag = context_tag; 14525 xcb_out.n = n; 14526 14527 xcb_parts[2].iov_base = (char *) &xcb_out; 14528 xcb_parts[2].iov_len = sizeof(xcb_out); 14529 xcb_parts[3].iov_base = 0; 14530 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14531 /* uint32_t ids */ 14532 xcb_parts[4].iov_base = (char *) ids; 14533 xcb_parts[4].iov_len = n * sizeof(uint32_t); 14534 xcb_parts[5].iov_base = 0; 14535 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14536 14537 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14538 return xcb_ret; 14539 } 14540 14541 int 14542 xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */) 14543 { 14544 char *xcb_tmp = (char *)_buffer; 14545 const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer; 14546 unsigned int xcb_buffer_len = 0; 14547 unsigned int xcb_block_len = 0; 14548 unsigned int xcb_pad = 0; 14549 unsigned int xcb_align_to; 14550 14551 14552 xcb_block_len += sizeof(xcb_glx_gen_queries_arb_reply_t); 14553 xcb_tmp += xcb_block_len; 14554 /* data */ 14555 xcb_block_len += _aux->length * sizeof(uint32_t); 14556 xcb_tmp += xcb_block_len; 14557 xcb_align_to = ALIGNOF(uint32_t); 14558 /* insert padding */ 14559 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14560 xcb_buffer_len += xcb_block_len + xcb_pad; 14561 if (0 != xcb_pad) { 14562 xcb_tmp += xcb_pad; 14563 xcb_pad = 0; 14564 } 14565 xcb_block_len = 0; 14566 14567 return xcb_buffer_len; 14568 } 14569 14570 14571 /***************************************************************************** 14572 ** 14573 ** xcb_glx_gen_queries_arb_cookie_t xcb_glx_gen_queries_arb 14574 ** 14575 ** @param xcb_connection_t *c 14576 ** @param xcb_glx_context_tag_t context_tag 14577 ** @param int32_t n 14578 ** @returns xcb_glx_gen_queries_arb_cookie_t 14579 ** 14580 *****************************************************************************/ 14581 14582 xcb_glx_gen_queries_arb_cookie_t 14583 xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, 14584 xcb_glx_context_tag_t context_tag /**< */, 14585 int32_t n /**< */) 14586 { 14587 static const xcb_protocol_request_t xcb_req = { 14588 /* count */ 2, 14589 /* ext */ &xcb_glx_id, 14590 /* opcode */ XCB_GLX_GEN_QUERIES_ARB, 14591 /* isvoid */ 0 14592 }; 14593 14594 struct iovec xcb_parts[4]; 14595 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 14596 xcb_glx_gen_queries_arb_request_t xcb_out; 14597 14598 xcb_out.context_tag = context_tag; 14599 xcb_out.n = n; 14600 14601 xcb_parts[2].iov_base = (char *) &xcb_out; 14602 xcb_parts[2].iov_len = sizeof(xcb_out); 14603 xcb_parts[3].iov_base = 0; 14604 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14605 14606 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14607 return xcb_ret; 14608 } 14609 14610 14611 /***************************************************************************** 14612 ** 14613 ** xcb_glx_gen_queries_arb_cookie_t xcb_glx_gen_queries_arb_unchecked 14614 ** 14615 ** @param xcb_connection_t *c 14616 ** @param xcb_glx_context_tag_t context_tag 14617 ** @param int32_t n 14618 ** @returns xcb_glx_gen_queries_arb_cookie_t 14619 ** 14620 *****************************************************************************/ 14621 14622 xcb_glx_gen_queries_arb_cookie_t 14623 xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c /**< */, 14624 xcb_glx_context_tag_t context_tag /**< */, 14625 int32_t n /**< */) 14626 { 14627 static const xcb_protocol_request_t xcb_req = { 14628 /* count */ 2, 14629 /* ext */ &xcb_glx_id, 14630 /* opcode */ XCB_GLX_GEN_QUERIES_ARB, 14631 /* isvoid */ 0 14632 }; 14633 14634 struct iovec xcb_parts[4]; 14635 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 14636 xcb_glx_gen_queries_arb_request_t xcb_out; 14637 14638 xcb_out.context_tag = context_tag; 14639 xcb_out.n = n; 14640 14641 xcb_parts[2].iov_base = (char *) &xcb_out; 14642 xcb_parts[2].iov_len = sizeof(xcb_out); 14643 xcb_parts[3].iov_base = 0; 14644 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14645 14646 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14647 return xcb_ret; 14648 } 14649 14650 14651 /***************************************************************************** 14652 ** 14653 ** uint32_t * xcb_glx_gen_queries_arb_data 14654 ** 14655 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14656 ** @returns uint32_t * 14657 ** 14658 *****************************************************************************/ 14659 14660 uint32_t * 14661 xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14662 { 14663 return (uint32_t *) (R + 1); 14664 } 14665 14666 14667 /***************************************************************************** 14668 ** 14669 ** int xcb_glx_gen_queries_arb_data_length 14670 ** 14671 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14672 ** @returns int 14673 ** 14674 *****************************************************************************/ 14675 14676 int 14677 xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14678 { 14679 return R->length; 14680 } 14681 14682 14683 /***************************************************************************** 14684 ** 14685 ** xcb_generic_iterator_t xcb_glx_gen_queries_arb_data_end 14686 ** 14687 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14688 ** @returns xcb_generic_iterator_t 14689 ** 14690 *****************************************************************************/ 14691 14692 xcb_generic_iterator_t 14693 xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14694 { 14695 xcb_generic_iterator_t i; 14696 i.data = ((uint32_t *) (R + 1)) + (R->length); 14697 i.rem = 0; 14698 i.index = (char *) i.data - (char *) R; 14699 return i; 14700 } 14701 14702 14703 /***************************************************************************** 14704 ** 14705 ** xcb_glx_gen_queries_arb_reply_t * xcb_glx_gen_queries_arb_reply 14706 ** 14707 ** @param xcb_connection_t *c 14708 ** @param xcb_glx_gen_queries_arb_cookie_t cookie 14709 ** @param xcb_generic_error_t **e 14710 ** @returns xcb_glx_gen_queries_arb_reply_t * 14711 ** 14712 *****************************************************************************/ 14713 14714 xcb_glx_gen_queries_arb_reply_t * 14715 xcb_glx_gen_queries_arb_reply (xcb_connection_t *c /**< */, 14716 xcb_glx_gen_queries_arb_cookie_t cookie /**< */, 14717 xcb_generic_error_t **e /**< */) 14718 { 14719 return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14720 } 14721 14722 14723 /***************************************************************************** 14724 ** 14725 ** xcb_glx_is_query_arb_cookie_t xcb_glx_is_query_arb 14726 ** 14727 ** @param xcb_connection_t *c 14728 ** @param xcb_glx_context_tag_t context_tag 14729 ** @param uint32_t id 14730 ** @returns xcb_glx_is_query_arb_cookie_t 14731 ** 14732 *****************************************************************************/ 14733 14734 xcb_glx_is_query_arb_cookie_t 14735 xcb_glx_is_query_arb (xcb_connection_t *c /**< */, 14736 xcb_glx_context_tag_t context_tag /**< */, 14737 uint32_t id /**< */) 14738 { 14739 static const xcb_protocol_request_t xcb_req = { 14740 /* count */ 2, 14741 /* ext */ &xcb_glx_id, 14742 /* opcode */ XCB_GLX_IS_QUERY_ARB, 14743 /* isvoid */ 0 14744 }; 14745 14746 struct iovec xcb_parts[4]; 14747 xcb_glx_is_query_arb_cookie_t xcb_ret; 14748 xcb_glx_is_query_arb_request_t xcb_out; 14749 14750 xcb_out.context_tag = context_tag; 14751 xcb_out.id = id; 14752 14753 xcb_parts[2].iov_base = (char *) &xcb_out; 14754 xcb_parts[2].iov_len = sizeof(xcb_out); 14755 xcb_parts[3].iov_base = 0; 14756 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14757 14758 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14759 return xcb_ret; 14760 } 14761 14762 14763 /***************************************************************************** 14764 ** 14765 ** xcb_glx_is_query_arb_cookie_t xcb_glx_is_query_arb_unchecked 14766 ** 14767 ** @param xcb_connection_t *c 14768 ** @param xcb_glx_context_tag_t context_tag 14769 ** @param uint32_t id 14770 ** @returns xcb_glx_is_query_arb_cookie_t 14771 ** 14772 *****************************************************************************/ 14773 14774 xcb_glx_is_query_arb_cookie_t 14775 xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, 14776 xcb_glx_context_tag_t context_tag /**< */, 14777 uint32_t id /**< */) 14778 { 14779 static const xcb_protocol_request_t xcb_req = { 14780 /* count */ 2, 14781 /* ext */ &xcb_glx_id, 14782 /* opcode */ XCB_GLX_IS_QUERY_ARB, 14783 /* isvoid */ 0 14784 }; 14785 14786 struct iovec xcb_parts[4]; 14787 xcb_glx_is_query_arb_cookie_t xcb_ret; 14788 xcb_glx_is_query_arb_request_t xcb_out; 14789 14790 xcb_out.context_tag = context_tag; 14791 xcb_out.id = id; 14792 14793 xcb_parts[2].iov_base = (char *) &xcb_out; 14794 xcb_parts[2].iov_len = sizeof(xcb_out); 14795 xcb_parts[3].iov_base = 0; 14796 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14797 14798 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14799 return xcb_ret; 14800 } 14801 14802 14803 /***************************************************************************** 14804 ** 14805 ** xcb_glx_is_query_arb_reply_t * xcb_glx_is_query_arb_reply 14806 ** 14807 ** @param xcb_connection_t *c 14808 ** @param xcb_glx_is_query_arb_cookie_t cookie 14809 ** @param xcb_generic_error_t **e 14810 ** @returns xcb_glx_is_query_arb_reply_t * 14811 ** 14812 *****************************************************************************/ 14813 14814 xcb_glx_is_query_arb_reply_t * 14815 xcb_glx_is_query_arb_reply (xcb_connection_t *c /**< */, 14816 xcb_glx_is_query_arb_cookie_t cookie /**< */, 14817 xcb_generic_error_t **e /**< */) 14818 { 14819 return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14820 } 14821 14822 int 14823 xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */) 14824 { 14825 char *xcb_tmp = (char *)_buffer; 14826 const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer; 14827 unsigned int xcb_buffer_len = 0; 14828 unsigned int xcb_block_len = 0; 14829 unsigned int xcb_pad = 0; 14830 unsigned int xcb_align_to; 14831 14832 14833 xcb_block_len += sizeof(xcb_glx_get_queryiv_arb_reply_t); 14834 xcb_tmp += xcb_block_len; 14835 /* data */ 14836 xcb_block_len += _aux->n * sizeof(int32_t); 14837 xcb_tmp += xcb_block_len; 14838 xcb_align_to = ALIGNOF(int32_t); 14839 /* insert padding */ 14840 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14841 xcb_buffer_len += xcb_block_len + xcb_pad; 14842 if (0 != xcb_pad) { 14843 xcb_tmp += xcb_pad; 14844 xcb_pad = 0; 14845 } 14846 xcb_block_len = 0; 14847 14848 return xcb_buffer_len; 14849 } 14850 14851 14852 /***************************************************************************** 14853 ** 14854 ** xcb_glx_get_queryiv_arb_cookie_t xcb_glx_get_queryiv_arb 14855 ** 14856 ** @param xcb_connection_t *c 14857 ** @param xcb_glx_context_tag_t context_tag 14858 ** @param uint32_t target 14859 ** @param uint32_t pname 14860 ** @returns xcb_glx_get_queryiv_arb_cookie_t 14861 ** 14862 *****************************************************************************/ 14863 14864 xcb_glx_get_queryiv_arb_cookie_t 14865 xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, 14866 xcb_glx_context_tag_t context_tag /**< */, 14867 uint32_t target /**< */, 14868 uint32_t pname /**< */) 14869 { 14870 static const xcb_protocol_request_t xcb_req = { 14871 /* count */ 2, 14872 /* ext */ &xcb_glx_id, 14873 /* opcode */ XCB_GLX_GET_QUERYIV_ARB, 14874 /* isvoid */ 0 14875 }; 14876 14877 struct iovec xcb_parts[4]; 14878 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 14879 xcb_glx_get_queryiv_arb_request_t xcb_out; 14880 14881 xcb_out.context_tag = context_tag; 14882 xcb_out.target = target; 14883 xcb_out.pname = pname; 14884 14885 xcb_parts[2].iov_base = (char *) &xcb_out; 14886 xcb_parts[2].iov_len = sizeof(xcb_out); 14887 xcb_parts[3].iov_base = 0; 14888 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14889 14890 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14891 return xcb_ret; 14892 } 14893 14894 14895 /***************************************************************************** 14896 ** 14897 ** xcb_glx_get_queryiv_arb_cookie_t xcb_glx_get_queryiv_arb_unchecked 14898 ** 14899 ** @param xcb_connection_t *c 14900 ** @param xcb_glx_context_tag_t context_tag 14901 ** @param uint32_t target 14902 ** @param uint32_t pname 14903 ** @returns xcb_glx_get_queryiv_arb_cookie_t 14904 ** 14905 *****************************************************************************/ 14906 14907 xcb_glx_get_queryiv_arb_cookie_t 14908 xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c /**< */, 14909 xcb_glx_context_tag_t context_tag /**< */, 14910 uint32_t target /**< */, 14911 uint32_t pname /**< */) 14912 { 14913 static const xcb_protocol_request_t xcb_req = { 14914 /* count */ 2, 14915 /* ext */ &xcb_glx_id, 14916 /* opcode */ XCB_GLX_GET_QUERYIV_ARB, 14917 /* isvoid */ 0 14918 }; 14919 14920 struct iovec xcb_parts[4]; 14921 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 14922 xcb_glx_get_queryiv_arb_request_t xcb_out; 14923 14924 xcb_out.context_tag = context_tag; 14925 xcb_out.target = target; 14926 xcb_out.pname = pname; 14927 14928 xcb_parts[2].iov_base = (char *) &xcb_out; 14929 xcb_parts[2].iov_len = sizeof(xcb_out); 14930 xcb_parts[3].iov_base = 0; 14931 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14932 14933 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14934 return xcb_ret; 14935 } 14936 14937 14938 /***************************************************************************** 14939 ** 14940 ** int32_t * xcb_glx_get_queryiv_arb_data 14941 ** 14942 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 14943 ** @returns int32_t * 14944 ** 14945 *****************************************************************************/ 14946 14947 int32_t * 14948 xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 14949 { 14950 return (int32_t *) (R + 1); 14951 } 14952 14953 14954 /***************************************************************************** 14955 ** 14956 ** int xcb_glx_get_queryiv_arb_data_length 14957 ** 14958 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 14959 ** @returns int 14960 ** 14961 *****************************************************************************/ 14962 14963 int 14964 xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 14965 { 14966 return R->n; 14967 } 14968 14969 14970 /***************************************************************************** 14971 ** 14972 ** xcb_generic_iterator_t xcb_glx_get_queryiv_arb_data_end 14973 ** 14974 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 14975 ** @returns xcb_generic_iterator_t 14976 ** 14977 *****************************************************************************/ 14978 14979 xcb_generic_iterator_t 14980 xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 14981 { 14982 xcb_generic_iterator_t i; 14983 i.data = ((int32_t *) (R + 1)) + (R->n); 14984 i.rem = 0; 14985 i.index = (char *) i.data - (char *) R; 14986 return i; 14987 } 14988 14989 14990 /***************************************************************************** 14991 ** 14992 ** xcb_glx_get_queryiv_arb_reply_t * xcb_glx_get_queryiv_arb_reply 14993 ** 14994 ** @param xcb_connection_t *c 14995 ** @param xcb_glx_get_queryiv_arb_cookie_t cookie 14996 ** @param xcb_generic_error_t **e 14997 ** @returns xcb_glx_get_queryiv_arb_reply_t * 14998 ** 14999 *****************************************************************************/ 15000 15001 xcb_glx_get_queryiv_arb_reply_t * 15002 xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c /**< */, 15003 xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, 15004 xcb_generic_error_t **e /**< */) 15005 { 15006 return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15007 } 15008 15009 int 15010 xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */) 15011 { 15012 char *xcb_tmp = (char *)_buffer; 15013 const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer; 15014 unsigned int xcb_buffer_len = 0; 15015 unsigned int xcb_block_len = 0; 15016 unsigned int xcb_pad = 0; 15017 unsigned int xcb_align_to; 15018 15019 15020 xcb_block_len += sizeof(xcb_glx_get_query_objectiv_arb_reply_t); 15021 xcb_tmp += xcb_block_len; 15022 /* data */ 15023 xcb_block_len += _aux->n * sizeof(int32_t); 15024 xcb_tmp += xcb_block_len; 15025 xcb_align_to = ALIGNOF(int32_t); 15026 /* insert padding */ 15027 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15028 xcb_buffer_len += xcb_block_len + xcb_pad; 15029 if (0 != xcb_pad) { 15030 xcb_tmp += xcb_pad; 15031 xcb_pad = 0; 15032 } 15033 xcb_block_len = 0; 15034 15035 return xcb_buffer_len; 15036 } 15037 15038 15039 /***************************************************************************** 15040 ** 15041 ** xcb_glx_get_query_objectiv_arb_cookie_t xcb_glx_get_query_objectiv_arb 15042 ** 15043 ** @param xcb_connection_t *c 15044 ** @param xcb_glx_context_tag_t context_tag 15045 ** @param uint32_t id 15046 ** @param uint32_t pname 15047 ** @returns xcb_glx_get_query_objectiv_arb_cookie_t 15048 ** 15049 *****************************************************************************/ 15050 15051 xcb_glx_get_query_objectiv_arb_cookie_t 15052 xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, 15053 xcb_glx_context_tag_t context_tag /**< */, 15054 uint32_t id /**< */, 15055 uint32_t pname /**< */) 15056 { 15057 static const xcb_protocol_request_t xcb_req = { 15058 /* count */ 2, 15059 /* ext */ &xcb_glx_id, 15060 /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, 15061 /* isvoid */ 0 15062 }; 15063 15064 struct iovec xcb_parts[4]; 15065 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 15066 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 15067 15068 xcb_out.context_tag = context_tag; 15069 xcb_out.id = id; 15070 xcb_out.pname = pname; 15071 15072 xcb_parts[2].iov_base = (char *) &xcb_out; 15073 xcb_parts[2].iov_len = sizeof(xcb_out); 15074 xcb_parts[3].iov_base = 0; 15075 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15076 15077 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15078 return xcb_ret; 15079 } 15080 15081 15082 /***************************************************************************** 15083 ** 15084 ** xcb_glx_get_query_objectiv_arb_cookie_t xcb_glx_get_query_objectiv_arb_unchecked 15085 ** 15086 ** @param xcb_connection_t *c 15087 ** @param xcb_glx_context_tag_t context_tag 15088 ** @param uint32_t id 15089 ** @param uint32_t pname 15090 ** @returns xcb_glx_get_query_objectiv_arb_cookie_t 15091 ** 15092 *****************************************************************************/ 15093 15094 xcb_glx_get_query_objectiv_arb_cookie_t 15095 xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c /**< */, 15096 xcb_glx_context_tag_t context_tag /**< */, 15097 uint32_t id /**< */, 15098 uint32_t pname /**< */) 15099 { 15100 static const xcb_protocol_request_t xcb_req = { 15101 /* count */ 2, 15102 /* ext */ &xcb_glx_id, 15103 /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, 15104 /* isvoid */ 0 15105 }; 15106 15107 struct iovec xcb_parts[4]; 15108 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 15109 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 15110 15111 xcb_out.context_tag = context_tag; 15112 xcb_out.id = id; 15113 xcb_out.pname = pname; 15114 15115 xcb_parts[2].iov_base = (char *) &xcb_out; 15116 xcb_parts[2].iov_len = sizeof(xcb_out); 15117 xcb_parts[3].iov_base = 0; 15118 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15119 15120 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15121 return xcb_ret; 15122 } 15123 15124 15125 /***************************************************************************** 15126 ** 15127 ** int32_t * xcb_glx_get_query_objectiv_arb_data 15128 ** 15129 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15130 ** @returns int32_t * 15131 ** 15132 *****************************************************************************/ 15133 15134 int32_t * 15135 xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15136 { 15137 return (int32_t *) (R + 1); 15138 } 15139 15140 15141 /***************************************************************************** 15142 ** 15143 ** int xcb_glx_get_query_objectiv_arb_data_length 15144 ** 15145 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15146 ** @returns int 15147 ** 15148 *****************************************************************************/ 15149 15150 int 15151 xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15152 { 15153 return R->n; 15154 } 15155 15156 15157 /***************************************************************************** 15158 ** 15159 ** xcb_generic_iterator_t xcb_glx_get_query_objectiv_arb_data_end 15160 ** 15161 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15162 ** @returns xcb_generic_iterator_t 15163 ** 15164 *****************************************************************************/ 15165 15166 xcb_generic_iterator_t 15167 xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15168 { 15169 xcb_generic_iterator_t i; 15170 i.data = ((int32_t *) (R + 1)) + (R->n); 15171 i.rem = 0; 15172 i.index = (char *) i.data - (char *) R; 15173 return i; 15174 } 15175 15176 15177 /***************************************************************************** 15178 ** 15179 ** xcb_glx_get_query_objectiv_arb_reply_t * xcb_glx_get_query_objectiv_arb_reply 15180 ** 15181 ** @param xcb_connection_t *c 15182 ** @param xcb_glx_get_query_objectiv_arb_cookie_t cookie 15183 ** @param xcb_generic_error_t **e 15184 ** @returns xcb_glx_get_query_objectiv_arb_reply_t * 15185 ** 15186 *****************************************************************************/ 15187 15188 xcb_glx_get_query_objectiv_arb_reply_t * 15189 xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c /**< */, 15190 xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, 15191 xcb_generic_error_t **e /**< */) 15192 { 15193 return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15194 } 15195 15196 int 15197 xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */) 15198 { 15199 char *xcb_tmp = (char *)_buffer; 15200 const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer; 15201 unsigned int xcb_buffer_len = 0; 15202 unsigned int xcb_block_len = 0; 15203 unsigned int xcb_pad = 0; 15204 unsigned int xcb_align_to; 15205 15206 15207 xcb_block_len += sizeof(xcb_glx_get_query_objectuiv_arb_reply_t); 15208 xcb_tmp += xcb_block_len; 15209 /* data */ 15210 xcb_block_len += _aux->n * sizeof(uint32_t); 15211 xcb_tmp += xcb_block_len; 15212 xcb_align_to = ALIGNOF(uint32_t); 15213 /* insert padding */ 15214 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15215 xcb_buffer_len += xcb_block_len + xcb_pad; 15216 if (0 != xcb_pad) { 15217 xcb_tmp += xcb_pad; 15218 xcb_pad = 0; 15219 } 15220 xcb_block_len = 0; 15221 15222 return xcb_buffer_len; 15223 } 15224 15225 15226 /***************************************************************************** 15227 ** 15228 ** xcb_glx_get_query_objectuiv_arb_cookie_t xcb_glx_get_query_objectuiv_arb 15229 ** 15230 ** @param xcb_connection_t *c 15231 ** @param xcb_glx_context_tag_t context_tag 15232 ** @param uint32_t id 15233 ** @param uint32_t pname 15234 ** @returns xcb_glx_get_query_objectuiv_arb_cookie_t 15235 ** 15236 *****************************************************************************/ 15237 15238 xcb_glx_get_query_objectuiv_arb_cookie_t 15239 xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, 15240 xcb_glx_context_tag_t context_tag /**< */, 15241 uint32_t id /**< */, 15242 uint32_t pname /**< */) 15243 { 15244 static const xcb_protocol_request_t xcb_req = { 15245 /* count */ 2, 15246 /* ext */ &xcb_glx_id, 15247 /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 15248 /* isvoid */ 0 15249 }; 15250 15251 struct iovec xcb_parts[4]; 15252 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 15253 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 15254 15255 xcb_out.context_tag = context_tag; 15256 xcb_out.id = id; 15257 xcb_out.pname = pname; 15258 15259 xcb_parts[2].iov_base = (char *) &xcb_out; 15260 xcb_parts[2].iov_len = sizeof(xcb_out); 15261 xcb_parts[3].iov_base = 0; 15262 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15263 15264 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15265 return xcb_ret; 15266 } 15267 15268 15269 /***************************************************************************** 15270 ** 15271 ** xcb_glx_get_query_objectuiv_arb_cookie_t xcb_glx_get_query_objectuiv_arb_unchecked 15272 ** 15273 ** @param xcb_connection_t *c 15274 ** @param xcb_glx_context_tag_t context_tag 15275 ** @param uint32_t id 15276 ** @param uint32_t pname 15277 ** @returns xcb_glx_get_query_objectuiv_arb_cookie_t 15278 ** 15279 *****************************************************************************/ 15280 15281 xcb_glx_get_query_objectuiv_arb_cookie_t 15282 xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c /**< */, 15283 xcb_glx_context_tag_t context_tag /**< */, 15284 uint32_t id /**< */, 15285 uint32_t pname /**< */) 15286 { 15287 static const xcb_protocol_request_t xcb_req = { 15288 /* count */ 2, 15289 /* ext */ &xcb_glx_id, 15290 /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 15291 /* isvoid */ 0 15292 }; 15293 15294 struct iovec xcb_parts[4]; 15295 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 15296 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 15297 15298 xcb_out.context_tag = context_tag; 15299 xcb_out.id = id; 15300 xcb_out.pname = pname; 15301 15302 xcb_parts[2].iov_base = (char *) &xcb_out; 15303 xcb_parts[2].iov_len = sizeof(xcb_out); 15304 xcb_parts[3].iov_base = 0; 15305 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15306 15307 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15308 return xcb_ret; 15309 } 15310 15311 15312 /***************************************************************************** 15313 ** 15314 ** uint32_t * xcb_glx_get_query_objectuiv_arb_data 15315 ** 15316 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15317 ** @returns uint32_t * 15318 ** 15319 *****************************************************************************/ 15320 15321 uint32_t * 15322 xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15323 { 15324 return (uint32_t *) (R + 1); 15325 } 15326 15327 15328 /***************************************************************************** 15329 ** 15330 ** int xcb_glx_get_query_objectuiv_arb_data_length 15331 ** 15332 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15333 ** @returns int 15334 ** 15335 *****************************************************************************/ 15336 15337 int 15338 xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15339 { 15340 return R->n; 15341 } 15342 15343 15344 /***************************************************************************** 15345 ** 15346 ** xcb_generic_iterator_t xcb_glx_get_query_objectuiv_arb_data_end 15347 ** 15348 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15349 ** @returns xcb_generic_iterator_t 15350 ** 15351 *****************************************************************************/ 15352 15353 xcb_generic_iterator_t 15354 xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15355 { 15356 xcb_generic_iterator_t i; 15357 i.data = ((uint32_t *) (R + 1)) + (R->n); 15358 i.rem = 0; 15359 i.index = (char *) i.data - (char *) R; 15360 return i; 15361 } 15362 15363 15364 /***************************************************************************** 15365 ** 15366 ** xcb_glx_get_query_objectuiv_arb_reply_t * xcb_glx_get_query_objectuiv_arb_reply 15367 ** 15368 ** @param xcb_connection_t *c 15369 ** @param xcb_glx_get_query_objectuiv_arb_cookie_t cookie 15370 ** @param xcb_generic_error_t **e 15371 ** @returns xcb_glx_get_query_objectuiv_arb_reply_t * 15372 ** 15373 *****************************************************************************/ 15374 15375 xcb_glx_get_query_objectuiv_arb_reply_t * 15376 xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c /**< */, 15377 xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, 15378 xcb_generic_error_t **e /**< */) 15379 { 15380 return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15381 } 15382 15383