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 = 0; 410 411 412 xcb_block_len += sizeof(xcb_glx_render_request_t); 413 xcb_tmp += xcb_block_len; 414 xcb_buffer_len += xcb_block_len; 415 xcb_block_len = 0; 416 /* data */ 417 xcb_block_len += data_len * sizeof(uint8_t); 418 xcb_tmp += xcb_block_len; 419 xcb_align_to = ALIGNOF(uint8_t); 420 /* insert padding */ 421 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 422 xcb_buffer_len += xcb_block_len + xcb_pad; 423 if (0 != xcb_pad) { 424 xcb_tmp += xcb_pad; 425 xcb_pad = 0; 426 } 427 xcb_block_len = 0; 428 429 return xcb_buffer_len; 430 } 431 432 433 /***************************************************************************** 434 ** 435 ** xcb_void_cookie_t xcb_glx_render_checked 436 ** 437 ** @param xcb_connection_t *c 438 ** @param xcb_glx_context_tag_t context_tag 439 ** @param uint32_t data_len 440 ** @param const uint8_t *data 441 ** @returns xcb_void_cookie_t 442 ** 443 *****************************************************************************/ 444 445 xcb_void_cookie_t 446 xcb_glx_render_checked (xcb_connection_t *c /**< */, 447 xcb_glx_context_tag_t context_tag /**< */, 448 uint32_t data_len /**< */, 449 const uint8_t *data /**< */) 450 { 451 static const xcb_protocol_request_t xcb_req = { 452 /* count */ 4, 453 /* ext */ &xcb_glx_id, 454 /* opcode */ XCB_GLX_RENDER, 455 /* isvoid */ 1 456 }; 457 458 struct iovec xcb_parts[6]; 459 xcb_void_cookie_t xcb_ret; 460 xcb_glx_render_request_t xcb_out; 461 462 xcb_out.context_tag = context_tag; 463 464 xcb_parts[2].iov_base = (char *) &xcb_out; 465 xcb_parts[2].iov_len = sizeof(xcb_out); 466 xcb_parts[3].iov_base = 0; 467 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 468 /* uint8_t data */ 469 xcb_parts[4].iov_base = (char *) data; 470 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 471 xcb_parts[5].iov_base = 0; 472 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 473 474 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 475 return xcb_ret; 476 } 477 478 479 /***************************************************************************** 480 ** 481 ** xcb_void_cookie_t xcb_glx_render 482 ** 483 ** @param xcb_connection_t *c 484 ** @param xcb_glx_context_tag_t context_tag 485 ** @param uint32_t data_len 486 ** @param const uint8_t *data 487 ** @returns xcb_void_cookie_t 488 ** 489 *****************************************************************************/ 490 491 xcb_void_cookie_t 492 xcb_glx_render (xcb_connection_t *c /**< */, 493 xcb_glx_context_tag_t context_tag /**< */, 494 uint32_t data_len /**< */, 495 const uint8_t *data /**< */) 496 { 497 static const xcb_protocol_request_t xcb_req = { 498 /* count */ 4, 499 /* ext */ &xcb_glx_id, 500 /* opcode */ XCB_GLX_RENDER, 501 /* isvoid */ 1 502 }; 503 504 struct iovec xcb_parts[6]; 505 xcb_void_cookie_t xcb_ret; 506 xcb_glx_render_request_t xcb_out; 507 508 xcb_out.context_tag = context_tag; 509 510 xcb_parts[2].iov_base = (char *) &xcb_out; 511 xcb_parts[2].iov_len = sizeof(xcb_out); 512 xcb_parts[3].iov_base = 0; 513 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 514 /* uint8_t data */ 515 xcb_parts[4].iov_base = (char *) data; 516 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 517 xcb_parts[5].iov_base = 0; 518 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 519 520 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 521 return xcb_ret; 522 } 523 524 int 525 xcb_glx_render_large_sizeof (const void *_buffer /**< */) 526 { 527 char *xcb_tmp = (char *)_buffer; 528 const xcb_glx_render_large_request_t *_aux = (xcb_glx_render_large_request_t *)_buffer; 529 unsigned int xcb_buffer_len = 0; 530 unsigned int xcb_block_len = 0; 531 unsigned int xcb_pad = 0; 532 unsigned int xcb_align_to = 0; 533 534 535 xcb_block_len += sizeof(xcb_glx_render_large_request_t); 536 xcb_tmp += xcb_block_len; 537 xcb_buffer_len += xcb_block_len; 538 xcb_block_len = 0; 539 /* data */ 540 xcb_block_len += _aux->data_len * sizeof(uint8_t); 541 xcb_tmp += xcb_block_len; 542 xcb_align_to = ALIGNOF(uint8_t); 543 /* insert padding */ 544 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 545 xcb_buffer_len += xcb_block_len + xcb_pad; 546 if (0 != xcb_pad) { 547 xcb_tmp += xcb_pad; 548 xcb_pad = 0; 549 } 550 xcb_block_len = 0; 551 552 return xcb_buffer_len; 553 } 554 555 556 /***************************************************************************** 557 ** 558 ** xcb_void_cookie_t xcb_glx_render_large_checked 559 ** 560 ** @param xcb_connection_t *c 561 ** @param xcb_glx_context_tag_t context_tag 562 ** @param uint16_t request_num 563 ** @param uint16_t request_total 564 ** @param uint32_t data_len 565 ** @param const uint8_t *data 566 ** @returns xcb_void_cookie_t 567 ** 568 *****************************************************************************/ 569 570 xcb_void_cookie_t 571 xcb_glx_render_large_checked (xcb_connection_t *c /**< */, 572 xcb_glx_context_tag_t context_tag /**< */, 573 uint16_t request_num /**< */, 574 uint16_t request_total /**< */, 575 uint32_t data_len /**< */, 576 const uint8_t *data /**< */) 577 { 578 static const xcb_protocol_request_t xcb_req = { 579 /* count */ 4, 580 /* ext */ &xcb_glx_id, 581 /* opcode */ XCB_GLX_RENDER_LARGE, 582 /* isvoid */ 1 583 }; 584 585 struct iovec xcb_parts[6]; 586 xcb_void_cookie_t xcb_ret; 587 xcb_glx_render_large_request_t xcb_out; 588 589 xcb_out.context_tag = context_tag; 590 xcb_out.request_num = request_num; 591 xcb_out.request_total = request_total; 592 xcb_out.data_len = data_len; 593 594 xcb_parts[2].iov_base = (char *) &xcb_out; 595 xcb_parts[2].iov_len = sizeof(xcb_out); 596 xcb_parts[3].iov_base = 0; 597 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 598 /* uint8_t data */ 599 xcb_parts[4].iov_base = (char *) data; 600 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 601 xcb_parts[5].iov_base = 0; 602 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 603 604 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 605 return xcb_ret; 606 } 607 608 609 /***************************************************************************** 610 ** 611 ** xcb_void_cookie_t xcb_glx_render_large 612 ** 613 ** @param xcb_connection_t *c 614 ** @param xcb_glx_context_tag_t context_tag 615 ** @param uint16_t request_num 616 ** @param uint16_t request_total 617 ** @param uint32_t data_len 618 ** @param const uint8_t *data 619 ** @returns xcb_void_cookie_t 620 ** 621 *****************************************************************************/ 622 623 xcb_void_cookie_t 624 xcb_glx_render_large (xcb_connection_t *c /**< */, 625 xcb_glx_context_tag_t context_tag /**< */, 626 uint16_t request_num /**< */, 627 uint16_t request_total /**< */, 628 uint32_t data_len /**< */, 629 const uint8_t *data /**< */) 630 { 631 static const xcb_protocol_request_t xcb_req = { 632 /* count */ 4, 633 /* ext */ &xcb_glx_id, 634 /* opcode */ XCB_GLX_RENDER_LARGE, 635 /* isvoid */ 1 636 }; 637 638 struct iovec xcb_parts[6]; 639 xcb_void_cookie_t xcb_ret; 640 xcb_glx_render_large_request_t xcb_out; 641 642 xcb_out.context_tag = context_tag; 643 xcb_out.request_num = request_num; 644 xcb_out.request_total = request_total; 645 xcb_out.data_len = data_len; 646 647 xcb_parts[2].iov_base = (char *) &xcb_out; 648 xcb_parts[2].iov_len = sizeof(xcb_out); 649 xcb_parts[3].iov_base = 0; 650 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 651 /* uint8_t data */ 652 xcb_parts[4].iov_base = (char *) data; 653 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 654 xcb_parts[5].iov_base = 0; 655 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 656 657 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 658 return xcb_ret; 659 } 660 661 662 /***************************************************************************** 663 ** 664 ** xcb_void_cookie_t xcb_glx_create_context_checked 665 ** 666 ** @param xcb_connection_t *c 667 ** @param xcb_glx_context_t context 668 ** @param xcb_visualid_t visual 669 ** @param uint32_t screen 670 ** @param xcb_glx_context_t share_list 671 ** @param uint8_t is_direct 672 ** @returns xcb_void_cookie_t 673 ** 674 *****************************************************************************/ 675 676 xcb_void_cookie_t 677 xcb_glx_create_context_checked (xcb_connection_t *c /**< */, 678 xcb_glx_context_t context /**< */, 679 xcb_visualid_t visual /**< */, 680 uint32_t screen /**< */, 681 xcb_glx_context_t share_list /**< */, 682 uint8_t is_direct /**< */) 683 { 684 static const xcb_protocol_request_t xcb_req = { 685 /* count */ 2, 686 /* ext */ &xcb_glx_id, 687 /* opcode */ XCB_GLX_CREATE_CONTEXT, 688 /* isvoid */ 1 689 }; 690 691 struct iovec xcb_parts[4]; 692 xcb_void_cookie_t xcb_ret; 693 xcb_glx_create_context_request_t xcb_out; 694 695 xcb_out.context = context; 696 xcb_out.visual = visual; 697 xcb_out.screen = screen; 698 xcb_out.share_list = share_list; 699 xcb_out.is_direct = is_direct; 700 memset(xcb_out.pad0, 0, 3); 701 702 xcb_parts[2].iov_base = (char *) &xcb_out; 703 xcb_parts[2].iov_len = sizeof(xcb_out); 704 xcb_parts[3].iov_base = 0; 705 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 706 707 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 708 return xcb_ret; 709 } 710 711 712 /***************************************************************************** 713 ** 714 ** xcb_void_cookie_t xcb_glx_create_context 715 ** 716 ** @param xcb_connection_t *c 717 ** @param xcb_glx_context_t context 718 ** @param xcb_visualid_t visual 719 ** @param uint32_t screen 720 ** @param xcb_glx_context_t share_list 721 ** @param uint8_t is_direct 722 ** @returns xcb_void_cookie_t 723 ** 724 *****************************************************************************/ 725 726 xcb_void_cookie_t 727 xcb_glx_create_context (xcb_connection_t *c /**< */, 728 xcb_glx_context_t context /**< */, 729 xcb_visualid_t visual /**< */, 730 uint32_t screen /**< */, 731 xcb_glx_context_t share_list /**< */, 732 uint8_t is_direct /**< */) 733 { 734 static const xcb_protocol_request_t xcb_req = { 735 /* count */ 2, 736 /* ext */ &xcb_glx_id, 737 /* opcode */ XCB_GLX_CREATE_CONTEXT, 738 /* isvoid */ 1 739 }; 740 741 struct iovec xcb_parts[4]; 742 xcb_void_cookie_t xcb_ret; 743 xcb_glx_create_context_request_t xcb_out; 744 745 xcb_out.context = context; 746 xcb_out.visual = visual; 747 xcb_out.screen = screen; 748 xcb_out.share_list = share_list; 749 xcb_out.is_direct = is_direct; 750 memset(xcb_out.pad0, 0, 3); 751 752 xcb_parts[2].iov_base = (char *) &xcb_out; 753 xcb_parts[2].iov_len = sizeof(xcb_out); 754 xcb_parts[3].iov_base = 0; 755 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 756 757 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 758 return xcb_ret; 759 } 760 761 762 /***************************************************************************** 763 ** 764 ** xcb_void_cookie_t xcb_glx_destroy_context_checked 765 ** 766 ** @param xcb_connection_t *c 767 ** @param xcb_glx_context_t context 768 ** @returns xcb_void_cookie_t 769 ** 770 *****************************************************************************/ 771 772 xcb_void_cookie_t 773 xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, 774 xcb_glx_context_t context /**< */) 775 { 776 static const xcb_protocol_request_t xcb_req = { 777 /* count */ 2, 778 /* ext */ &xcb_glx_id, 779 /* opcode */ XCB_GLX_DESTROY_CONTEXT, 780 /* isvoid */ 1 781 }; 782 783 struct iovec xcb_parts[4]; 784 xcb_void_cookie_t xcb_ret; 785 xcb_glx_destroy_context_request_t xcb_out; 786 787 xcb_out.context = context; 788 789 xcb_parts[2].iov_base = (char *) &xcb_out; 790 xcb_parts[2].iov_len = sizeof(xcb_out); 791 xcb_parts[3].iov_base = 0; 792 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 793 794 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 795 return xcb_ret; 796 } 797 798 799 /***************************************************************************** 800 ** 801 ** xcb_void_cookie_t xcb_glx_destroy_context 802 ** 803 ** @param xcb_connection_t *c 804 ** @param xcb_glx_context_t context 805 ** @returns xcb_void_cookie_t 806 ** 807 *****************************************************************************/ 808 809 xcb_void_cookie_t 810 xcb_glx_destroy_context (xcb_connection_t *c /**< */, 811 xcb_glx_context_t context /**< */) 812 { 813 static const xcb_protocol_request_t xcb_req = { 814 /* count */ 2, 815 /* ext */ &xcb_glx_id, 816 /* opcode */ XCB_GLX_DESTROY_CONTEXT, 817 /* isvoid */ 1 818 }; 819 820 struct iovec xcb_parts[4]; 821 xcb_void_cookie_t xcb_ret; 822 xcb_glx_destroy_context_request_t xcb_out; 823 824 xcb_out.context = context; 825 826 xcb_parts[2].iov_base = (char *) &xcb_out; 827 xcb_parts[2].iov_len = sizeof(xcb_out); 828 xcb_parts[3].iov_base = 0; 829 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 830 831 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 832 return xcb_ret; 833 } 834 835 836 /***************************************************************************** 837 ** 838 ** xcb_glx_make_current_cookie_t xcb_glx_make_current 839 ** 840 ** @param xcb_connection_t *c 841 ** @param xcb_glx_drawable_t drawable 842 ** @param xcb_glx_context_t context 843 ** @param xcb_glx_context_tag_t old_context_tag 844 ** @returns xcb_glx_make_current_cookie_t 845 ** 846 *****************************************************************************/ 847 848 xcb_glx_make_current_cookie_t 849 xcb_glx_make_current (xcb_connection_t *c /**< */, 850 xcb_glx_drawable_t drawable /**< */, 851 xcb_glx_context_t context /**< */, 852 xcb_glx_context_tag_t old_context_tag /**< */) 853 { 854 static const xcb_protocol_request_t xcb_req = { 855 /* count */ 2, 856 /* ext */ &xcb_glx_id, 857 /* opcode */ XCB_GLX_MAKE_CURRENT, 858 /* isvoid */ 0 859 }; 860 861 struct iovec xcb_parts[4]; 862 xcb_glx_make_current_cookie_t xcb_ret; 863 xcb_glx_make_current_request_t xcb_out; 864 865 xcb_out.drawable = drawable; 866 xcb_out.context = context; 867 xcb_out.old_context_tag = old_context_tag; 868 869 xcb_parts[2].iov_base = (char *) &xcb_out; 870 xcb_parts[2].iov_len = sizeof(xcb_out); 871 xcb_parts[3].iov_base = 0; 872 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 873 874 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 875 return xcb_ret; 876 } 877 878 879 /***************************************************************************** 880 ** 881 ** xcb_glx_make_current_cookie_t xcb_glx_make_current_unchecked 882 ** 883 ** @param xcb_connection_t *c 884 ** @param xcb_glx_drawable_t drawable 885 ** @param xcb_glx_context_t context 886 ** @param xcb_glx_context_tag_t old_context_tag 887 ** @returns xcb_glx_make_current_cookie_t 888 ** 889 *****************************************************************************/ 890 891 xcb_glx_make_current_cookie_t 892 xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, 893 xcb_glx_drawable_t drawable /**< */, 894 xcb_glx_context_t context /**< */, 895 xcb_glx_context_tag_t old_context_tag /**< */) 896 { 897 static const xcb_protocol_request_t xcb_req = { 898 /* count */ 2, 899 /* ext */ &xcb_glx_id, 900 /* opcode */ XCB_GLX_MAKE_CURRENT, 901 /* isvoid */ 0 902 }; 903 904 struct iovec xcb_parts[4]; 905 xcb_glx_make_current_cookie_t xcb_ret; 906 xcb_glx_make_current_request_t xcb_out; 907 908 xcb_out.drawable = drawable; 909 xcb_out.context = context; 910 xcb_out.old_context_tag = old_context_tag; 911 912 xcb_parts[2].iov_base = (char *) &xcb_out; 913 xcb_parts[2].iov_len = sizeof(xcb_out); 914 xcb_parts[3].iov_base = 0; 915 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 916 917 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 918 return xcb_ret; 919 } 920 921 922 /***************************************************************************** 923 ** 924 ** xcb_glx_make_current_reply_t * xcb_glx_make_current_reply 925 ** 926 ** @param xcb_connection_t *c 927 ** @param xcb_glx_make_current_cookie_t cookie 928 ** @param xcb_generic_error_t **e 929 ** @returns xcb_glx_make_current_reply_t * 930 ** 931 *****************************************************************************/ 932 933 xcb_glx_make_current_reply_t * 934 xcb_glx_make_current_reply (xcb_connection_t *c /**< */, 935 xcb_glx_make_current_cookie_t cookie /**< */, 936 xcb_generic_error_t **e /**< */) 937 { 938 return (xcb_glx_make_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 939 } 940 941 942 /***************************************************************************** 943 ** 944 ** xcb_glx_is_direct_cookie_t xcb_glx_is_direct 945 ** 946 ** @param xcb_connection_t *c 947 ** @param xcb_glx_context_t context 948 ** @returns xcb_glx_is_direct_cookie_t 949 ** 950 *****************************************************************************/ 951 952 xcb_glx_is_direct_cookie_t 953 xcb_glx_is_direct (xcb_connection_t *c /**< */, 954 xcb_glx_context_t context /**< */) 955 { 956 static const xcb_protocol_request_t xcb_req = { 957 /* count */ 2, 958 /* ext */ &xcb_glx_id, 959 /* opcode */ XCB_GLX_IS_DIRECT, 960 /* isvoid */ 0 961 }; 962 963 struct iovec xcb_parts[4]; 964 xcb_glx_is_direct_cookie_t xcb_ret; 965 xcb_glx_is_direct_request_t xcb_out; 966 967 xcb_out.context = context; 968 969 xcb_parts[2].iov_base = (char *) &xcb_out; 970 xcb_parts[2].iov_len = sizeof(xcb_out); 971 xcb_parts[3].iov_base = 0; 972 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 973 974 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 975 return xcb_ret; 976 } 977 978 979 /***************************************************************************** 980 ** 981 ** xcb_glx_is_direct_cookie_t xcb_glx_is_direct_unchecked 982 ** 983 ** @param xcb_connection_t *c 984 ** @param xcb_glx_context_t context 985 ** @returns xcb_glx_is_direct_cookie_t 986 ** 987 *****************************************************************************/ 988 989 xcb_glx_is_direct_cookie_t 990 xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, 991 xcb_glx_context_t context /**< */) 992 { 993 static const xcb_protocol_request_t xcb_req = { 994 /* count */ 2, 995 /* ext */ &xcb_glx_id, 996 /* opcode */ XCB_GLX_IS_DIRECT, 997 /* isvoid */ 0 998 }; 999 1000 struct iovec xcb_parts[4]; 1001 xcb_glx_is_direct_cookie_t xcb_ret; 1002 xcb_glx_is_direct_request_t xcb_out; 1003 1004 xcb_out.context = context; 1005 1006 xcb_parts[2].iov_base = (char *) &xcb_out; 1007 xcb_parts[2].iov_len = sizeof(xcb_out); 1008 xcb_parts[3].iov_base = 0; 1009 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1010 1011 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1012 return xcb_ret; 1013 } 1014 1015 1016 /***************************************************************************** 1017 ** 1018 ** xcb_glx_is_direct_reply_t * xcb_glx_is_direct_reply 1019 ** 1020 ** @param xcb_connection_t *c 1021 ** @param xcb_glx_is_direct_cookie_t cookie 1022 ** @param xcb_generic_error_t **e 1023 ** @returns xcb_glx_is_direct_reply_t * 1024 ** 1025 *****************************************************************************/ 1026 1027 xcb_glx_is_direct_reply_t * 1028 xcb_glx_is_direct_reply (xcb_connection_t *c /**< */, 1029 xcb_glx_is_direct_cookie_t cookie /**< */, 1030 xcb_generic_error_t **e /**< */) 1031 { 1032 return (xcb_glx_is_direct_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1033 } 1034 1035 1036 /***************************************************************************** 1037 ** 1038 ** xcb_glx_query_version_cookie_t xcb_glx_query_version 1039 ** 1040 ** @param xcb_connection_t *c 1041 ** @param uint32_t major_version 1042 ** @param uint32_t minor_version 1043 ** @returns xcb_glx_query_version_cookie_t 1044 ** 1045 *****************************************************************************/ 1046 1047 xcb_glx_query_version_cookie_t 1048 xcb_glx_query_version (xcb_connection_t *c /**< */, 1049 uint32_t major_version /**< */, 1050 uint32_t minor_version /**< */) 1051 { 1052 static const xcb_protocol_request_t xcb_req = { 1053 /* count */ 2, 1054 /* ext */ &xcb_glx_id, 1055 /* opcode */ XCB_GLX_QUERY_VERSION, 1056 /* isvoid */ 0 1057 }; 1058 1059 struct iovec xcb_parts[4]; 1060 xcb_glx_query_version_cookie_t xcb_ret; 1061 xcb_glx_query_version_request_t xcb_out; 1062 1063 xcb_out.major_version = major_version; 1064 xcb_out.minor_version = minor_version; 1065 1066 xcb_parts[2].iov_base = (char *) &xcb_out; 1067 xcb_parts[2].iov_len = sizeof(xcb_out); 1068 xcb_parts[3].iov_base = 0; 1069 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1070 1071 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1072 return xcb_ret; 1073 } 1074 1075 1076 /***************************************************************************** 1077 ** 1078 ** xcb_glx_query_version_cookie_t xcb_glx_query_version_unchecked 1079 ** 1080 ** @param xcb_connection_t *c 1081 ** @param uint32_t major_version 1082 ** @param uint32_t minor_version 1083 ** @returns xcb_glx_query_version_cookie_t 1084 ** 1085 *****************************************************************************/ 1086 1087 xcb_glx_query_version_cookie_t 1088 xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, 1089 uint32_t major_version /**< */, 1090 uint32_t minor_version /**< */) 1091 { 1092 static const xcb_protocol_request_t xcb_req = { 1093 /* count */ 2, 1094 /* ext */ &xcb_glx_id, 1095 /* opcode */ XCB_GLX_QUERY_VERSION, 1096 /* isvoid */ 0 1097 }; 1098 1099 struct iovec xcb_parts[4]; 1100 xcb_glx_query_version_cookie_t xcb_ret; 1101 xcb_glx_query_version_request_t xcb_out; 1102 1103 xcb_out.major_version = major_version; 1104 xcb_out.minor_version = minor_version; 1105 1106 xcb_parts[2].iov_base = (char *) &xcb_out; 1107 xcb_parts[2].iov_len = sizeof(xcb_out); 1108 xcb_parts[3].iov_base = 0; 1109 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1110 1111 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1112 return xcb_ret; 1113 } 1114 1115 1116 /***************************************************************************** 1117 ** 1118 ** xcb_glx_query_version_reply_t * xcb_glx_query_version_reply 1119 ** 1120 ** @param xcb_connection_t *c 1121 ** @param xcb_glx_query_version_cookie_t cookie 1122 ** @param xcb_generic_error_t **e 1123 ** @returns xcb_glx_query_version_reply_t * 1124 ** 1125 *****************************************************************************/ 1126 1127 xcb_glx_query_version_reply_t * 1128 xcb_glx_query_version_reply (xcb_connection_t *c /**< */, 1129 xcb_glx_query_version_cookie_t cookie /**< */, 1130 xcb_generic_error_t **e /**< */) 1131 { 1132 return (xcb_glx_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1133 } 1134 1135 1136 /***************************************************************************** 1137 ** 1138 ** xcb_void_cookie_t xcb_glx_wait_gl_checked 1139 ** 1140 ** @param xcb_connection_t *c 1141 ** @param xcb_glx_context_tag_t context_tag 1142 ** @returns xcb_void_cookie_t 1143 ** 1144 *****************************************************************************/ 1145 1146 xcb_void_cookie_t 1147 xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, 1148 xcb_glx_context_tag_t context_tag /**< */) 1149 { 1150 static const xcb_protocol_request_t xcb_req = { 1151 /* count */ 2, 1152 /* ext */ &xcb_glx_id, 1153 /* opcode */ XCB_GLX_WAIT_GL, 1154 /* isvoid */ 1 1155 }; 1156 1157 struct iovec xcb_parts[4]; 1158 xcb_void_cookie_t xcb_ret; 1159 xcb_glx_wait_gl_request_t xcb_out; 1160 1161 xcb_out.context_tag = context_tag; 1162 1163 xcb_parts[2].iov_base = (char *) &xcb_out; 1164 xcb_parts[2].iov_len = sizeof(xcb_out); 1165 xcb_parts[3].iov_base = 0; 1166 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1167 1168 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1169 return xcb_ret; 1170 } 1171 1172 1173 /***************************************************************************** 1174 ** 1175 ** xcb_void_cookie_t xcb_glx_wait_gl 1176 ** 1177 ** @param xcb_connection_t *c 1178 ** @param xcb_glx_context_tag_t context_tag 1179 ** @returns xcb_void_cookie_t 1180 ** 1181 *****************************************************************************/ 1182 1183 xcb_void_cookie_t 1184 xcb_glx_wait_gl (xcb_connection_t *c /**< */, 1185 xcb_glx_context_tag_t context_tag /**< */) 1186 { 1187 static const xcb_protocol_request_t xcb_req = { 1188 /* count */ 2, 1189 /* ext */ &xcb_glx_id, 1190 /* opcode */ XCB_GLX_WAIT_GL, 1191 /* isvoid */ 1 1192 }; 1193 1194 struct iovec xcb_parts[4]; 1195 xcb_void_cookie_t xcb_ret; 1196 xcb_glx_wait_gl_request_t xcb_out; 1197 1198 xcb_out.context_tag = context_tag; 1199 1200 xcb_parts[2].iov_base = (char *) &xcb_out; 1201 xcb_parts[2].iov_len = sizeof(xcb_out); 1202 xcb_parts[3].iov_base = 0; 1203 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1204 1205 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1206 return xcb_ret; 1207 } 1208 1209 1210 /***************************************************************************** 1211 ** 1212 ** xcb_void_cookie_t xcb_glx_wait_x_checked 1213 ** 1214 ** @param xcb_connection_t *c 1215 ** @param xcb_glx_context_tag_t context_tag 1216 ** @returns xcb_void_cookie_t 1217 ** 1218 *****************************************************************************/ 1219 1220 xcb_void_cookie_t 1221 xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, 1222 xcb_glx_context_tag_t context_tag /**< */) 1223 { 1224 static const xcb_protocol_request_t xcb_req = { 1225 /* count */ 2, 1226 /* ext */ &xcb_glx_id, 1227 /* opcode */ XCB_GLX_WAIT_X, 1228 /* isvoid */ 1 1229 }; 1230 1231 struct iovec xcb_parts[4]; 1232 xcb_void_cookie_t xcb_ret; 1233 xcb_glx_wait_x_request_t xcb_out; 1234 1235 xcb_out.context_tag = context_tag; 1236 1237 xcb_parts[2].iov_base = (char *) &xcb_out; 1238 xcb_parts[2].iov_len = sizeof(xcb_out); 1239 xcb_parts[3].iov_base = 0; 1240 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1241 1242 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1243 return xcb_ret; 1244 } 1245 1246 1247 /***************************************************************************** 1248 ** 1249 ** xcb_void_cookie_t xcb_glx_wait_x 1250 ** 1251 ** @param xcb_connection_t *c 1252 ** @param xcb_glx_context_tag_t context_tag 1253 ** @returns xcb_void_cookie_t 1254 ** 1255 *****************************************************************************/ 1256 1257 xcb_void_cookie_t 1258 xcb_glx_wait_x (xcb_connection_t *c /**< */, 1259 xcb_glx_context_tag_t context_tag /**< */) 1260 { 1261 static const xcb_protocol_request_t xcb_req = { 1262 /* count */ 2, 1263 /* ext */ &xcb_glx_id, 1264 /* opcode */ XCB_GLX_WAIT_X, 1265 /* isvoid */ 1 1266 }; 1267 1268 struct iovec xcb_parts[4]; 1269 xcb_void_cookie_t xcb_ret; 1270 xcb_glx_wait_x_request_t xcb_out; 1271 1272 xcb_out.context_tag = context_tag; 1273 1274 xcb_parts[2].iov_base = (char *) &xcb_out; 1275 xcb_parts[2].iov_len = sizeof(xcb_out); 1276 xcb_parts[3].iov_base = 0; 1277 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1278 1279 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1280 return xcb_ret; 1281 } 1282 1283 1284 /***************************************************************************** 1285 ** 1286 ** xcb_void_cookie_t xcb_glx_copy_context_checked 1287 ** 1288 ** @param xcb_connection_t *c 1289 ** @param xcb_glx_context_t src 1290 ** @param xcb_glx_context_t dest 1291 ** @param uint32_t mask 1292 ** @param xcb_glx_context_tag_t src_context_tag 1293 ** @returns xcb_void_cookie_t 1294 ** 1295 *****************************************************************************/ 1296 1297 xcb_void_cookie_t 1298 xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, 1299 xcb_glx_context_t src /**< */, 1300 xcb_glx_context_t dest /**< */, 1301 uint32_t mask /**< */, 1302 xcb_glx_context_tag_t src_context_tag /**< */) 1303 { 1304 static const xcb_protocol_request_t xcb_req = { 1305 /* count */ 2, 1306 /* ext */ &xcb_glx_id, 1307 /* opcode */ XCB_GLX_COPY_CONTEXT, 1308 /* isvoid */ 1 1309 }; 1310 1311 struct iovec xcb_parts[4]; 1312 xcb_void_cookie_t xcb_ret; 1313 xcb_glx_copy_context_request_t xcb_out; 1314 1315 xcb_out.src = src; 1316 xcb_out.dest = dest; 1317 xcb_out.mask = mask; 1318 xcb_out.src_context_tag = src_context_tag; 1319 1320 xcb_parts[2].iov_base = (char *) &xcb_out; 1321 xcb_parts[2].iov_len = sizeof(xcb_out); 1322 xcb_parts[3].iov_base = 0; 1323 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1324 1325 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1326 return xcb_ret; 1327 } 1328 1329 1330 /***************************************************************************** 1331 ** 1332 ** xcb_void_cookie_t xcb_glx_copy_context 1333 ** 1334 ** @param xcb_connection_t *c 1335 ** @param xcb_glx_context_t src 1336 ** @param xcb_glx_context_t dest 1337 ** @param uint32_t mask 1338 ** @param xcb_glx_context_tag_t src_context_tag 1339 ** @returns xcb_void_cookie_t 1340 ** 1341 *****************************************************************************/ 1342 1343 xcb_void_cookie_t 1344 xcb_glx_copy_context (xcb_connection_t *c /**< */, 1345 xcb_glx_context_t src /**< */, 1346 xcb_glx_context_t dest /**< */, 1347 uint32_t mask /**< */, 1348 xcb_glx_context_tag_t src_context_tag /**< */) 1349 { 1350 static const xcb_protocol_request_t xcb_req = { 1351 /* count */ 2, 1352 /* ext */ &xcb_glx_id, 1353 /* opcode */ XCB_GLX_COPY_CONTEXT, 1354 /* isvoid */ 1 1355 }; 1356 1357 struct iovec xcb_parts[4]; 1358 xcb_void_cookie_t xcb_ret; 1359 xcb_glx_copy_context_request_t xcb_out; 1360 1361 xcb_out.src = src; 1362 xcb_out.dest = dest; 1363 xcb_out.mask = mask; 1364 xcb_out.src_context_tag = src_context_tag; 1365 1366 xcb_parts[2].iov_base = (char *) &xcb_out; 1367 xcb_parts[2].iov_len = sizeof(xcb_out); 1368 xcb_parts[3].iov_base = 0; 1369 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1370 1371 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1372 return xcb_ret; 1373 } 1374 1375 1376 /***************************************************************************** 1377 ** 1378 ** xcb_void_cookie_t xcb_glx_swap_buffers_checked 1379 ** 1380 ** @param xcb_connection_t *c 1381 ** @param xcb_glx_context_tag_t context_tag 1382 ** @param xcb_glx_drawable_t drawable 1383 ** @returns xcb_void_cookie_t 1384 ** 1385 *****************************************************************************/ 1386 1387 xcb_void_cookie_t 1388 xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, 1389 xcb_glx_context_tag_t context_tag /**< */, 1390 xcb_glx_drawable_t drawable /**< */) 1391 { 1392 static const xcb_protocol_request_t xcb_req = { 1393 /* count */ 2, 1394 /* ext */ &xcb_glx_id, 1395 /* opcode */ XCB_GLX_SWAP_BUFFERS, 1396 /* isvoid */ 1 1397 }; 1398 1399 struct iovec xcb_parts[4]; 1400 xcb_void_cookie_t xcb_ret; 1401 xcb_glx_swap_buffers_request_t xcb_out; 1402 1403 xcb_out.context_tag = context_tag; 1404 xcb_out.drawable = drawable; 1405 1406 xcb_parts[2].iov_base = (char *) &xcb_out; 1407 xcb_parts[2].iov_len = sizeof(xcb_out); 1408 xcb_parts[3].iov_base = 0; 1409 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1410 1411 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1412 return xcb_ret; 1413 } 1414 1415 1416 /***************************************************************************** 1417 ** 1418 ** xcb_void_cookie_t xcb_glx_swap_buffers 1419 ** 1420 ** @param xcb_connection_t *c 1421 ** @param xcb_glx_context_tag_t context_tag 1422 ** @param xcb_glx_drawable_t drawable 1423 ** @returns xcb_void_cookie_t 1424 ** 1425 *****************************************************************************/ 1426 1427 xcb_void_cookie_t 1428 xcb_glx_swap_buffers (xcb_connection_t *c /**< */, 1429 xcb_glx_context_tag_t context_tag /**< */, 1430 xcb_glx_drawable_t drawable /**< */) 1431 { 1432 static const xcb_protocol_request_t xcb_req = { 1433 /* count */ 2, 1434 /* ext */ &xcb_glx_id, 1435 /* opcode */ XCB_GLX_SWAP_BUFFERS, 1436 /* isvoid */ 1 1437 }; 1438 1439 struct iovec xcb_parts[4]; 1440 xcb_void_cookie_t xcb_ret; 1441 xcb_glx_swap_buffers_request_t xcb_out; 1442 1443 xcb_out.context_tag = context_tag; 1444 xcb_out.drawable = drawable; 1445 1446 xcb_parts[2].iov_base = (char *) &xcb_out; 1447 xcb_parts[2].iov_len = sizeof(xcb_out); 1448 xcb_parts[3].iov_base = 0; 1449 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1450 1451 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1452 return xcb_ret; 1453 } 1454 1455 1456 /***************************************************************************** 1457 ** 1458 ** xcb_void_cookie_t xcb_glx_use_x_font_checked 1459 ** 1460 ** @param xcb_connection_t *c 1461 ** @param xcb_glx_context_tag_t context_tag 1462 ** @param xcb_font_t font 1463 ** @param uint32_t first 1464 ** @param uint32_t count 1465 ** @param uint32_t list_base 1466 ** @returns xcb_void_cookie_t 1467 ** 1468 *****************************************************************************/ 1469 1470 xcb_void_cookie_t 1471 xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, 1472 xcb_glx_context_tag_t context_tag /**< */, 1473 xcb_font_t font /**< */, 1474 uint32_t first /**< */, 1475 uint32_t count /**< */, 1476 uint32_t list_base /**< */) 1477 { 1478 static const xcb_protocol_request_t xcb_req = { 1479 /* count */ 2, 1480 /* ext */ &xcb_glx_id, 1481 /* opcode */ XCB_GLX_USE_X_FONT, 1482 /* isvoid */ 1 1483 }; 1484 1485 struct iovec xcb_parts[4]; 1486 xcb_void_cookie_t xcb_ret; 1487 xcb_glx_use_x_font_request_t xcb_out; 1488 1489 xcb_out.context_tag = context_tag; 1490 xcb_out.font = font; 1491 xcb_out.first = first; 1492 xcb_out.count = count; 1493 xcb_out.list_base = list_base; 1494 1495 xcb_parts[2].iov_base = (char *) &xcb_out; 1496 xcb_parts[2].iov_len = sizeof(xcb_out); 1497 xcb_parts[3].iov_base = 0; 1498 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1499 1500 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1501 return xcb_ret; 1502 } 1503 1504 1505 /***************************************************************************** 1506 ** 1507 ** xcb_void_cookie_t xcb_glx_use_x_font 1508 ** 1509 ** @param xcb_connection_t *c 1510 ** @param xcb_glx_context_tag_t context_tag 1511 ** @param xcb_font_t font 1512 ** @param uint32_t first 1513 ** @param uint32_t count 1514 ** @param uint32_t list_base 1515 ** @returns xcb_void_cookie_t 1516 ** 1517 *****************************************************************************/ 1518 1519 xcb_void_cookie_t 1520 xcb_glx_use_x_font (xcb_connection_t *c /**< */, 1521 xcb_glx_context_tag_t context_tag /**< */, 1522 xcb_font_t font /**< */, 1523 uint32_t first /**< */, 1524 uint32_t count /**< */, 1525 uint32_t list_base /**< */) 1526 { 1527 static const xcb_protocol_request_t xcb_req = { 1528 /* count */ 2, 1529 /* ext */ &xcb_glx_id, 1530 /* opcode */ XCB_GLX_USE_X_FONT, 1531 /* isvoid */ 1 1532 }; 1533 1534 struct iovec xcb_parts[4]; 1535 xcb_void_cookie_t xcb_ret; 1536 xcb_glx_use_x_font_request_t xcb_out; 1537 1538 xcb_out.context_tag = context_tag; 1539 xcb_out.font = font; 1540 xcb_out.first = first; 1541 xcb_out.count = count; 1542 xcb_out.list_base = list_base; 1543 1544 xcb_parts[2].iov_base = (char *) &xcb_out; 1545 xcb_parts[2].iov_len = sizeof(xcb_out); 1546 xcb_parts[3].iov_base = 0; 1547 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1548 1549 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1550 return xcb_ret; 1551 } 1552 1553 1554 /***************************************************************************** 1555 ** 1556 ** xcb_void_cookie_t xcb_glx_create_glx_pixmap_checked 1557 ** 1558 ** @param xcb_connection_t *c 1559 ** @param uint32_t screen 1560 ** @param xcb_visualid_t visual 1561 ** @param xcb_pixmap_t pixmap 1562 ** @param xcb_glx_pixmap_t glx_pixmap 1563 ** @returns xcb_void_cookie_t 1564 ** 1565 *****************************************************************************/ 1566 1567 xcb_void_cookie_t 1568 xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, 1569 uint32_t screen /**< */, 1570 xcb_visualid_t visual /**< */, 1571 xcb_pixmap_t pixmap /**< */, 1572 xcb_glx_pixmap_t glx_pixmap /**< */) 1573 { 1574 static const xcb_protocol_request_t xcb_req = { 1575 /* count */ 2, 1576 /* ext */ &xcb_glx_id, 1577 /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, 1578 /* isvoid */ 1 1579 }; 1580 1581 struct iovec xcb_parts[4]; 1582 xcb_void_cookie_t xcb_ret; 1583 xcb_glx_create_glx_pixmap_request_t xcb_out; 1584 1585 xcb_out.screen = screen; 1586 xcb_out.visual = visual; 1587 xcb_out.pixmap = pixmap; 1588 xcb_out.glx_pixmap = glx_pixmap; 1589 1590 xcb_parts[2].iov_base = (char *) &xcb_out; 1591 xcb_parts[2].iov_len = sizeof(xcb_out); 1592 xcb_parts[3].iov_base = 0; 1593 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1594 1595 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1596 return xcb_ret; 1597 } 1598 1599 1600 /***************************************************************************** 1601 ** 1602 ** xcb_void_cookie_t xcb_glx_create_glx_pixmap 1603 ** 1604 ** @param xcb_connection_t *c 1605 ** @param uint32_t screen 1606 ** @param xcb_visualid_t visual 1607 ** @param xcb_pixmap_t pixmap 1608 ** @param xcb_glx_pixmap_t glx_pixmap 1609 ** @returns xcb_void_cookie_t 1610 ** 1611 *****************************************************************************/ 1612 1613 xcb_void_cookie_t 1614 xcb_glx_create_glx_pixmap (xcb_connection_t *c /**< */, 1615 uint32_t screen /**< */, 1616 xcb_visualid_t visual /**< */, 1617 xcb_pixmap_t pixmap /**< */, 1618 xcb_glx_pixmap_t glx_pixmap /**< */) 1619 { 1620 static const xcb_protocol_request_t xcb_req = { 1621 /* count */ 2, 1622 /* ext */ &xcb_glx_id, 1623 /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, 1624 /* isvoid */ 1 1625 }; 1626 1627 struct iovec xcb_parts[4]; 1628 xcb_void_cookie_t xcb_ret; 1629 xcb_glx_create_glx_pixmap_request_t xcb_out; 1630 1631 xcb_out.screen = screen; 1632 xcb_out.visual = visual; 1633 xcb_out.pixmap = pixmap; 1634 xcb_out.glx_pixmap = glx_pixmap; 1635 1636 xcb_parts[2].iov_base = (char *) &xcb_out; 1637 xcb_parts[2].iov_len = sizeof(xcb_out); 1638 xcb_parts[3].iov_base = 0; 1639 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1640 1641 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1642 return xcb_ret; 1643 } 1644 1645 int 1646 xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */) 1647 { 1648 char *xcb_tmp = (char *)_buffer; 1649 const xcb_glx_get_visual_configs_reply_t *_aux = (xcb_glx_get_visual_configs_reply_t *)_buffer; 1650 unsigned int xcb_buffer_len = 0; 1651 unsigned int xcb_block_len = 0; 1652 unsigned int xcb_pad = 0; 1653 unsigned int xcb_align_to = 0; 1654 1655 1656 xcb_block_len += sizeof(xcb_glx_get_visual_configs_reply_t); 1657 xcb_tmp += xcb_block_len; 1658 xcb_buffer_len += xcb_block_len; 1659 xcb_block_len = 0; 1660 /* property_list */ 1661 xcb_block_len += _aux->length * sizeof(uint32_t); 1662 xcb_tmp += xcb_block_len; 1663 xcb_align_to = ALIGNOF(uint32_t); 1664 /* insert padding */ 1665 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1666 xcb_buffer_len += xcb_block_len + xcb_pad; 1667 if (0 != xcb_pad) { 1668 xcb_tmp += xcb_pad; 1669 xcb_pad = 0; 1670 } 1671 xcb_block_len = 0; 1672 1673 return xcb_buffer_len; 1674 } 1675 1676 1677 /***************************************************************************** 1678 ** 1679 ** xcb_glx_get_visual_configs_cookie_t xcb_glx_get_visual_configs 1680 ** 1681 ** @param xcb_connection_t *c 1682 ** @param uint32_t screen 1683 ** @returns xcb_glx_get_visual_configs_cookie_t 1684 ** 1685 *****************************************************************************/ 1686 1687 xcb_glx_get_visual_configs_cookie_t 1688 xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, 1689 uint32_t screen /**< */) 1690 { 1691 static const xcb_protocol_request_t xcb_req = { 1692 /* count */ 2, 1693 /* ext */ &xcb_glx_id, 1694 /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, 1695 /* isvoid */ 0 1696 }; 1697 1698 struct iovec xcb_parts[4]; 1699 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1700 xcb_glx_get_visual_configs_request_t xcb_out; 1701 1702 xcb_out.screen = screen; 1703 1704 xcb_parts[2].iov_base = (char *) &xcb_out; 1705 xcb_parts[2].iov_len = sizeof(xcb_out); 1706 xcb_parts[3].iov_base = 0; 1707 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1708 1709 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1710 return xcb_ret; 1711 } 1712 1713 1714 /***************************************************************************** 1715 ** 1716 ** xcb_glx_get_visual_configs_cookie_t xcb_glx_get_visual_configs_unchecked 1717 ** 1718 ** @param xcb_connection_t *c 1719 ** @param uint32_t screen 1720 ** @returns xcb_glx_get_visual_configs_cookie_t 1721 ** 1722 *****************************************************************************/ 1723 1724 xcb_glx_get_visual_configs_cookie_t 1725 xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c /**< */, 1726 uint32_t screen /**< */) 1727 { 1728 static const xcb_protocol_request_t xcb_req = { 1729 /* count */ 2, 1730 /* ext */ &xcb_glx_id, 1731 /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, 1732 /* isvoid */ 0 1733 }; 1734 1735 struct iovec xcb_parts[4]; 1736 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1737 xcb_glx_get_visual_configs_request_t xcb_out; 1738 1739 xcb_out.screen = screen; 1740 1741 xcb_parts[2].iov_base = (char *) &xcb_out; 1742 xcb_parts[2].iov_len = sizeof(xcb_out); 1743 xcb_parts[3].iov_base = 0; 1744 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1745 1746 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1747 return xcb_ret; 1748 } 1749 1750 1751 /***************************************************************************** 1752 ** 1753 ** uint32_t * xcb_glx_get_visual_configs_property_list 1754 ** 1755 ** @param const xcb_glx_get_visual_configs_reply_t *R 1756 ** @returns uint32_t * 1757 ** 1758 *****************************************************************************/ 1759 1760 uint32_t * 1761 xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1762 { 1763 return (uint32_t *) (R + 1); 1764 } 1765 1766 1767 /***************************************************************************** 1768 ** 1769 ** int xcb_glx_get_visual_configs_property_list_length 1770 ** 1771 ** @param const xcb_glx_get_visual_configs_reply_t *R 1772 ** @returns int 1773 ** 1774 *****************************************************************************/ 1775 1776 int 1777 xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1778 { 1779 return R->length; 1780 } 1781 1782 1783 /***************************************************************************** 1784 ** 1785 ** xcb_generic_iterator_t xcb_glx_get_visual_configs_property_list_end 1786 ** 1787 ** @param const xcb_glx_get_visual_configs_reply_t *R 1788 ** @returns xcb_generic_iterator_t 1789 ** 1790 *****************************************************************************/ 1791 1792 xcb_generic_iterator_t 1793 xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R /**< */) 1794 { 1795 xcb_generic_iterator_t i; 1796 i.data = ((uint32_t *) (R + 1)) + (R->length); 1797 i.rem = 0; 1798 i.index = (char *) i.data - (char *) R; 1799 return i; 1800 } 1801 1802 1803 /***************************************************************************** 1804 ** 1805 ** xcb_glx_get_visual_configs_reply_t * xcb_glx_get_visual_configs_reply 1806 ** 1807 ** @param xcb_connection_t *c 1808 ** @param xcb_glx_get_visual_configs_cookie_t cookie 1809 ** @param xcb_generic_error_t **e 1810 ** @returns xcb_glx_get_visual_configs_reply_t * 1811 ** 1812 *****************************************************************************/ 1813 1814 xcb_glx_get_visual_configs_reply_t * 1815 xcb_glx_get_visual_configs_reply (xcb_connection_t *c /**< */, 1816 xcb_glx_get_visual_configs_cookie_t cookie /**< */, 1817 xcb_generic_error_t **e /**< */) 1818 { 1819 return (xcb_glx_get_visual_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1820 } 1821 1822 1823 /***************************************************************************** 1824 ** 1825 ** xcb_void_cookie_t xcb_glx_destroy_glx_pixmap_checked 1826 ** 1827 ** @param xcb_connection_t *c 1828 ** @param xcb_glx_pixmap_t glx_pixmap 1829 ** @returns xcb_void_cookie_t 1830 ** 1831 *****************************************************************************/ 1832 1833 xcb_void_cookie_t 1834 xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, 1835 xcb_glx_pixmap_t glx_pixmap /**< */) 1836 { 1837 static const xcb_protocol_request_t xcb_req = { 1838 /* count */ 2, 1839 /* ext */ &xcb_glx_id, 1840 /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, 1841 /* isvoid */ 1 1842 }; 1843 1844 struct iovec xcb_parts[4]; 1845 xcb_void_cookie_t xcb_ret; 1846 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1847 1848 xcb_out.glx_pixmap = glx_pixmap; 1849 1850 xcb_parts[2].iov_base = (char *) &xcb_out; 1851 xcb_parts[2].iov_len = sizeof(xcb_out); 1852 xcb_parts[3].iov_base = 0; 1853 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1854 1855 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1856 return xcb_ret; 1857 } 1858 1859 1860 /***************************************************************************** 1861 ** 1862 ** xcb_void_cookie_t xcb_glx_destroy_glx_pixmap 1863 ** 1864 ** @param xcb_connection_t *c 1865 ** @param xcb_glx_pixmap_t glx_pixmap 1866 ** @returns xcb_void_cookie_t 1867 ** 1868 *****************************************************************************/ 1869 1870 xcb_void_cookie_t 1871 xcb_glx_destroy_glx_pixmap (xcb_connection_t *c /**< */, 1872 xcb_glx_pixmap_t glx_pixmap /**< */) 1873 { 1874 static const xcb_protocol_request_t xcb_req = { 1875 /* count */ 2, 1876 /* ext */ &xcb_glx_id, 1877 /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, 1878 /* isvoid */ 1 1879 }; 1880 1881 struct iovec xcb_parts[4]; 1882 xcb_void_cookie_t xcb_ret; 1883 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1884 1885 xcb_out.glx_pixmap = glx_pixmap; 1886 1887 xcb_parts[2].iov_base = (char *) &xcb_out; 1888 xcb_parts[2].iov_len = sizeof(xcb_out); 1889 xcb_parts[3].iov_base = 0; 1890 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1891 1892 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1893 return xcb_ret; 1894 } 1895 1896 int 1897 xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, 1898 uint32_t data_len /**< */) 1899 { 1900 char *xcb_tmp = (char *)_buffer; 1901 unsigned int xcb_buffer_len = 0; 1902 unsigned int xcb_block_len = 0; 1903 unsigned int xcb_pad = 0; 1904 unsigned int xcb_align_to = 0; 1905 1906 1907 xcb_block_len += sizeof(xcb_glx_vendor_private_request_t); 1908 xcb_tmp += xcb_block_len; 1909 xcb_buffer_len += xcb_block_len; 1910 xcb_block_len = 0; 1911 /* data */ 1912 xcb_block_len += data_len * sizeof(uint8_t); 1913 xcb_tmp += xcb_block_len; 1914 xcb_align_to = ALIGNOF(uint8_t); 1915 /* insert padding */ 1916 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1917 xcb_buffer_len += xcb_block_len + xcb_pad; 1918 if (0 != xcb_pad) { 1919 xcb_tmp += xcb_pad; 1920 xcb_pad = 0; 1921 } 1922 xcb_block_len = 0; 1923 1924 return xcb_buffer_len; 1925 } 1926 1927 1928 /***************************************************************************** 1929 ** 1930 ** xcb_void_cookie_t xcb_glx_vendor_private_checked 1931 ** 1932 ** @param xcb_connection_t *c 1933 ** @param uint32_t vendor_code 1934 ** @param xcb_glx_context_tag_t context_tag 1935 ** @param uint32_t data_len 1936 ** @param const uint8_t *data 1937 ** @returns xcb_void_cookie_t 1938 ** 1939 *****************************************************************************/ 1940 1941 xcb_void_cookie_t 1942 xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, 1943 uint32_t vendor_code /**< */, 1944 xcb_glx_context_tag_t context_tag /**< */, 1945 uint32_t data_len /**< */, 1946 const uint8_t *data /**< */) 1947 { 1948 static const xcb_protocol_request_t xcb_req = { 1949 /* count */ 4, 1950 /* ext */ &xcb_glx_id, 1951 /* opcode */ XCB_GLX_VENDOR_PRIVATE, 1952 /* isvoid */ 1 1953 }; 1954 1955 struct iovec xcb_parts[6]; 1956 xcb_void_cookie_t xcb_ret; 1957 xcb_glx_vendor_private_request_t xcb_out; 1958 1959 xcb_out.vendor_code = vendor_code; 1960 xcb_out.context_tag = context_tag; 1961 1962 xcb_parts[2].iov_base = (char *) &xcb_out; 1963 xcb_parts[2].iov_len = sizeof(xcb_out); 1964 xcb_parts[3].iov_base = 0; 1965 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1966 /* uint8_t data */ 1967 xcb_parts[4].iov_base = (char *) data; 1968 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1969 xcb_parts[5].iov_base = 0; 1970 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1971 1972 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1973 return xcb_ret; 1974 } 1975 1976 1977 /***************************************************************************** 1978 ** 1979 ** xcb_void_cookie_t xcb_glx_vendor_private 1980 ** 1981 ** @param xcb_connection_t *c 1982 ** @param uint32_t vendor_code 1983 ** @param xcb_glx_context_tag_t context_tag 1984 ** @param uint32_t data_len 1985 ** @param const uint8_t *data 1986 ** @returns xcb_void_cookie_t 1987 ** 1988 *****************************************************************************/ 1989 1990 xcb_void_cookie_t 1991 xcb_glx_vendor_private (xcb_connection_t *c /**< */, 1992 uint32_t vendor_code /**< */, 1993 xcb_glx_context_tag_t context_tag /**< */, 1994 uint32_t data_len /**< */, 1995 const uint8_t *data /**< */) 1996 { 1997 static const xcb_protocol_request_t xcb_req = { 1998 /* count */ 4, 1999 /* ext */ &xcb_glx_id, 2000 /* opcode */ XCB_GLX_VENDOR_PRIVATE, 2001 /* isvoid */ 1 2002 }; 2003 2004 struct iovec xcb_parts[6]; 2005 xcb_void_cookie_t xcb_ret; 2006 xcb_glx_vendor_private_request_t xcb_out; 2007 2008 xcb_out.vendor_code = vendor_code; 2009 xcb_out.context_tag = context_tag; 2010 2011 xcb_parts[2].iov_base = (char *) &xcb_out; 2012 xcb_parts[2].iov_len = sizeof(xcb_out); 2013 xcb_parts[3].iov_base = 0; 2014 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2015 /* uint8_t data */ 2016 xcb_parts[4].iov_base = (char *) data; 2017 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2018 xcb_parts[5].iov_base = 0; 2019 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2020 2021 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2022 return xcb_ret; 2023 } 2024 2025 int 2026 xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, 2027 uint32_t data_len /**< */) 2028 { 2029 char *xcb_tmp = (char *)_buffer; 2030 unsigned int xcb_buffer_len = 0; 2031 unsigned int xcb_block_len = 0; 2032 unsigned int xcb_pad = 0; 2033 unsigned int xcb_align_to = 0; 2034 2035 2036 xcb_block_len += sizeof(xcb_glx_vendor_private_with_reply_request_t); 2037 xcb_tmp += xcb_block_len; 2038 xcb_buffer_len += xcb_block_len; 2039 xcb_block_len = 0; 2040 /* data */ 2041 xcb_block_len += data_len * sizeof(uint8_t); 2042 xcb_tmp += xcb_block_len; 2043 xcb_align_to = ALIGNOF(uint8_t); 2044 /* insert padding */ 2045 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2046 xcb_buffer_len += xcb_block_len + xcb_pad; 2047 if (0 != xcb_pad) { 2048 xcb_tmp += xcb_pad; 2049 xcb_pad = 0; 2050 } 2051 xcb_block_len = 0; 2052 2053 return xcb_buffer_len; 2054 } 2055 2056 2057 /***************************************************************************** 2058 ** 2059 ** xcb_glx_vendor_private_with_reply_cookie_t xcb_glx_vendor_private_with_reply 2060 ** 2061 ** @param xcb_connection_t *c 2062 ** @param uint32_t vendor_code 2063 ** @param xcb_glx_context_tag_t context_tag 2064 ** @param uint32_t data_len 2065 ** @param const uint8_t *data 2066 ** @returns xcb_glx_vendor_private_with_reply_cookie_t 2067 ** 2068 *****************************************************************************/ 2069 2070 xcb_glx_vendor_private_with_reply_cookie_t 2071 xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, 2072 uint32_t vendor_code /**< */, 2073 xcb_glx_context_tag_t context_tag /**< */, 2074 uint32_t data_len /**< */, 2075 const uint8_t *data /**< */) 2076 { 2077 static const xcb_protocol_request_t xcb_req = { 2078 /* count */ 4, 2079 /* ext */ &xcb_glx_id, 2080 /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 2081 /* isvoid */ 0 2082 }; 2083 2084 struct iovec xcb_parts[6]; 2085 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 2086 xcb_glx_vendor_private_with_reply_request_t xcb_out; 2087 2088 xcb_out.vendor_code = vendor_code; 2089 xcb_out.context_tag = context_tag; 2090 2091 xcb_parts[2].iov_base = (char *) &xcb_out; 2092 xcb_parts[2].iov_len = sizeof(xcb_out); 2093 xcb_parts[3].iov_base = 0; 2094 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2095 /* uint8_t data */ 2096 xcb_parts[4].iov_base = (char *) data; 2097 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2098 xcb_parts[5].iov_base = 0; 2099 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2100 2101 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2102 return xcb_ret; 2103 } 2104 2105 2106 /***************************************************************************** 2107 ** 2108 ** xcb_glx_vendor_private_with_reply_cookie_t xcb_glx_vendor_private_with_reply_unchecked 2109 ** 2110 ** @param xcb_connection_t *c 2111 ** @param uint32_t vendor_code 2112 ** @param xcb_glx_context_tag_t context_tag 2113 ** @param uint32_t data_len 2114 ** @param const uint8_t *data 2115 ** @returns xcb_glx_vendor_private_with_reply_cookie_t 2116 ** 2117 *****************************************************************************/ 2118 2119 xcb_glx_vendor_private_with_reply_cookie_t 2120 xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c /**< */, 2121 uint32_t vendor_code /**< */, 2122 xcb_glx_context_tag_t context_tag /**< */, 2123 uint32_t data_len /**< */, 2124 const uint8_t *data /**< */) 2125 { 2126 static const xcb_protocol_request_t xcb_req = { 2127 /* count */ 4, 2128 /* ext */ &xcb_glx_id, 2129 /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 2130 /* isvoid */ 0 2131 }; 2132 2133 struct iovec xcb_parts[6]; 2134 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 2135 xcb_glx_vendor_private_with_reply_request_t xcb_out; 2136 2137 xcb_out.vendor_code = vendor_code; 2138 xcb_out.context_tag = context_tag; 2139 2140 xcb_parts[2].iov_base = (char *) &xcb_out; 2141 xcb_parts[2].iov_len = sizeof(xcb_out); 2142 xcb_parts[3].iov_base = 0; 2143 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2144 /* uint8_t data */ 2145 xcb_parts[4].iov_base = (char *) data; 2146 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 2147 xcb_parts[5].iov_base = 0; 2148 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2149 2150 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2151 return xcb_ret; 2152 } 2153 2154 2155 /***************************************************************************** 2156 ** 2157 ** uint8_t * xcb_glx_vendor_private_with_reply_data_2 2158 ** 2159 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2160 ** @returns uint8_t * 2161 ** 2162 *****************************************************************************/ 2163 2164 uint8_t * 2165 xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2166 { 2167 return (uint8_t *) (R + 1); 2168 } 2169 2170 2171 /***************************************************************************** 2172 ** 2173 ** int xcb_glx_vendor_private_with_reply_data_2_length 2174 ** 2175 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2176 ** @returns int 2177 ** 2178 *****************************************************************************/ 2179 2180 int 2181 xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2182 { 2183 return (R->length * 4); 2184 } 2185 2186 2187 /***************************************************************************** 2188 ** 2189 ** xcb_generic_iterator_t xcb_glx_vendor_private_with_reply_data_2_end 2190 ** 2191 ** @param const xcb_glx_vendor_private_with_reply_reply_t *R 2192 ** @returns xcb_generic_iterator_t 2193 ** 2194 *****************************************************************************/ 2195 2196 xcb_generic_iterator_t 2197 xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) 2198 { 2199 xcb_generic_iterator_t i; 2200 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 2201 i.rem = 0; 2202 i.index = (char *) i.data - (char *) R; 2203 return i; 2204 } 2205 2206 2207 /***************************************************************************** 2208 ** 2209 ** xcb_glx_vendor_private_with_reply_reply_t * xcb_glx_vendor_private_with_reply_reply 2210 ** 2211 ** @param xcb_connection_t *c 2212 ** @param xcb_glx_vendor_private_with_reply_cookie_t cookie 2213 ** @param xcb_generic_error_t **e 2214 ** @returns xcb_glx_vendor_private_with_reply_reply_t * 2215 ** 2216 *****************************************************************************/ 2217 2218 xcb_glx_vendor_private_with_reply_reply_t * 2219 xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c /**< */, 2220 xcb_glx_vendor_private_with_reply_cookie_t cookie /**< */, 2221 xcb_generic_error_t **e /**< */) 2222 { 2223 return (xcb_glx_vendor_private_with_reply_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2224 } 2225 2226 2227 /***************************************************************************** 2228 ** 2229 ** xcb_glx_query_extensions_string_cookie_t xcb_glx_query_extensions_string 2230 ** 2231 ** @param xcb_connection_t *c 2232 ** @param uint32_t screen 2233 ** @returns xcb_glx_query_extensions_string_cookie_t 2234 ** 2235 *****************************************************************************/ 2236 2237 xcb_glx_query_extensions_string_cookie_t 2238 xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, 2239 uint32_t screen /**< */) 2240 { 2241 static const xcb_protocol_request_t xcb_req = { 2242 /* count */ 2, 2243 /* ext */ &xcb_glx_id, 2244 /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, 2245 /* isvoid */ 0 2246 }; 2247 2248 struct iovec xcb_parts[4]; 2249 xcb_glx_query_extensions_string_cookie_t xcb_ret; 2250 xcb_glx_query_extensions_string_request_t xcb_out; 2251 2252 xcb_out.screen = screen; 2253 2254 xcb_parts[2].iov_base = (char *) &xcb_out; 2255 xcb_parts[2].iov_len = sizeof(xcb_out); 2256 xcb_parts[3].iov_base = 0; 2257 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2258 2259 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2260 return xcb_ret; 2261 } 2262 2263 2264 /***************************************************************************** 2265 ** 2266 ** xcb_glx_query_extensions_string_cookie_t xcb_glx_query_extensions_string_unchecked 2267 ** 2268 ** @param xcb_connection_t *c 2269 ** @param uint32_t screen 2270 ** @returns xcb_glx_query_extensions_string_cookie_t 2271 ** 2272 *****************************************************************************/ 2273 2274 xcb_glx_query_extensions_string_cookie_t 2275 xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, 2276 uint32_t screen /**< */) 2277 { 2278 static const xcb_protocol_request_t xcb_req = { 2279 /* count */ 2, 2280 /* ext */ &xcb_glx_id, 2281 /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, 2282 /* isvoid */ 0 2283 }; 2284 2285 struct iovec xcb_parts[4]; 2286 xcb_glx_query_extensions_string_cookie_t xcb_ret; 2287 xcb_glx_query_extensions_string_request_t xcb_out; 2288 2289 xcb_out.screen = screen; 2290 2291 xcb_parts[2].iov_base = (char *) &xcb_out; 2292 xcb_parts[2].iov_len = sizeof(xcb_out); 2293 xcb_parts[3].iov_base = 0; 2294 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2295 2296 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2297 return xcb_ret; 2298 } 2299 2300 2301 /***************************************************************************** 2302 ** 2303 ** xcb_glx_query_extensions_string_reply_t * xcb_glx_query_extensions_string_reply 2304 ** 2305 ** @param xcb_connection_t *c 2306 ** @param xcb_glx_query_extensions_string_cookie_t cookie 2307 ** @param xcb_generic_error_t **e 2308 ** @returns xcb_glx_query_extensions_string_reply_t * 2309 ** 2310 *****************************************************************************/ 2311 2312 xcb_glx_query_extensions_string_reply_t * 2313 xcb_glx_query_extensions_string_reply (xcb_connection_t *c /**< */, 2314 xcb_glx_query_extensions_string_cookie_t cookie /**< */, 2315 xcb_generic_error_t **e /**< */) 2316 { 2317 return (xcb_glx_query_extensions_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2318 } 2319 2320 int 2321 xcb_glx_query_server_string_sizeof (const void *_buffer /**< */) 2322 { 2323 char *xcb_tmp = (char *)_buffer; 2324 const xcb_glx_query_server_string_reply_t *_aux = (xcb_glx_query_server_string_reply_t *)_buffer; 2325 unsigned int xcb_buffer_len = 0; 2326 unsigned int xcb_block_len = 0; 2327 unsigned int xcb_pad = 0; 2328 unsigned int xcb_align_to = 0; 2329 2330 2331 xcb_block_len += sizeof(xcb_glx_query_server_string_reply_t); 2332 xcb_tmp += xcb_block_len; 2333 xcb_buffer_len += xcb_block_len; 2334 xcb_block_len = 0; 2335 /* string */ 2336 xcb_block_len += _aux->str_len * sizeof(char); 2337 xcb_tmp += xcb_block_len; 2338 xcb_align_to = ALIGNOF(char); 2339 /* insert padding */ 2340 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2341 xcb_buffer_len += xcb_block_len + xcb_pad; 2342 if (0 != xcb_pad) { 2343 xcb_tmp += xcb_pad; 2344 xcb_pad = 0; 2345 } 2346 xcb_block_len = 0; 2347 2348 return xcb_buffer_len; 2349 } 2350 2351 2352 /***************************************************************************** 2353 ** 2354 ** xcb_glx_query_server_string_cookie_t xcb_glx_query_server_string 2355 ** 2356 ** @param xcb_connection_t *c 2357 ** @param uint32_t screen 2358 ** @param uint32_t name 2359 ** @returns xcb_glx_query_server_string_cookie_t 2360 ** 2361 *****************************************************************************/ 2362 2363 xcb_glx_query_server_string_cookie_t 2364 xcb_glx_query_server_string (xcb_connection_t *c /**< */, 2365 uint32_t screen /**< */, 2366 uint32_t name /**< */) 2367 { 2368 static const xcb_protocol_request_t xcb_req = { 2369 /* count */ 2, 2370 /* ext */ &xcb_glx_id, 2371 /* opcode */ XCB_GLX_QUERY_SERVER_STRING, 2372 /* isvoid */ 0 2373 }; 2374 2375 struct iovec xcb_parts[4]; 2376 xcb_glx_query_server_string_cookie_t xcb_ret; 2377 xcb_glx_query_server_string_request_t xcb_out; 2378 2379 xcb_out.screen = screen; 2380 xcb_out.name = name; 2381 2382 xcb_parts[2].iov_base = (char *) &xcb_out; 2383 xcb_parts[2].iov_len = sizeof(xcb_out); 2384 xcb_parts[3].iov_base = 0; 2385 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2386 2387 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2388 return xcb_ret; 2389 } 2390 2391 2392 /***************************************************************************** 2393 ** 2394 ** xcb_glx_query_server_string_cookie_t xcb_glx_query_server_string_unchecked 2395 ** 2396 ** @param xcb_connection_t *c 2397 ** @param uint32_t screen 2398 ** @param uint32_t name 2399 ** @returns xcb_glx_query_server_string_cookie_t 2400 ** 2401 *****************************************************************************/ 2402 2403 xcb_glx_query_server_string_cookie_t 2404 xcb_glx_query_server_string_unchecked (xcb_connection_t *c /**< */, 2405 uint32_t screen /**< */, 2406 uint32_t name /**< */) 2407 { 2408 static const xcb_protocol_request_t xcb_req = { 2409 /* count */ 2, 2410 /* ext */ &xcb_glx_id, 2411 /* opcode */ XCB_GLX_QUERY_SERVER_STRING, 2412 /* isvoid */ 0 2413 }; 2414 2415 struct iovec xcb_parts[4]; 2416 xcb_glx_query_server_string_cookie_t xcb_ret; 2417 xcb_glx_query_server_string_request_t xcb_out; 2418 2419 xcb_out.screen = screen; 2420 xcb_out.name = name; 2421 2422 xcb_parts[2].iov_base = (char *) &xcb_out; 2423 xcb_parts[2].iov_len = sizeof(xcb_out); 2424 xcb_parts[3].iov_base = 0; 2425 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2426 2427 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2428 return xcb_ret; 2429 } 2430 2431 2432 /***************************************************************************** 2433 ** 2434 ** char * xcb_glx_query_server_string_string 2435 ** 2436 ** @param const xcb_glx_query_server_string_reply_t *R 2437 ** @returns char * 2438 ** 2439 *****************************************************************************/ 2440 2441 char * 2442 xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R /**< */) 2443 { 2444 return (char *) (R + 1); 2445 } 2446 2447 2448 /***************************************************************************** 2449 ** 2450 ** int xcb_glx_query_server_string_string_length 2451 ** 2452 ** @param const xcb_glx_query_server_string_reply_t *R 2453 ** @returns int 2454 ** 2455 *****************************************************************************/ 2456 2457 int 2458 xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R /**< */) 2459 { 2460 return R->str_len; 2461 } 2462 2463 2464 /***************************************************************************** 2465 ** 2466 ** xcb_generic_iterator_t xcb_glx_query_server_string_string_end 2467 ** 2468 ** @param const xcb_glx_query_server_string_reply_t *R 2469 ** @returns xcb_generic_iterator_t 2470 ** 2471 *****************************************************************************/ 2472 2473 xcb_generic_iterator_t 2474 xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R /**< */) 2475 { 2476 xcb_generic_iterator_t i; 2477 i.data = ((char *) (R + 1)) + (R->str_len); 2478 i.rem = 0; 2479 i.index = (char *) i.data - (char *) R; 2480 return i; 2481 } 2482 2483 2484 /***************************************************************************** 2485 ** 2486 ** xcb_glx_query_server_string_reply_t * xcb_glx_query_server_string_reply 2487 ** 2488 ** @param xcb_connection_t *c 2489 ** @param xcb_glx_query_server_string_cookie_t cookie 2490 ** @param xcb_generic_error_t **e 2491 ** @returns xcb_glx_query_server_string_reply_t * 2492 ** 2493 *****************************************************************************/ 2494 2495 xcb_glx_query_server_string_reply_t * 2496 xcb_glx_query_server_string_reply (xcb_connection_t *c /**< */, 2497 xcb_glx_query_server_string_cookie_t cookie /**< */, 2498 xcb_generic_error_t **e /**< */) 2499 { 2500 return (xcb_glx_query_server_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2501 } 2502 2503 int 2504 xcb_glx_client_info_sizeof (const void *_buffer /**< */) 2505 { 2506 char *xcb_tmp = (char *)_buffer; 2507 const xcb_glx_client_info_request_t *_aux = (xcb_glx_client_info_request_t *)_buffer; 2508 unsigned int xcb_buffer_len = 0; 2509 unsigned int xcb_block_len = 0; 2510 unsigned int xcb_pad = 0; 2511 unsigned int xcb_align_to = 0; 2512 2513 2514 xcb_block_len += sizeof(xcb_glx_client_info_request_t); 2515 xcb_tmp += xcb_block_len; 2516 xcb_buffer_len += xcb_block_len; 2517 xcb_block_len = 0; 2518 /* string */ 2519 xcb_block_len += _aux->str_len * sizeof(char); 2520 xcb_tmp += xcb_block_len; 2521 xcb_align_to = ALIGNOF(char); 2522 /* insert padding */ 2523 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2524 xcb_buffer_len += xcb_block_len + xcb_pad; 2525 if (0 != xcb_pad) { 2526 xcb_tmp += xcb_pad; 2527 xcb_pad = 0; 2528 } 2529 xcb_block_len = 0; 2530 2531 return xcb_buffer_len; 2532 } 2533 2534 2535 /***************************************************************************** 2536 ** 2537 ** xcb_void_cookie_t xcb_glx_client_info_checked 2538 ** 2539 ** @param xcb_connection_t *c 2540 ** @param uint32_t major_version 2541 ** @param uint32_t minor_version 2542 ** @param uint32_t str_len 2543 ** @param const char *string 2544 ** @returns xcb_void_cookie_t 2545 ** 2546 *****************************************************************************/ 2547 2548 xcb_void_cookie_t 2549 xcb_glx_client_info_checked (xcb_connection_t *c /**< */, 2550 uint32_t major_version /**< */, 2551 uint32_t minor_version /**< */, 2552 uint32_t str_len /**< */, 2553 const char *string /**< */) 2554 { 2555 static const xcb_protocol_request_t xcb_req = { 2556 /* count */ 4, 2557 /* ext */ &xcb_glx_id, 2558 /* opcode */ XCB_GLX_CLIENT_INFO, 2559 /* isvoid */ 1 2560 }; 2561 2562 struct iovec xcb_parts[6]; 2563 xcb_void_cookie_t xcb_ret; 2564 xcb_glx_client_info_request_t xcb_out; 2565 2566 xcb_out.major_version = major_version; 2567 xcb_out.minor_version = minor_version; 2568 xcb_out.str_len = str_len; 2569 2570 xcb_parts[2].iov_base = (char *) &xcb_out; 2571 xcb_parts[2].iov_len = sizeof(xcb_out); 2572 xcb_parts[3].iov_base = 0; 2573 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2574 /* char string */ 2575 xcb_parts[4].iov_base = (char *) string; 2576 xcb_parts[4].iov_len = str_len * sizeof(char); 2577 xcb_parts[5].iov_base = 0; 2578 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2579 2580 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2581 return xcb_ret; 2582 } 2583 2584 2585 /***************************************************************************** 2586 ** 2587 ** xcb_void_cookie_t xcb_glx_client_info 2588 ** 2589 ** @param xcb_connection_t *c 2590 ** @param uint32_t major_version 2591 ** @param uint32_t minor_version 2592 ** @param uint32_t str_len 2593 ** @param const char *string 2594 ** @returns xcb_void_cookie_t 2595 ** 2596 *****************************************************************************/ 2597 2598 xcb_void_cookie_t 2599 xcb_glx_client_info (xcb_connection_t *c /**< */, 2600 uint32_t major_version /**< */, 2601 uint32_t minor_version /**< */, 2602 uint32_t str_len /**< */, 2603 const char *string /**< */) 2604 { 2605 static const xcb_protocol_request_t xcb_req = { 2606 /* count */ 4, 2607 /* ext */ &xcb_glx_id, 2608 /* opcode */ XCB_GLX_CLIENT_INFO, 2609 /* isvoid */ 1 2610 }; 2611 2612 struct iovec xcb_parts[6]; 2613 xcb_void_cookie_t xcb_ret; 2614 xcb_glx_client_info_request_t xcb_out; 2615 2616 xcb_out.major_version = major_version; 2617 xcb_out.minor_version = minor_version; 2618 xcb_out.str_len = str_len; 2619 2620 xcb_parts[2].iov_base = (char *) &xcb_out; 2621 xcb_parts[2].iov_len = sizeof(xcb_out); 2622 xcb_parts[3].iov_base = 0; 2623 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2624 /* char string */ 2625 xcb_parts[4].iov_base = (char *) string; 2626 xcb_parts[4].iov_len = str_len * sizeof(char); 2627 xcb_parts[5].iov_base = 0; 2628 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2629 2630 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2631 return xcb_ret; 2632 } 2633 2634 int 2635 xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */) 2636 { 2637 char *xcb_tmp = (char *)_buffer; 2638 const xcb_glx_get_fb_configs_reply_t *_aux = (xcb_glx_get_fb_configs_reply_t *)_buffer; 2639 unsigned int xcb_buffer_len = 0; 2640 unsigned int xcb_block_len = 0; 2641 unsigned int xcb_pad = 0; 2642 unsigned int xcb_align_to = 0; 2643 2644 2645 xcb_block_len += sizeof(xcb_glx_get_fb_configs_reply_t); 2646 xcb_tmp += xcb_block_len; 2647 xcb_buffer_len += xcb_block_len; 2648 xcb_block_len = 0; 2649 /* property_list */ 2650 xcb_block_len += _aux->length * sizeof(uint32_t); 2651 xcb_tmp += xcb_block_len; 2652 xcb_align_to = ALIGNOF(uint32_t); 2653 /* insert padding */ 2654 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2655 xcb_buffer_len += xcb_block_len + xcb_pad; 2656 if (0 != xcb_pad) { 2657 xcb_tmp += xcb_pad; 2658 xcb_pad = 0; 2659 } 2660 xcb_block_len = 0; 2661 2662 return xcb_buffer_len; 2663 } 2664 2665 2666 /***************************************************************************** 2667 ** 2668 ** xcb_glx_get_fb_configs_cookie_t xcb_glx_get_fb_configs 2669 ** 2670 ** @param xcb_connection_t *c 2671 ** @param uint32_t screen 2672 ** @returns xcb_glx_get_fb_configs_cookie_t 2673 ** 2674 *****************************************************************************/ 2675 2676 xcb_glx_get_fb_configs_cookie_t 2677 xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, 2678 uint32_t screen /**< */) 2679 { 2680 static const xcb_protocol_request_t xcb_req = { 2681 /* count */ 2, 2682 /* ext */ &xcb_glx_id, 2683 /* opcode */ XCB_GLX_GET_FB_CONFIGS, 2684 /* isvoid */ 0 2685 }; 2686 2687 struct iovec xcb_parts[4]; 2688 xcb_glx_get_fb_configs_cookie_t xcb_ret; 2689 xcb_glx_get_fb_configs_request_t xcb_out; 2690 2691 xcb_out.screen = screen; 2692 2693 xcb_parts[2].iov_base = (char *) &xcb_out; 2694 xcb_parts[2].iov_len = sizeof(xcb_out); 2695 xcb_parts[3].iov_base = 0; 2696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2697 2698 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2699 return xcb_ret; 2700 } 2701 2702 2703 /***************************************************************************** 2704 ** 2705 ** xcb_glx_get_fb_configs_cookie_t xcb_glx_get_fb_configs_unchecked 2706 ** 2707 ** @param xcb_connection_t *c 2708 ** @param uint32_t screen 2709 ** @returns xcb_glx_get_fb_configs_cookie_t 2710 ** 2711 *****************************************************************************/ 2712 2713 xcb_glx_get_fb_configs_cookie_t 2714 xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c /**< */, 2715 uint32_t screen /**< */) 2716 { 2717 static const xcb_protocol_request_t xcb_req = { 2718 /* count */ 2, 2719 /* ext */ &xcb_glx_id, 2720 /* opcode */ XCB_GLX_GET_FB_CONFIGS, 2721 /* isvoid */ 0 2722 }; 2723 2724 struct iovec xcb_parts[4]; 2725 xcb_glx_get_fb_configs_cookie_t xcb_ret; 2726 xcb_glx_get_fb_configs_request_t xcb_out; 2727 2728 xcb_out.screen = screen; 2729 2730 xcb_parts[2].iov_base = (char *) &xcb_out; 2731 xcb_parts[2].iov_len = sizeof(xcb_out); 2732 xcb_parts[3].iov_base = 0; 2733 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2734 2735 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2736 return xcb_ret; 2737 } 2738 2739 2740 /***************************************************************************** 2741 ** 2742 ** uint32_t * xcb_glx_get_fb_configs_property_list 2743 ** 2744 ** @param const xcb_glx_get_fb_configs_reply_t *R 2745 ** @returns uint32_t * 2746 ** 2747 *****************************************************************************/ 2748 2749 uint32_t * 2750 xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2751 { 2752 return (uint32_t *) (R + 1); 2753 } 2754 2755 2756 /***************************************************************************** 2757 ** 2758 ** int xcb_glx_get_fb_configs_property_list_length 2759 ** 2760 ** @param const xcb_glx_get_fb_configs_reply_t *R 2761 ** @returns int 2762 ** 2763 *****************************************************************************/ 2764 2765 int 2766 xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2767 { 2768 return R->length; 2769 } 2770 2771 2772 /***************************************************************************** 2773 ** 2774 ** xcb_generic_iterator_t xcb_glx_get_fb_configs_property_list_end 2775 ** 2776 ** @param const xcb_glx_get_fb_configs_reply_t *R 2777 ** @returns xcb_generic_iterator_t 2778 ** 2779 *****************************************************************************/ 2780 2781 xcb_generic_iterator_t 2782 xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R /**< */) 2783 { 2784 xcb_generic_iterator_t i; 2785 i.data = ((uint32_t *) (R + 1)) + (R->length); 2786 i.rem = 0; 2787 i.index = (char *) i.data - (char *) R; 2788 return i; 2789 } 2790 2791 2792 /***************************************************************************** 2793 ** 2794 ** xcb_glx_get_fb_configs_reply_t * xcb_glx_get_fb_configs_reply 2795 ** 2796 ** @param xcb_connection_t *c 2797 ** @param xcb_glx_get_fb_configs_cookie_t cookie 2798 ** @param xcb_generic_error_t **e 2799 ** @returns xcb_glx_get_fb_configs_reply_t * 2800 ** 2801 *****************************************************************************/ 2802 2803 xcb_glx_get_fb_configs_reply_t * 2804 xcb_glx_get_fb_configs_reply (xcb_connection_t *c /**< */, 2805 xcb_glx_get_fb_configs_cookie_t cookie /**< */, 2806 xcb_generic_error_t **e /**< */) 2807 { 2808 return (xcb_glx_get_fb_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2809 } 2810 2811 int 2812 xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */) 2813 { 2814 char *xcb_tmp = (char *)_buffer; 2815 const xcb_glx_create_pixmap_request_t *_aux = (xcb_glx_create_pixmap_request_t *)_buffer; 2816 unsigned int xcb_buffer_len = 0; 2817 unsigned int xcb_block_len = 0; 2818 unsigned int xcb_pad = 0; 2819 unsigned int xcb_align_to = 0; 2820 2821 2822 xcb_block_len += sizeof(xcb_glx_create_pixmap_request_t); 2823 xcb_tmp += xcb_block_len; 2824 xcb_buffer_len += xcb_block_len; 2825 xcb_block_len = 0; 2826 /* attribs */ 2827 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2828 xcb_tmp += xcb_block_len; 2829 xcb_align_to = ALIGNOF(uint32_t); 2830 /* insert padding */ 2831 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2832 xcb_buffer_len += xcb_block_len + xcb_pad; 2833 if (0 != xcb_pad) { 2834 xcb_tmp += xcb_pad; 2835 xcb_pad = 0; 2836 } 2837 xcb_block_len = 0; 2838 2839 return xcb_buffer_len; 2840 } 2841 2842 2843 /***************************************************************************** 2844 ** 2845 ** xcb_void_cookie_t xcb_glx_create_pixmap_checked 2846 ** 2847 ** @param xcb_connection_t *c 2848 ** @param uint32_t screen 2849 ** @param xcb_glx_fbconfig_t fbconfig 2850 ** @param xcb_pixmap_t pixmap 2851 ** @param xcb_glx_pixmap_t glx_pixmap 2852 ** @param uint32_t num_attribs 2853 ** @param const uint32_t *attribs 2854 ** @returns xcb_void_cookie_t 2855 ** 2856 *****************************************************************************/ 2857 2858 xcb_void_cookie_t 2859 xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, 2860 uint32_t screen /**< */, 2861 xcb_glx_fbconfig_t fbconfig /**< */, 2862 xcb_pixmap_t pixmap /**< */, 2863 xcb_glx_pixmap_t glx_pixmap /**< */, 2864 uint32_t num_attribs /**< */, 2865 const uint32_t *attribs /**< */) 2866 { 2867 static const xcb_protocol_request_t xcb_req = { 2868 /* count */ 4, 2869 /* ext */ &xcb_glx_id, 2870 /* opcode */ XCB_GLX_CREATE_PIXMAP, 2871 /* isvoid */ 1 2872 }; 2873 2874 struct iovec xcb_parts[6]; 2875 xcb_void_cookie_t xcb_ret; 2876 xcb_glx_create_pixmap_request_t xcb_out; 2877 2878 xcb_out.screen = screen; 2879 xcb_out.fbconfig = fbconfig; 2880 xcb_out.pixmap = pixmap; 2881 xcb_out.glx_pixmap = glx_pixmap; 2882 xcb_out.num_attribs = num_attribs; 2883 2884 xcb_parts[2].iov_base = (char *) &xcb_out; 2885 xcb_parts[2].iov_len = sizeof(xcb_out); 2886 xcb_parts[3].iov_base = 0; 2887 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2888 /* uint32_t attribs */ 2889 xcb_parts[4].iov_base = (char *) attribs; 2890 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2891 xcb_parts[5].iov_base = 0; 2892 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2893 2894 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2895 return xcb_ret; 2896 } 2897 2898 2899 /***************************************************************************** 2900 ** 2901 ** xcb_void_cookie_t xcb_glx_create_pixmap 2902 ** 2903 ** @param xcb_connection_t *c 2904 ** @param uint32_t screen 2905 ** @param xcb_glx_fbconfig_t fbconfig 2906 ** @param xcb_pixmap_t pixmap 2907 ** @param xcb_glx_pixmap_t glx_pixmap 2908 ** @param uint32_t num_attribs 2909 ** @param const uint32_t *attribs 2910 ** @returns xcb_void_cookie_t 2911 ** 2912 *****************************************************************************/ 2913 2914 xcb_void_cookie_t 2915 xcb_glx_create_pixmap (xcb_connection_t *c /**< */, 2916 uint32_t screen /**< */, 2917 xcb_glx_fbconfig_t fbconfig /**< */, 2918 xcb_pixmap_t pixmap /**< */, 2919 xcb_glx_pixmap_t glx_pixmap /**< */, 2920 uint32_t num_attribs /**< */, 2921 const uint32_t *attribs /**< */) 2922 { 2923 static const xcb_protocol_request_t xcb_req = { 2924 /* count */ 4, 2925 /* ext */ &xcb_glx_id, 2926 /* opcode */ XCB_GLX_CREATE_PIXMAP, 2927 /* isvoid */ 1 2928 }; 2929 2930 struct iovec xcb_parts[6]; 2931 xcb_void_cookie_t xcb_ret; 2932 xcb_glx_create_pixmap_request_t xcb_out; 2933 2934 xcb_out.screen = screen; 2935 xcb_out.fbconfig = fbconfig; 2936 xcb_out.pixmap = pixmap; 2937 xcb_out.glx_pixmap = glx_pixmap; 2938 xcb_out.num_attribs = num_attribs; 2939 2940 xcb_parts[2].iov_base = (char *) &xcb_out; 2941 xcb_parts[2].iov_len = sizeof(xcb_out); 2942 xcb_parts[3].iov_base = 0; 2943 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2944 /* uint32_t attribs */ 2945 xcb_parts[4].iov_base = (char *) attribs; 2946 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2947 xcb_parts[5].iov_base = 0; 2948 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2949 2950 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2951 return xcb_ret; 2952 } 2953 2954 2955 /***************************************************************************** 2956 ** 2957 ** xcb_void_cookie_t xcb_glx_destroy_pixmap_checked 2958 ** 2959 ** @param xcb_connection_t *c 2960 ** @param xcb_glx_pixmap_t glx_pixmap 2961 ** @returns xcb_void_cookie_t 2962 ** 2963 *****************************************************************************/ 2964 2965 xcb_void_cookie_t 2966 xcb_glx_destroy_pixmap_checked (xcb_connection_t *c /**< */, 2967 xcb_glx_pixmap_t glx_pixmap /**< */) 2968 { 2969 static const xcb_protocol_request_t xcb_req = { 2970 /* count */ 2, 2971 /* ext */ &xcb_glx_id, 2972 /* opcode */ XCB_GLX_DESTROY_PIXMAP, 2973 /* isvoid */ 1 2974 }; 2975 2976 struct iovec xcb_parts[4]; 2977 xcb_void_cookie_t xcb_ret; 2978 xcb_glx_destroy_pixmap_request_t xcb_out; 2979 2980 xcb_out.glx_pixmap = glx_pixmap; 2981 2982 xcb_parts[2].iov_base = (char *) &xcb_out; 2983 xcb_parts[2].iov_len = sizeof(xcb_out); 2984 xcb_parts[3].iov_base = 0; 2985 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2986 2987 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2988 return xcb_ret; 2989 } 2990 2991 2992 /***************************************************************************** 2993 ** 2994 ** xcb_void_cookie_t xcb_glx_destroy_pixmap 2995 ** 2996 ** @param xcb_connection_t *c 2997 ** @param xcb_glx_pixmap_t glx_pixmap 2998 ** @returns xcb_void_cookie_t 2999 ** 3000 *****************************************************************************/ 3001 3002 xcb_void_cookie_t 3003 xcb_glx_destroy_pixmap (xcb_connection_t *c /**< */, 3004 xcb_glx_pixmap_t glx_pixmap /**< */) 3005 { 3006 static const xcb_protocol_request_t xcb_req = { 3007 /* count */ 2, 3008 /* ext */ &xcb_glx_id, 3009 /* opcode */ XCB_GLX_DESTROY_PIXMAP, 3010 /* isvoid */ 1 3011 }; 3012 3013 struct iovec xcb_parts[4]; 3014 xcb_void_cookie_t xcb_ret; 3015 xcb_glx_destroy_pixmap_request_t xcb_out; 3016 3017 xcb_out.glx_pixmap = glx_pixmap; 3018 3019 xcb_parts[2].iov_base = (char *) &xcb_out; 3020 xcb_parts[2].iov_len = sizeof(xcb_out); 3021 xcb_parts[3].iov_base = 0; 3022 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3023 3024 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3025 return xcb_ret; 3026 } 3027 3028 3029 /***************************************************************************** 3030 ** 3031 ** xcb_void_cookie_t xcb_glx_create_new_context_checked 3032 ** 3033 ** @param xcb_connection_t *c 3034 ** @param xcb_glx_context_t context 3035 ** @param xcb_glx_fbconfig_t fbconfig 3036 ** @param uint32_t screen 3037 ** @param uint32_t render_type 3038 ** @param xcb_glx_context_t share_list 3039 ** @param uint8_t is_direct 3040 ** @returns xcb_void_cookie_t 3041 ** 3042 *****************************************************************************/ 3043 3044 xcb_void_cookie_t 3045 xcb_glx_create_new_context_checked (xcb_connection_t *c /**< */, 3046 xcb_glx_context_t context /**< */, 3047 xcb_glx_fbconfig_t fbconfig /**< */, 3048 uint32_t screen /**< */, 3049 uint32_t render_type /**< */, 3050 xcb_glx_context_t share_list /**< */, 3051 uint8_t is_direct /**< */) 3052 { 3053 static const xcb_protocol_request_t xcb_req = { 3054 /* count */ 2, 3055 /* ext */ &xcb_glx_id, 3056 /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, 3057 /* isvoid */ 1 3058 }; 3059 3060 struct iovec xcb_parts[4]; 3061 xcb_void_cookie_t xcb_ret; 3062 xcb_glx_create_new_context_request_t xcb_out; 3063 3064 xcb_out.context = context; 3065 xcb_out.fbconfig = fbconfig; 3066 xcb_out.screen = screen; 3067 xcb_out.render_type = render_type; 3068 xcb_out.share_list = share_list; 3069 xcb_out.is_direct = is_direct; 3070 memset(xcb_out.pad0, 0, 3); 3071 3072 xcb_parts[2].iov_base = (char *) &xcb_out; 3073 xcb_parts[2].iov_len = sizeof(xcb_out); 3074 xcb_parts[3].iov_base = 0; 3075 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3076 3077 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3078 return xcb_ret; 3079 } 3080 3081 3082 /***************************************************************************** 3083 ** 3084 ** xcb_void_cookie_t xcb_glx_create_new_context 3085 ** 3086 ** @param xcb_connection_t *c 3087 ** @param xcb_glx_context_t context 3088 ** @param xcb_glx_fbconfig_t fbconfig 3089 ** @param uint32_t screen 3090 ** @param uint32_t render_type 3091 ** @param xcb_glx_context_t share_list 3092 ** @param uint8_t is_direct 3093 ** @returns xcb_void_cookie_t 3094 ** 3095 *****************************************************************************/ 3096 3097 xcb_void_cookie_t 3098 xcb_glx_create_new_context (xcb_connection_t *c /**< */, 3099 xcb_glx_context_t context /**< */, 3100 xcb_glx_fbconfig_t fbconfig /**< */, 3101 uint32_t screen /**< */, 3102 uint32_t render_type /**< */, 3103 xcb_glx_context_t share_list /**< */, 3104 uint8_t is_direct /**< */) 3105 { 3106 static const xcb_protocol_request_t xcb_req = { 3107 /* count */ 2, 3108 /* ext */ &xcb_glx_id, 3109 /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, 3110 /* isvoid */ 1 3111 }; 3112 3113 struct iovec xcb_parts[4]; 3114 xcb_void_cookie_t xcb_ret; 3115 xcb_glx_create_new_context_request_t xcb_out; 3116 3117 xcb_out.context = context; 3118 xcb_out.fbconfig = fbconfig; 3119 xcb_out.screen = screen; 3120 xcb_out.render_type = render_type; 3121 xcb_out.share_list = share_list; 3122 xcb_out.is_direct = is_direct; 3123 memset(xcb_out.pad0, 0, 3); 3124 3125 xcb_parts[2].iov_base = (char *) &xcb_out; 3126 xcb_parts[2].iov_len = sizeof(xcb_out); 3127 xcb_parts[3].iov_base = 0; 3128 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3129 3130 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3131 return xcb_ret; 3132 } 3133 3134 int 3135 xcb_glx_query_context_sizeof (const void *_buffer /**< */) 3136 { 3137 char *xcb_tmp = (char *)_buffer; 3138 const xcb_glx_query_context_reply_t *_aux = (xcb_glx_query_context_reply_t *)_buffer; 3139 unsigned int xcb_buffer_len = 0; 3140 unsigned int xcb_block_len = 0; 3141 unsigned int xcb_pad = 0; 3142 unsigned int xcb_align_to = 0; 3143 3144 3145 xcb_block_len += sizeof(xcb_glx_query_context_reply_t); 3146 xcb_tmp += xcb_block_len; 3147 xcb_buffer_len += xcb_block_len; 3148 xcb_block_len = 0; 3149 /* attribs */ 3150 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3151 xcb_tmp += xcb_block_len; 3152 xcb_align_to = ALIGNOF(uint32_t); 3153 /* insert padding */ 3154 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3155 xcb_buffer_len += xcb_block_len + xcb_pad; 3156 if (0 != xcb_pad) { 3157 xcb_tmp += xcb_pad; 3158 xcb_pad = 0; 3159 } 3160 xcb_block_len = 0; 3161 3162 return xcb_buffer_len; 3163 } 3164 3165 3166 /***************************************************************************** 3167 ** 3168 ** xcb_glx_query_context_cookie_t xcb_glx_query_context 3169 ** 3170 ** @param xcb_connection_t *c 3171 ** @param xcb_glx_context_t context 3172 ** @returns xcb_glx_query_context_cookie_t 3173 ** 3174 *****************************************************************************/ 3175 3176 xcb_glx_query_context_cookie_t 3177 xcb_glx_query_context (xcb_connection_t *c /**< */, 3178 xcb_glx_context_t context /**< */) 3179 { 3180 static const xcb_protocol_request_t xcb_req = { 3181 /* count */ 2, 3182 /* ext */ &xcb_glx_id, 3183 /* opcode */ XCB_GLX_QUERY_CONTEXT, 3184 /* isvoid */ 0 3185 }; 3186 3187 struct iovec xcb_parts[4]; 3188 xcb_glx_query_context_cookie_t xcb_ret; 3189 xcb_glx_query_context_request_t xcb_out; 3190 3191 xcb_out.context = context; 3192 3193 xcb_parts[2].iov_base = (char *) &xcb_out; 3194 xcb_parts[2].iov_len = sizeof(xcb_out); 3195 xcb_parts[3].iov_base = 0; 3196 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3197 3198 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3199 return xcb_ret; 3200 } 3201 3202 3203 /***************************************************************************** 3204 ** 3205 ** xcb_glx_query_context_cookie_t xcb_glx_query_context_unchecked 3206 ** 3207 ** @param xcb_connection_t *c 3208 ** @param xcb_glx_context_t context 3209 ** @returns xcb_glx_query_context_cookie_t 3210 ** 3211 *****************************************************************************/ 3212 3213 xcb_glx_query_context_cookie_t 3214 xcb_glx_query_context_unchecked (xcb_connection_t *c /**< */, 3215 xcb_glx_context_t context /**< */) 3216 { 3217 static const xcb_protocol_request_t xcb_req = { 3218 /* count */ 2, 3219 /* ext */ &xcb_glx_id, 3220 /* opcode */ XCB_GLX_QUERY_CONTEXT, 3221 /* isvoid */ 0 3222 }; 3223 3224 struct iovec xcb_parts[4]; 3225 xcb_glx_query_context_cookie_t xcb_ret; 3226 xcb_glx_query_context_request_t xcb_out; 3227 3228 xcb_out.context = context; 3229 3230 xcb_parts[2].iov_base = (char *) &xcb_out; 3231 xcb_parts[2].iov_len = sizeof(xcb_out); 3232 xcb_parts[3].iov_base = 0; 3233 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3234 3235 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3236 return xcb_ret; 3237 } 3238 3239 3240 /***************************************************************************** 3241 ** 3242 ** uint32_t * xcb_glx_query_context_attribs 3243 ** 3244 ** @param const xcb_glx_query_context_reply_t *R 3245 ** @returns uint32_t * 3246 ** 3247 *****************************************************************************/ 3248 3249 uint32_t * 3250 xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R /**< */) 3251 { 3252 return (uint32_t *) (R + 1); 3253 } 3254 3255 3256 /***************************************************************************** 3257 ** 3258 ** int xcb_glx_query_context_attribs_length 3259 ** 3260 ** @param const xcb_glx_query_context_reply_t *R 3261 ** @returns int 3262 ** 3263 *****************************************************************************/ 3264 3265 int 3266 xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R /**< */) 3267 { 3268 return (R->num_attribs * 2); 3269 } 3270 3271 3272 /***************************************************************************** 3273 ** 3274 ** xcb_generic_iterator_t xcb_glx_query_context_attribs_end 3275 ** 3276 ** @param const xcb_glx_query_context_reply_t *R 3277 ** @returns xcb_generic_iterator_t 3278 ** 3279 *****************************************************************************/ 3280 3281 xcb_generic_iterator_t 3282 xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< */) 3283 { 3284 xcb_generic_iterator_t i; 3285 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3286 i.rem = 0; 3287 i.index = (char *) i.data - (char *) R; 3288 return i; 3289 } 3290 3291 3292 /***************************************************************************** 3293 ** 3294 ** xcb_glx_query_context_reply_t * xcb_glx_query_context_reply 3295 ** 3296 ** @param xcb_connection_t *c 3297 ** @param xcb_glx_query_context_cookie_t cookie 3298 ** @param xcb_generic_error_t **e 3299 ** @returns xcb_glx_query_context_reply_t * 3300 ** 3301 *****************************************************************************/ 3302 3303 xcb_glx_query_context_reply_t * 3304 xcb_glx_query_context_reply (xcb_connection_t *c /**< */, 3305 xcb_glx_query_context_cookie_t cookie /**< */, 3306 xcb_generic_error_t **e /**< */) 3307 { 3308 return (xcb_glx_query_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3309 } 3310 3311 3312 /***************************************************************************** 3313 ** 3314 ** xcb_glx_make_context_current_cookie_t xcb_glx_make_context_current 3315 ** 3316 ** @param xcb_connection_t *c 3317 ** @param xcb_glx_context_tag_t old_context_tag 3318 ** @param xcb_glx_drawable_t drawable 3319 ** @param xcb_glx_drawable_t read_drawable 3320 ** @param xcb_glx_context_t context 3321 ** @returns xcb_glx_make_context_current_cookie_t 3322 ** 3323 *****************************************************************************/ 3324 3325 xcb_glx_make_context_current_cookie_t 3326 xcb_glx_make_context_current (xcb_connection_t *c /**< */, 3327 xcb_glx_context_tag_t old_context_tag /**< */, 3328 xcb_glx_drawable_t drawable /**< */, 3329 xcb_glx_drawable_t read_drawable /**< */, 3330 xcb_glx_context_t context /**< */) 3331 { 3332 static const xcb_protocol_request_t xcb_req = { 3333 /* count */ 2, 3334 /* ext */ &xcb_glx_id, 3335 /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, 3336 /* isvoid */ 0 3337 }; 3338 3339 struct iovec xcb_parts[4]; 3340 xcb_glx_make_context_current_cookie_t xcb_ret; 3341 xcb_glx_make_context_current_request_t xcb_out; 3342 3343 xcb_out.old_context_tag = old_context_tag; 3344 xcb_out.drawable = drawable; 3345 xcb_out.read_drawable = read_drawable; 3346 xcb_out.context = context; 3347 3348 xcb_parts[2].iov_base = (char *) &xcb_out; 3349 xcb_parts[2].iov_len = sizeof(xcb_out); 3350 xcb_parts[3].iov_base = 0; 3351 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3352 3353 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3354 return xcb_ret; 3355 } 3356 3357 3358 /***************************************************************************** 3359 ** 3360 ** xcb_glx_make_context_current_cookie_t xcb_glx_make_context_current_unchecked 3361 ** 3362 ** @param xcb_connection_t *c 3363 ** @param xcb_glx_context_tag_t old_context_tag 3364 ** @param xcb_glx_drawable_t drawable 3365 ** @param xcb_glx_drawable_t read_drawable 3366 ** @param xcb_glx_context_t context 3367 ** @returns xcb_glx_make_context_current_cookie_t 3368 ** 3369 *****************************************************************************/ 3370 3371 xcb_glx_make_context_current_cookie_t 3372 xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, 3373 xcb_glx_context_tag_t old_context_tag /**< */, 3374 xcb_glx_drawable_t drawable /**< */, 3375 xcb_glx_drawable_t read_drawable /**< */, 3376 xcb_glx_context_t context /**< */) 3377 { 3378 static const xcb_protocol_request_t xcb_req = { 3379 /* count */ 2, 3380 /* ext */ &xcb_glx_id, 3381 /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, 3382 /* isvoid */ 0 3383 }; 3384 3385 struct iovec xcb_parts[4]; 3386 xcb_glx_make_context_current_cookie_t xcb_ret; 3387 xcb_glx_make_context_current_request_t xcb_out; 3388 3389 xcb_out.old_context_tag = old_context_tag; 3390 xcb_out.drawable = drawable; 3391 xcb_out.read_drawable = read_drawable; 3392 xcb_out.context = context; 3393 3394 xcb_parts[2].iov_base = (char *) &xcb_out; 3395 xcb_parts[2].iov_len = sizeof(xcb_out); 3396 xcb_parts[3].iov_base = 0; 3397 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3398 3399 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3400 return xcb_ret; 3401 } 3402 3403 3404 /***************************************************************************** 3405 ** 3406 ** xcb_glx_make_context_current_reply_t * xcb_glx_make_context_current_reply 3407 ** 3408 ** @param xcb_connection_t *c 3409 ** @param xcb_glx_make_context_current_cookie_t cookie 3410 ** @param xcb_generic_error_t **e 3411 ** @returns xcb_glx_make_context_current_reply_t * 3412 ** 3413 *****************************************************************************/ 3414 3415 xcb_glx_make_context_current_reply_t * 3416 xcb_glx_make_context_current_reply (xcb_connection_t *c /**< */, 3417 xcb_glx_make_context_current_cookie_t cookie /**< */, 3418 xcb_generic_error_t **e /**< */) 3419 { 3420 return (xcb_glx_make_context_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3421 } 3422 3423 int 3424 xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */) 3425 { 3426 char *xcb_tmp = (char *)_buffer; 3427 const xcb_glx_create_pbuffer_request_t *_aux = (xcb_glx_create_pbuffer_request_t *)_buffer; 3428 unsigned int xcb_buffer_len = 0; 3429 unsigned int xcb_block_len = 0; 3430 unsigned int xcb_pad = 0; 3431 unsigned int xcb_align_to = 0; 3432 3433 3434 xcb_block_len += sizeof(xcb_glx_create_pbuffer_request_t); 3435 xcb_tmp += xcb_block_len; 3436 xcb_buffer_len += xcb_block_len; 3437 xcb_block_len = 0; 3438 /* attribs */ 3439 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3440 xcb_tmp += xcb_block_len; 3441 xcb_align_to = ALIGNOF(uint32_t); 3442 /* insert padding */ 3443 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3444 xcb_buffer_len += xcb_block_len + xcb_pad; 3445 if (0 != xcb_pad) { 3446 xcb_tmp += xcb_pad; 3447 xcb_pad = 0; 3448 } 3449 xcb_block_len = 0; 3450 3451 return xcb_buffer_len; 3452 } 3453 3454 3455 /***************************************************************************** 3456 ** 3457 ** xcb_void_cookie_t xcb_glx_create_pbuffer_checked 3458 ** 3459 ** @param xcb_connection_t *c 3460 ** @param uint32_t screen 3461 ** @param xcb_glx_fbconfig_t fbconfig 3462 ** @param xcb_glx_pbuffer_t pbuffer 3463 ** @param uint32_t num_attribs 3464 ** @param const uint32_t *attribs 3465 ** @returns xcb_void_cookie_t 3466 ** 3467 *****************************************************************************/ 3468 3469 xcb_void_cookie_t 3470 xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, 3471 uint32_t screen /**< */, 3472 xcb_glx_fbconfig_t fbconfig /**< */, 3473 xcb_glx_pbuffer_t pbuffer /**< */, 3474 uint32_t num_attribs /**< */, 3475 const uint32_t *attribs /**< */) 3476 { 3477 static const xcb_protocol_request_t xcb_req = { 3478 /* count */ 4, 3479 /* ext */ &xcb_glx_id, 3480 /* opcode */ XCB_GLX_CREATE_PBUFFER, 3481 /* isvoid */ 1 3482 }; 3483 3484 struct iovec xcb_parts[6]; 3485 xcb_void_cookie_t xcb_ret; 3486 xcb_glx_create_pbuffer_request_t xcb_out; 3487 3488 xcb_out.screen = screen; 3489 xcb_out.fbconfig = fbconfig; 3490 xcb_out.pbuffer = pbuffer; 3491 xcb_out.num_attribs = num_attribs; 3492 3493 xcb_parts[2].iov_base = (char *) &xcb_out; 3494 xcb_parts[2].iov_len = sizeof(xcb_out); 3495 xcb_parts[3].iov_base = 0; 3496 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3497 /* uint32_t attribs */ 3498 xcb_parts[4].iov_base = (char *) attribs; 3499 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3500 xcb_parts[5].iov_base = 0; 3501 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3502 3503 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3504 return xcb_ret; 3505 } 3506 3507 3508 /***************************************************************************** 3509 ** 3510 ** xcb_void_cookie_t xcb_glx_create_pbuffer 3511 ** 3512 ** @param xcb_connection_t *c 3513 ** @param uint32_t screen 3514 ** @param xcb_glx_fbconfig_t fbconfig 3515 ** @param xcb_glx_pbuffer_t pbuffer 3516 ** @param uint32_t num_attribs 3517 ** @param const uint32_t *attribs 3518 ** @returns xcb_void_cookie_t 3519 ** 3520 *****************************************************************************/ 3521 3522 xcb_void_cookie_t 3523 xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, 3524 uint32_t screen /**< */, 3525 xcb_glx_fbconfig_t fbconfig /**< */, 3526 xcb_glx_pbuffer_t pbuffer /**< */, 3527 uint32_t num_attribs /**< */, 3528 const uint32_t *attribs /**< */) 3529 { 3530 static const xcb_protocol_request_t xcb_req = { 3531 /* count */ 4, 3532 /* ext */ &xcb_glx_id, 3533 /* opcode */ XCB_GLX_CREATE_PBUFFER, 3534 /* isvoid */ 1 3535 }; 3536 3537 struct iovec xcb_parts[6]; 3538 xcb_void_cookie_t xcb_ret; 3539 xcb_glx_create_pbuffer_request_t xcb_out; 3540 3541 xcb_out.screen = screen; 3542 xcb_out.fbconfig = fbconfig; 3543 xcb_out.pbuffer = pbuffer; 3544 xcb_out.num_attribs = num_attribs; 3545 3546 xcb_parts[2].iov_base = (char *) &xcb_out; 3547 xcb_parts[2].iov_len = sizeof(xcb_out); 3548 xcb_parts[3].iov_base = 0; 3549 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3550 /* uint32_t attribs */ 3551 xcb_parts[4].iov_base = (char *) attribs; 3552 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3553 xcb_parts[5].iov_base = 0; 3554 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3555 3556 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3557 return xcb_ret; 3558 } 3559 3560 3561 /***************************************************************************** 3562 ** 3563 ** xcb_void_cookie_t xcb_glx_destroy_pbuffer_checked 3564 ** 3565 ** @param xcb_connection_t *c 3566 ** @param xcb_glx_pbuffer_t pbuffer 3567 ** @returns xcb_void_cookie_t 3568 ** 3569 *****************************************************************************/ 3570 3571 xcb_void_cookie_t 3572 xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, 3573 xcb_glx_pbuffer_t pbuffer /**< */) 3574 { 3575 static const xcb_protocol_request_t xcb_req = { 3576 /* count */ 2, 3577 /* ext */ &xcb_glx_id, 3578 /* opcode */ XCB_GLX_DESTROY_PBUFFER, 3579 /* isvoid */ 1 3580 }; 3581 3582 struct iovec xcb_parts[4]; 3583 xcb_void_cookie_t xcb_ret; 3584 xcb_glx_destroy_pbuffer_request_t xcb_out; 3585 3586 xcb_out.pbuffer = pbuffer; 3587 3588 xcb_parts[2].iov_base = (char *) &xcb_out; 3589 xcb_parts[2].iov_len = sizeof(xcb_out); 3590 xcb_parts[3].iov_base = 0; 3591 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3592 3593 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3594 return xcb_ret; 3595 } 3596 3597 3598 /***************************************************************************** 3599 ** 3600 ** xcb_void_cookie_t xcb_glx_destroy_pbuffer 3601 ** 3602 ** @param xcb_connection_t *c 3603 ** @param xcb_glx_pbuffer_t pbuffer 3604 ** @returns xcb_void_cookie_t 3605 ** 3606 *****************************************************************************/ 3607 3608 xcb_void_cookie_t 3609 xcb_glx_destroy_pbuffer (xcb_connection_t *c /**< */, 3610 xcb_glx_pbuffer_t pbuffer /**< */) 3611 { 3612 static const xcb_protocol_request_t xcb_req = { 3613 /* count */ 2, 3614 /* ext */ &xcb_glx_id, 3615 /* opcode */ XCB_GLX_DESTROY_PBUFFER, 3616 /* isvoid */ 1 3617 }; 3618 3619 struct iovec xcb_parts[4]; 3620 xcb_void_cookie_t xcb_ret; 3621 xcb_glx_destroy_pbuffer_request_t xcb_out; 3622 3623 xcb_out.pbuffer = pbuffer; 3624 3625 xcb_parts[2].iov_base = (char *) &xcb_out; 3626 xcb_parts[2].iov_len = sizeof(xcb_out); 3627 xcb_parts[3].iov_base = 0; 3628 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3629 3630 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3631 return xcb_ret; 3632 } 3633 3634 int 3635 xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */) 3636 { 3637 char *xcb_tmp = (char *)_buffer; 3638 const xcb_glx_get_drawable_attributes_reply_t *_aux = (xcb_glx_get_drawable_attributes_reply_t *)_buffer; 3639 unsigned int xcb_buffer_len = 0; 3640 unsigned int xcb_block_len = 0; 3641 unsigned int xcb_pad = 0; 3642 unsigned int xcb_align_to = 0; 3643 3644 3645 xcb_block_len += sizeof(xcb_glx_get_drawable_attributes_reply_t); 3646 xcb_tmp += xcb_block_len; 3647 xcb_buffer_len += xcb_block_len; 3648 xcb_block_len = 0; 3649 /* attribs */ 3650 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3651 xcb_tmp += xcb_block_len; 3652 xcb_align_to = ALIGNOF(uint32_t); 3653 /* insert padding */ 3654 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3655 xcb_buffer_len += xcb_block_len + xcb_pad; 3656 if (0 != xcb_pad) { 3657 xcb_tmp += xcb_pad; 3658 xcb_pad = 0; 3659 } 3660 xcb_block_len = 0; 3661 3662 return xcb_buffer_len; 3663 } 3664 3665 3666 /***************************************************************************** 3667 ** 3668 ** xcb_glx_get_drawable_attributes_cookie_t xcb_glx_get_drawable_attributes 3669 ** 3670 ** @param xcb_connection_t *c 3671 ** @param xcb_glx_drawable_t drawable 3672 ** @returns xcb_glx_get_drawable_attributes_cookie_t 3673 ** 3674 *****************************************************************************/ 3675 3676 xcb_glx_get_drawable_attributes_cookie_t 3677 xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, 3678 xcb_glx_drawable_t drawable /**< */) 3679 { 3680 static const xcb_protocol_request_t xcb_req = { 3681 /* count */ 2, 3682 /* ext */ &xcb_glx_id, 3683 /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 3684 /* isvoid */ 0 3685 }; 3686 3687 struct iovec xcb_parts[4]; 3688 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 3689 xcb_glx_get_drawable_attributes_request_t xcb_out; 3690 3691 xcb_out.drawable = drawable; 3692 3693 xcb_parts[2].iov_base = (char *) &xcb_out; 3694 xcb_parts[2].iov_len = sizeof(xcb_out); 3695 xcb_parts[3].iov_base = 0; 3696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3697 3698 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3699 return xcb_ret; 3700 } 3701 3702 3703 /***************************************************************************** 3704 ** 3705 ** xcb_glx_get_drawable_attributes_cookie_t xcb_glx_get_drawable_attributes_unchecked 3706 ** 3707 ** @param xcb_connection_t *c 3708 ** @param xcb_glx_drawable_t drawable 3709 ** @returns xcb_glx_get_drawable_attributes_cookie_t 3710 ** 3711 *****************************************************************************/ 3712 3713 xcb_glx_get_drawable_attributes_cookie_t 3714 xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c /**< */, 3715 xcb_glx_drawable_t drawable /**< */) 3716 { 3717 static const xcb_protocol_request_t xcb_req = { 3718 /* count */ 2, 3719 /* ext */ &xcb_glx_id, 3720 /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 3721 /* isvoid */ 0 3722 }; 3723 3724 struct iovec xcb_parts[4]; 3725 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 3726 xcb_glx_get_drawable_attributes_request_t xcb_out; 3727 3728 xcb_out.drawable = drawable; 3729 3730 xcb_parts[2].iov_base = (char *) &xcb_out; 3731 xcb_parts[2].iov_len = sizeof(xcb_out); 3732 xcb_parts[3].iov_base = 0; 3733 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3734 3735 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3736 return xcb_ret; 3737 } 3738 3739 3740 /***************************************************************************** 3741 ** 3742 ** uint32_t * xcb_glx_get_drawable_attributes_attribs 3743 ** 3744 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3745 ** @returns uint32_t * 3746 ** 3747 *****************************************************************************/ 3748 3749 uint32_t * 3750 xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3751 { 3752 return (uint32_t *) (R + 1); 3753 } 3754 3755 3756 /***************************************************************************** 3757 ** 3758 ** int xcb_glx_get_drawable_attributes_attribs_length 3759 ** 3760 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3761 ** @returns int 3762 ** 3763 *****************************************************************************/ 3764 3765 int 3766 xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3767 { 3768 return (R->num_attribs * 2); 3769 } 3770 3771 3772 /***************************************************************************** 3773 ** 3774 ** xcb_generic_iterator_t xcb_glx_get_drawable_attributes_attribs_end 3775 ** 3776 ** @param const xcb_glx_get_drawable_attributes_reply_t *R 3777 ** @returns xcb_generic_iterator_t 3778 ** 3779 *****************************************************************************/ 3780 3781 xcb_generic_iterator_t 3782 xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) 3783 { 3784 xcb_generic_iterator_t i; 3785 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3786 i.rem = 0; 3787 i.index = (char *) i.data - (char *) R; 3788 return i; 3789 } 3790 3791 3792 /***************************************************************************** 3793 ** 3794 ** xcb_glx_get_drawable_attributes_reply_t * xcb_glx_get_drawable_attributes_reply 3795 ** 3796 ** @param xcb_connection_t *c 3797 ** @param xcb_glx_get_drawable_attributes_cookie_t cookie 3798 ** @param xcb_generic_error_t **e 3799 ** @returns xcb_glx_get_drawable_attributes_reply_t * 3800 ** 3801 *****************************************************************************/ 3802 3803 xcb_glx_get_drawable_attributes_reply_t * 3804 xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c /**< */, 3805 xcb_glx_get_drawable_attributes_cookie_t cookie /**< */, 3806 xcb_generic_error_t **e /**< */) 3807 { 3808 return (xcb_glx_get_drawable_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3809 } 3810 3811 int 3812 xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */) 3813 { 3814 char *xcb_tmp = (char *)_buffer; 3815 const xcb_glx_change_drawable_attributes_request_t *_aux = (xcb_glx_change_drawable_attributes_request_t *)_buffer; 3816 unsigned int xcb_buffer_len = 0; 3817 unsigned int xcb_block_len = 0; 3818 unsigned int xcb_pad = 0; 3819 unsigned int xcb_align_to = 0; 3820 3821 3822 xcb_block_len += sizeof(xcb_glx_change_drawable_attributes_request_t); 3823 xcb_tmp += xcb_block_len; 3824 xcb_buffer_len += xcb_block_len; 3825 xcb_block_len = 0; 3826 /* attribs */ 3827 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3828 xcb_tmp += xcb_block_len; 3829 xcb_align_to = ALIGNOF(uint32_t); 3830 /* insert padding */ 3831 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3832 xcb_buffer_len += xcb_block_len + xcb_pad; 3833 if (0 != xcb_pad) { 3834 xcb_tmp += xcb_pad; 3835 xcb_pad = 0; 3836 } 3837 xcb_block_len = 0; 3838 3839 return xcb_buffer_len; 3840 } 3841 3842 3843 /***************************************************************************** 3844 ** 3845 ** xcb_void_cookie_t xcb_glx_change_drawable_attributes_checked 3846 ** 3847 ** @param xcb_connection_t *c 3848 ** @param xcb_glx_drawable_t drawable 3849 ** @param uint32_t num_attribs 3850 ** @param const uint32_t *attribs 3851 ** @returns xcb_void_cookie_t 3852 ** 3853 *****************************************************************************/ 3854 3855 xcb_void_cookie_t 3856 xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, 3857 xcb_glx_drawable_t drawable /**< */, 3858 uint32_t num_attribs /**< */, 3859 const uint32_t *attribs /**< */) 3860 { 3861 static const xcb_protocol_request_t xcb_req = { 3862 /* count */ 4, 3863 /* ext */ &xcb_glx_id, 3864 /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 3865 /* isvoid */ 1 3866 }; 3867 3868 struct iovec xcb_parts[6]; 3869 xcb_void_cookie_t xcb_ret; 3870 xcb_glx_change_drawable_attributes_request_t xcb_out; 3871 3872 xcb_out.drawable = drawable; 3873 xcb_out.num_attribs = num_attribs; 3874 3875 xcb_parts[2].iov_base = (char *) &xcb_out; 3876 xcb_parts[2].iov_len = sizeof(xcb_out); 3877 xcb_parts[3].iov_base = 0; 3878 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3879 /* uint32_t attribs */ 3880 xcb_parts[4].iov_base = (char *) attribs; 3881 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3882 xcb_parts[5].iov_base = 0; 3883 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3884 3885 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3886 return xcb_ret; 3887 } 3888 3889 3890 /***************************************************************************** 3891 ** 3892 ** xcb_void_cookie_t xcb_glx_change_drawable_attributes 3893 ** 3894 ** @param xcb_connection_t *c 3895 ** @param xcb_glx_drawable_t drawable 3896 ** @param uint32_t num_attribs 3897 ** @param const uint32_t *attribs 3898 ** @returns xcb_void_cookie_t 3899 ** 3900 *****************************************************************************/ 3901 3902 xcb_void_cookie_t 3903 xcb_glx_change_drawable_attributes (xcb_connection_t *c /**< */, 3904 xcb_glx_drawable_t drawable /**< */, 3905 uint32_t num_attribs /**< */, 3906 const uint32_t *attribs /**< */) 3907 { 3908 static const xcb_protocol_request_t xcb_req = { 3909 /* count */ 4, 3910 /* ext */ &xcb_glx_id, 3911 /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 3912 /* isvoid */ 1 3913 }; 3914 3915 struct iovec xcb_parts[6]; 3916 xcb_void_cookie_t xcb_ret; 3917 xcb_glx_change_drawable_attributes_request_t xcb_out; 3918 3919 xcb_out.drawable = drawable; 3920 xcb_out.num_attribs = num_attribs; 3921 3922 xcb_parts[2].iov_base = (char *) &xcb_out; 3923 xcb_parts[2].iov_len = sizeof(xcb_out); 3924 xcb_parts[3].iov_base = 0; 3925 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3926 /* uint32_t attribs */ 3927 xcb_parts[4].iov_base = (char *) attribs; 3928 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3929 xcb_parts[5].iov_base = 0; 3930 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3931 3932 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3933 return xcb_ret; 3934 } 3935 3936 int 3937 xcb_glx_create_window_sizeof (const void *_buffer /**< */) 3938 { 3939 char *xcb_tmp = (char *)_buffer; 3940 const xcb_glx_create_window_request_t *_aux = (xcb_glx_create_window_request_t *)_buffer; 3941 unsigned int xcb_buffer_len = 0; 3942 unsigned int xcb_block_len = 0; 3943 unsigned int xcb_pad = 0; 3944 unsigned int xcb_align_to = 0; 3945 3946 3947 xcb_block_len += sizeof(xcb_glx_create_window_request_t); 3948 xcb_tmp += xcb_block_len; 3949 xcb_buffer_len += xcb_block_len; 3950 xcb_block_len = 0; 3951 /* attribs */ 3952 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3953 xcb_tmp += xcb_block_len; 3954 xcb_align_to = ALIGNOF(uint32_t); 3955 /* insert padding */ 3956 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3957 xcb_buffer_len += xcb_block_len + xcb_pad; 3958 if (0 != xcb_pad) { 3959 xcb_tmp += xcb_pad; 3960 xcb_pad = 0; 3961 } 3962 xcb_block_len = 0; 3963 3964 return xcb_buffer_len; 3965 } 3966 3967 3968 /***************************************************************************** 3969 ** 3970 ** xcb_void_cookie_t xcb_glx_create_window_checked 3971 ** 3972 ** @param xcb_connection_t *c 3973 ** @param uint32_t screen 3974 ** @param xcb_glx_fbconfig_t fbconfig 3975 ** @param xcb_window_t window 3976 ** @param xcb_glx_window_t glx_window 3977 ** @param uint32_t num_attribs 3978 ** @param const uint32_t *attribs 3979 ** @returns xcb_void_cookie_t 3980 ** 3981 *****************************************************************************/ 3982 3983 xcb_void_cookie_t 3984 xcb_glx_create_window_checked (xcb_connection_t *c /**< */, 3985 uint32_t screen /**< */, 3986 xcb_glx_fbconfig_t fbconfig /**< */, 3987 xcb_window_t window /**< */, 3988 xcb_glx_window_t glx_window /**< */, 3989 uint32_t num_attribs /**< */, 3990 const uint32_t *attribs /**< */) 3991 { 3992 static const xcb_protocol_request_t xcb_req = { 3993 /* count */ 4, 3994 /* ext */ &xcb_glx_id, 3995 /* opcode */ XCB_GLX_CREATE_WINDOW, 3996 /* isvoid */ 1 3997 }; 3998 3999 struct iovec xcb_parts[6]; 4000 xcb_void_cookie_t xcb_ret; 4001 xcb_glx_create_window_request_t xcb_out; 4002 4003 xcb_out.screen = screen; 4004 xcb_out.fbconfig = fbconfig; 4005 xcb_out.window = window; 4006 xcb_out.glx_window = glx_window; 4007 xcb_out.num_attribs = num_attribs; 4008 4009 xcb_parts[2].iov_base = (char *) &xcb_out; 4010 xcb_parts[2].iov_len = sizeof(xcb_out); 4011 xcb_parts[3].iov_base = 0; 4012 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4013 /* uint32_t attribs */ 4014 xcb_parts[4].iov_base = (char *) attribs; 4015 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4016 xcb_parts[5].iov_base = 0; 4017 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4018 4019 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4020 return xcb_ret; 4021 } 4022 4023 4024 /***************************************************************************** 4025 ** 4026 ** xcb_void_cookie_t xcb_glx_create_window 4027 ** 4028 ** @param xcb_connection_t *c 4029 ** @param uint32_t screen 4030 ** @param xcb_glx_fbconfig_t fbconfig 4031 ** @param xcb_window_t window 4032 ** @param xcb_glx_window_t glx_window 4033 ** @param uint32_t num_attribs 4034 ** @param const uint32_t *attribs 4035 ** @returns xcb_void_cookie_t 4036 ** 4037 *****************************************************************************/ 4038 4039 xcb_void_cookie_t 4040 xcb_glx_create_window (xcb_connection_t *c /**< */, 4041 uint32_t screen /**< */, 4042 xcb_glx_fbconfig_t fbconfig /**< */, 4043 xcb_window_t window /**< */, 4044 xcb_glx_window_t glx_window /**< */, 4045 uint32_t num_attribs /**< */, 4046 const uint32_t *attribs /**< */) 4047 { 4048 static const xcb_protocol_request_t xcb_req = { 4049 /* count */ 4, 4050 /* ext */ &xcb_glx_id, 4051 /* opcode */ XCB_GLX_CREATE_WINDOW, 4052 /* isvoid */ 1 4053 }; 4054 4055 struct iovec xcb_parts[6]; 4056 xcb_void_cookie_t xcb_ret; 4057 xcb_glx_create_window_request_t xcb_out; 4058 4059 xcb_out.screen = screen; 4060 xcb_out.fbconfig = fbconfig; 4061 xcb_out.window = window; 4062 xcb_out.glx_window = glx_window; 4063 xcb_out.num_attribs = num_attribs; 4064 4065 xcb_parts[2].iov_base = (char *) &xcb_out; 4066 xcb_parts[2].iov_len = sizeof(xcb_out); 4067 xcb_parts[3].iov_base = 0; 4068 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4069 /* uint32_t attribs */ 4070 xcb_parts[4].iov_base = (char *) attribs; 4071 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4072 xcb_parts[5].iov_base = 0; 4073 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4074 4075 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4076 return xcb_ret; 4077 } 4078 4079 4080 /***************************************************************************** 4081 ** 4082 ** xcb_void_cookie_t xcb_glx_delete_window_checked 4083 ** 4084 ** @param xcb_connection_t *c 4085 ** @param xcb_glx_window_t glxwindow 4086 ** @returns xcb_void_cookie_t 4087 ** 4088 *****************************************************************************/ 4089 4090 xcb_void_cookie_t 4091 xcb_glx_delete_window_checked (xcb_connection_t *c /**< */, 4092 xcb_glx_window_t glxwindow /**< */) 4093 { 4094 static const xcb_protocol_request_t xcb_req = { 4095 /* count */ 2, 4096 /* ext */ &xcb_glx_id, 4097 /* opcode */ XCB_GLX_DELETE_WINDOW, 4098 /* isvoid */ 1 4099 }; 4100 4101 struct iovec xcb_parts[4]; 4102 xcb_void_cookie_t xcb_ret; 4103 xcb_glx_delete_window_request_t xcb_out; 4104 4105 xcb_out.glxwindow = glxwindow; 4106 4107 xcb_parts[2].iov_base = (char *) &xcb_out; 4108 xcb_parts[2].iov_len = sizeof(xcb_out); 4109 xcb_parts[3].iov_base = 0; 4110 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4111 4112 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4113 return xcb_ret; 4114 } 4115 4116 4117 /***************************************************************************** 4118 ** 4119 ** xcb_void_cookie_t xcb_glx_delete_window 4120 ** 4121 ** @param xcb_connection_t *c 4122 ** @param xcb_glx_window_t glxwindow 4123 ** @returns xcb_void_cookie_t 4124 ** 4125 *****************************************************************************/ 4126 4127 xcb_void_cookie_t 4128 xcb_glx_delete_window (xcb_connection_t *c /**< */, 4129 xcb_glx_window_t glxwindow /**< */) 4130 { 4131 static const xcb_protocol_request_t xcb_req = { 4132 /* count */ 2, 4133 /* ext */ &xcb_glx_id, 4134 /* opcode */ XCB_GLX_DELETE_WINDOW, 4135 /* isvoid */ 1 4136 }; 4137 4138 struct iovec xcb_parts[4]; 4139 xcb_void_cookie_t xcb_ret; 4140 xcb_glx_delete_window_request_t xcb_out; 4141 4142 xcb_out.glxwindow = glxwindow; 4143 4144 xcb_parts[2].iov_base = (char *) &xcb_out; 4145 xcb_parts[2].iov_len = sizeof(xcb_out); 4146 xcb_parts[3].iov_base = 0; 4147 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4148 4149 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4150 return xcb_ret; 4151 } 4152 4153 int 4154 xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */) 4155 { 4156 char *xcb_tmp = (char *)_buffer; 4157 const xcb_glx_set_client_info_arb_request_t *_aux = (xcb_glx_set_client_info_arb_request_t *)_buffer; 4158 unsigned int xcb_buffer_len = 0; 4159 unsigned int xcb_block_len = 0; 4160 unsigned int xcb_pad = 0; 4161 unsigned int xcb_align_to = 0; 4162 4163 4164 xcb_block_len += sizeof(xcb_glx_set_client_info_arb_request_t); 4165 xcb_tmp += xcb_block_len; 4166 xcb_buffer_len += xcb_block_len; 4167 xcb_block_len = 0; 4168 /* gl_versions */ 4169 xcb_block_len += (_aux->num_versions * 2) * sizeof(uint32_t); 4170 xcb_tmp += xcb_block_len; 4171 xcb_align_to = ALIGNOF(uint32_t); 4172 /* insert padding */ 4173 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4174 xcb_buffer_len += xcb_block_len + xcb_pad; 4175 if (0 != xcb_pad) { 4176 xcb_tmp += xcb_pad; 4177 xcb_pad = 0; 4178 } 4179 xcb_block_len = 0; 4180 /* gl_extension_string */ 4181 xcb_block_len += _aux->gl_str_len * sizeof(char); 4182 xcb_tmp += xcb_block_len; 4183 xcb_align_to = ALIGNOF(char); 4184 /* insert padding */ 4185 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4186 xcb_buffer_len += xcb_block_len + xcb_pad; 4187 if (0 != xcb_pad) { 4188 xcb_tmp += xcb_pad; 4189 xcb_pad = 0; 4190 } 4191 xcb_block_len = 0; 4192 /* glx_extension_string */ 4193 xcb_block_len += _aux->glx_str_len * sizeof(char); 4194 xcb_tmp += xcb_block_len; 4195 xcb_align_to = ALIGNOF(char); 4196 /* insert padding */ 4197 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4198 xcb_buffer_len += xcb_block_len + xcb_pad; 4199 if (0 != xcb_pad) { 4200 xcb_tmp += xcb_pad; 4201 xcb_pad = 0; 4202 } 4203 xcb_block_len = 0; 4204 4205 return xcb_buffer_len; 4206 } 4207 4208 4209 /***************************************************************************** 4210 ** 4211 ** xcb_void_cookie_t xcb_glx_set_client_info_arb_checked 4212 ** 4213 ** @param xcb_connection_t *c 4214 ** @param uint32_t major_version 4215 ** @param uint32_t minor_version 4216 ** @param uint32_t num_versions 4217 ** @param uint32_t gl_str_len 4218 ** @param uint32_t glx_str_len 4219 ** @param const uint32_t *gl_versions 4220 ** @param const char *gl_extension_string 4221 ** @param const char *glx_extension_string 4222 ** @returns xcb_void_cookie_t 4223 ** 4224 *****************************************************************************/ 4225 4226 xcb_void_cookie_t 4227 xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, 4228 uint32_t major_version /**< */, 4229 uint32_t minor_version /**< */, 4230 uint32_t num_versions /**< */, 4231 uint32_t gl_str_len /**< */, 4232 uint32_t glx_str_len /**< */, 4233 const uint32_t *gl_versions /**< */, 4234 const char *gl_extension_string /**< */, 4235 const char *glx_extension_string /**< */) 4236 { 4237 static const xcb_protocol_request_t xcb_req = { 4238 /* count */ 8, 4239 /* ext */ &xcb_glx_id, 4240 /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, 4241 /* isvoid */ 1 4242 }; 4243 4244 struct iovec xcb_parts[10]; 4245 xcb_void_cookie_t xcb_ret; 4246 xcb_glx_set_client_info_arb_request_t xcb_out; 4247 4248 xcb_out.major_version = major_version; 4249 xcb_out.minor_version = minor_version; 4250 xcb_out.num_versions = num_versions; 4251 xcb_out.gl_str_len = gl_str_len; 4252 xcb_out.glx_str_len = glx_str_len; 4253 4254 xcb_parts[2].iov_base = (char *) &xcb_out; 4255 xcb_parts[2].iov_len = sizeof(xcb_out); 4256 xcb_parts[3].iov_base = 0; 4257 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4258 /* uint32_t gl_versions */ 4259 xcb_parts[4].iov_base = (char *) gl_versions; 4260 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 4261 xcb_parts[5].iov_base = 0; 4262 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4263 /* char gl_extension_string */ 4264 xcb_parts[6].iov_base = (char *) gl_extension_string; 4265 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4266 xcb_parts[7].iov_base = 0; 4267 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4268 /* char glx_extension_string */ 4269 xcb_parts[8].iov_base = (char *) glx_extension_string; 4270 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4271 xcb_parts[9].iov_base = 0; 4272 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4273 4274 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4275 return xcb_ret; 4276 } 4277 4278 4279 /***************************************************************************** 4280 ** 4281 ** xcb_void_cookie_t xcb_glx_set_client_info_arb 4282 ** 4283 ** @param xcb_connection_t *c 4284 ** @param uint32_t major_version 4285 ** @param uint32_t minor_version 4286 ** @param uint32_t num_versions 4287 ** @param uint32_t gl_str_len 4288 ** @param uint32_t glx_str_len 4289 ** @param const uint32_t *gl_versions 4290 ** @param const char *gl_extension_string 4291 ** @param const char *glx_extension_string 4292 ** @returns xcb_void_cookie_t 4293 ** 4294 *****************************************************************************/ 4295 4296 xcb_void_cookie_t 4297 xcb_glx_set_client_info_arb (xcb_connection_t *c /**< */, 4298 uint32_t major_version /**< */, 4299 uint32_t minor_version /**< */, 4300 uint32_t num_versions /**< */, 4301 uint32_t gl_str_len /**< */, 4302 uint32_t glx_str_len /**< */, 4303 const uint32_t *gl_versions /**< */, 4304 const char *gl_extension_string /**< */, 4305 const char *glx_extension_string /**< */) 4306 { 4307 static const xcb_protocol_request_t xcb_req = { 4308 /* count */ 8, 4309 /* ext */ &xcb_glx_id, 4310 /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, 4311 /* isvoid */ 1 4312 }; 4313 4314 struct iovec xcb_parts[10]; 4315 xcb_void_cookie_t xcb_ret; 4316 xcb_glx_set_client_info_arb_request_t xcb_out; 4317 4318 xcb_out.major_version = major_version; 4319 xcb_out.minor_version = minor_version; 4320 xcb_out.num_versions = num_versions; 4321 xcb_out.gl_str_len = gl_str_len; 4322 xcb_out.glx_str_len = glx_str_len; 4323 4324 xcb_parts[2].iov_base = (char *) &xcb_out; 4325 xcb_parts[2].iov_len = sizeof(xcb_out); 4326 xcb_parts[3].iov_base = 0; 4327 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4328 /* uint32_t gl_versions */ 4329 xcb_parts[4].iov_base = (char *) gl_versions; 4330 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 4331 xcb_parts[5].iov_base = 0; 4332 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4333 /* char gl_extension_string */ 4334 xcb_parts[6].iov_base = (char *) gl_extension_string; 4335 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4336 xcb_parts[7].iov_base = 0; 4337 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4338 /* char glx_extension_string */ 4339 xcb_parts[8].iov_base = (char *) glx_extension_string; 4340 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4341 xcb_parts[9].iov_base = 0; 4342 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4343 4344 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4345 return xcb_ret; 4346 } 4347 4348 int 4349 xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */) 4350 { 4351 char *xcb_tmp = (char *)_buffer; 4352 const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer; 4353 unsigned int xcb_buffer_len = 0; 4354 unsigned int xcb_block_len = 0; 4355 unsigned int xcb_pad = 0; 4356 unsigned int xcb_align_to = 0; 4357 4358 4359 xcb_block_len += sizeof(xcb_glx_create_context_attribs_arb_request_t); 4360 xcb_tmp += xcb_block_len; 4361 xcb_buffer_len += xcb_block_len; 4362 xcb_block_len = 0; 4363 /* attribs */ 4364 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 4365 xcb_tmp += xcb_block_len; 4366 xcb_align_to = ALIGNOF(uint32_t); 4367 /* insert padding */ 4368 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4369 xcb_buffer_len += xcb_block_len + xcb_pad; 4370 if (0 != xcb_pad) { 4371 xcb_tmp += xcb_pad; 4372 xcb_pad = 0; 4373 } 4374 xcb_block_len = 0; 4375 4376 return xcb_buffer_len; 4377 } 4378 4379 4380 /***************************************************************************** 4381 ** 4382 ** xcb_void_cookie_t xcb_glx_create_context_attribs_arb_checked 4383 ** 4384 ** @param xcb_connection_t *c 4385 ** @param xcb_glx_context_t context 4386 ** @param xcb_glx_fbconfig_t fbconfig 4387 ** @param uint32_t screen 4388 ** @param xcb_glx_context_t share_list 4389 ** @param uint8_t is_direct 4390 ** @param uint32_t num_attribs 4391 ** @param const uint32_t *attribs 4392 ** @returns xcb_void_cookie_t 4393 ** 4394 *****************************************************************************/ 4395 4396 xcb_void_cookie_t 4397 xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, 4398 xcb_glx_context_t context /**< */, 4399 xcb_glx_fbconfig_t fbconfig /**< */, 4400 uint32_t screen /**< */, 4401 xcb_glx_context_t share_list /**< */, 4402 uint8_t is_direct /**< */, 4403 uint32_t num_attribs /**< */, 4404 const uint32_t *attribs /**< */) 4405 { 4406 static const xcb_protocol_request_t xcb_req = { 4407 /* count */ 4, 4408 /* ext */ &xcb_glx_id, 4409 /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 4410 /* isvoid */ 1 4411 }; 4412 4413 struct iovec xcb_parts[6]; 4414 xcb_void_cookie_t xcb_ret; 4415 xcb_glx_create_context_attribs_arb_request_t xcb_out; 4416 4417 xcb_out.context = context; 4418 xcb_out.fbconfig = fbconfig; 4419 xcb_out.screen = screen; 4420 xcb_out.share_list = share_list; 4421 xcb_out.is_direct = is_direct; 4422 memset(xcb_out.pad0, 0, 3); 4423 xcb_out.num_attribs = num_attribs; 4424 4425 xcb_parts[2].iov_base = (char *) &xcb_out; 4426 xcb_parts[2].iov_len = sizeof(xcb_out); 4427 xcb_parts[3].iov_base = 0; 4428 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4429 /* uint32_t attribs */ 4430 xcb_parts[4].iov_base = (char *) attribs; 4431 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4432 xcb_parts[5].iov_base = 0; 4433 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4434 4435 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4436 return xcb_ret; 4437 } 4438 4439 4440 /***************************************************************************** 4441 ** 4442 ** xcb_void_cookie_t xcb_glx_create_context_attribs_arb 4443 ** 4444 ** @param xcb_connection_t *c 4445 ** @param xcb_glx_context_t context 4446 ** @param xcb_glx_fbconfig_t fbconfig 4447 ** @param uint32_t screen 4448 ** @param xcb_glx_context_t share_list 4449 ** @param uint8_t is_direct 4450 ** @param uint32_t num_attribs 4451 ** @param const uint32_t *attribs 4452 ** @returns xcb_void_cookie_t 4453 ** 4454 *****************************************************************************/ 4455 4456 xcb_void_cookie_t 4457 xcb_glx_create_context_attribs_arb (xcb_connection_t *c /**< */, 4458 xcb_glx_context_t context /**< */, 4459 xcb_glx_fbconfig_t fbconfig /**< */, 4460 uint32_t screen /**< */, 4461 xcb_glx_context_t share_list /**< */, 4462 uint8_t is_direct /**< */, 4463 uint32_t num_attribs /**< */, 4464 const uint32_t *attribs /**< */) 4465 { 4466 static const xcb_protocol_request_t xcb_req = { 4467 /* count */ 4, 4468 /* ext */ &xcb_glx_id, 4469 /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 4470 /* isvoid */ 1 4471 }; 4472 4473 struct iovec xcb_parts[6]; 4474 xcb_void_cookie_t xcb_ret; 4475 xcb_glx_create_context_attribs_arb_request_t xcb_out; 4476 4477 xcb_out.context = context; 4478 xcb_out.fbconfig = fbconfig; 4479 xcb_out.screen = screen; 4480 xcb_out.share_list = share_list; 4481 xcb_out.is_direct = is_direct; 4482 memset(xcb_out.pad0, 0, 3); 4483 xcb_out.num_attribs = num_attribs; 4484 4485 xcb_parts[2].iov_base = (char *) &xcb_out; 4486 xcb_parts[2].iov_len = sizeof(xcb_out); 4487 xcb_parts[3].iov_base = 0; 4488 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4489 /* uint32_t attribs */ 4490 xcb_parts[4].iov_base = (char *) attribs; 4491 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 4492 xcb_parts[5].iov_base = 0; 4493 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4494 4495 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4496 return xcb_ret; 4497 } 4498 4499 int 4500 xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */) 4501 { 4502 char *xcb_tmp = (char *)_buffer; 4503 const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer; 4504 unsigned int xcb_buffer_len = 0; 4505 unsigned int xcb_block_len = 0; 4506 unsigned int xcb_pad = 0; 4507 unsigned int xcb_align_to = 0; 4508 4509 4510 xcb_block_len += sizeof(xcb_glx_set_client_info_2arb_request_t); 4511 xcb_tmp += xcb_block_len; 4512 xcb_buffer_len += xcb_block_len; 4513 xcb_block_len = 0; 4514 /* gl_versions */ 4515 xcb_block_len += (_aux->num_versions * 3) * sizeof(uint32_t); 4516 xcb_tmp += xcb_block_len; 4517 xcb_align_to = ALIGNOF(uint32_t); 4518 /* insert padding */ 4519 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4520 xcb_buffer_len += xcb_block_len + xcb_pad; 4521 if (0 != xcb_pad) { 4522 xcb_tmp += xcb_pad; 4523 xcb_pad = 0; 4524 } 4525 xcb_block_len = 0; 4526 /* gl_extension_string */ 4527 xcb_block_len += _aux->gl_str_len * sizeof(char); 4528 xcb_tmp += xcb_block_len; 4529 xcb_align_to = ALIGNOF(char); 4530 /* insert padding */ 4531 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4532 xcb_buffer_len += xcb_block_len + xcb_pad; 4533 if (0 != xcb_pad) { 4534 xcb_tmp += xcb_pad; 4535 xcb_pad = 0; 4536 } 4537 xcb_block_len = 0; 4538 /* glx_extension_string */ 4539 xcb_block_len += _aux->glx_str_len * sizeof(char); 4540 xcb_tmp += xcb_block_len; 4541 xcb_align_to = ALIGNOF(char); 4542 /* insert padding */ 4543 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4544 xcb_buffer_len += xcb_block_len + xcb_pad; 4545 if (0 != xcb_pad) { 4546 xcb_tmp += xcb_pad; 4547 xcb_pad = 0; 4548 } 4549 xcb_block_len = 0; 4550 4551 return xcb_buffer_len; 4552 } 4553 4554 4555 /***************************************************************************** 4556 ** 4557 ** xcb_void_cookie_t xcb_glx_set_client_info_2arb_checked 4558 ** 4559 ** @param xcb_connection_t *c 4560 ** @param uint32_t major_version 4561 ** @param uint32_t minor_version 4562 ** @param uint32_t num_versions 4563 ** @param uint32_t gl_str_len 4564 ** @param uint32_t glx_str_len 4565 ** @param const uint32_t *gl_versions 4566 ** @param const char *gl_extension_string 4567 ** @param const char *glx_extension_string 4568 ** @returns xcb_void_cookie_t 4569 ** 4570 *****************************************************************************/ 4571 4572 xcb_void_cookie_t 4573 xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, 4574 uint32_t major_version /**< */, 4575 uint32_t minor_version /**< */, 4576 uint32_t num_versions /**< */, 4577 uint32_t gl_str_len /**< */, 4578 uint32_t glx_str_len /**< */, 4579 const uint32_t *gl_versions /**< */, 4580 const char *gl_extension_string /**< */, 4581 const char *glx_extension_string /**< */) 4582 { 4583 static const xcb_protocol_request_t xcb_req = { 4584 /* count */ 8, 4585 /* ext */ &xcb_glx_id, 4586 /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, 4587 /* isvoid */ 1 4588 }; 4589 4590 struct iovec xcb_parts[10]; 4591 xcb_void_cookie_t xcb_ret; 4592 xcb_glx_set_client_info_2arb_request_t xcb_out; 4593 4594 xcb_out.major_version = major_version; 4595 xcb_out.minor_version = minor_version; 4596 xcb_out.num_versions = num_versions; 4597 xcb_out.gl_str_len = gl_str_len; 4598 xcb_out.glx_str_len = glx_str_len; 4599 4600 xcb_parts[2].iov_base = (char *) &xcb_out; 4601 xcb_parts[2].iov_len = sizeof(xcb_out); 4602 xcb_parts[3].iov_base = 0; 4603 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4604 /* uint32_t gl_versions */ 4605 xcb_parts[4].iov_base = (char *) gl_versions; 4606 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 4607 xcb_parts[5].iov_base = 0; 4608 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4609 /* char gl_extension_string */ 4610 xcb_parts[6].iov_base = (char *) gl_extension_string; 4611 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4612 xcb_parts[7].iov_base = 0; 4613 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4614 /* char glx_extension_string */ 4615 xcb_parts[8].iov_base = (char *) glx_extension_string; 4616 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4617 xcb_parts[9].iov_base = 0; 4618 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4619 4620 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4621 return xcb_ret; 4622 } 4623 4624 4625 /***************************************************************************** 4626 ** 4627 ** xcb_void_cookie_t xcb_glx_set_client_info_2arb 4628 ** 4629 ** @param xcb_connection_t *c 4630 ** @param uint32_t major_version 4631 ** @param uint32_t minor_version 4632 ** @param uint32_t num_versions 4633 ** @param uint32_t gl_str_len 4634 ** @param uint32_t glx_str_len 4635 ** @param const uint32_t *gl_versions 4636 ** @param const char *gl_extension_string 4637 ** @param const char *glx_extension_string 4638 ** @returns xcb_void_cookie_t 4639 ** 4640 *****************************************************************************/ 4641 4642 xcb_void_cookie_t 4643 xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, 4644 uint32_t major_version /**< */, 4645 uint32_t minor_version /**< */, 4646 uint32_t num_versions /**< */, 4647 uint32_t gl_str_len /**< */, 4648 uint32_t glx_str_len /**< */, 4649 const uint32_t *gl_versions /**< */, 4650 const char *gl_extension_string /**< */, 4651 const char *glx_extension_string /**< */) 4652 { 4653 static const xcb_protocol_request_t xcb_req = { 4654 /* count */ 8, 4655 /* ext */ &xcb_glx_id, 4656 /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, 4657 /* isvoid */ 1 4658 }; 4659 4660 struct iovec xcb_parts[10]; 4661 xcb_void_cookie_t xcb_ret; 4662 xcb_glx_set_client_info_2arb_request_t xcb_out; 4663 4664 xcb_out.major_version = major_version; 4665 xcb_out.minor_version = minor_version; 4666 xcb_out.num_versions = num_versions; 4667 xcb_out.gl_str_len = gl_str_len; 4668 xcb_out.glx_str_len = glx_str_len; 4669 4670 xcb_parts[2].iov_base = (char *) &xcb_out; 4671 xcb_parts[2].iov_len = sizeof(xcb_out); 4672 xcb_parts[3].iov_base = 0; 4673 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4674 /* uint32_t gl_versions */ 4675 xcb_parts[4].iov_base = (char *) gl_versions; 4676 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 4677 xcb_parts[5].iov_base = 0; 4678 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4679 /* char gl_extension_string */ 4680 xcb_parts[6].iov_base = (char *) gl_extension_string; 4681 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 4682 xcb_parts[7].iov_base = 0; 4683 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4684 /* char glx_extension_string */ 4685 xcb_parts[8].iov_base = (char *) glx_extension_string; 4686 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 4687 xcb_parts[9].iov_base = 0; 4688 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 4689 4690 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4691 return xcb_ret; 4692 } 4693 4694 4695 /***************************************************************************** 4696 ** 4697 ** xcb_void_cookie_t xcb_glx_new_list_checked 4698 ** 4699 ** @param xcb_connection_t *c 4700 ** @param xcb_glx_context_tag_t context_tag 4701 ** @param uint32_t list 4702 ** @param uint32_t mode 4703 ** @returns xcb_void_cookie_t 4704 ** 4705 *****************************************************************************/ 4706 4707 xcb_void_cookie_t 4708 xcb_glx_new_list_checked (xcb_connection_t *c /**< */, 4709 xcb_glx_context_tag_t context_tag /**< */, 4710 uint32_t list /**< */, 4711 uint32_t mode /**< */) 4712 { 4713 static const xcb_protocol_request_t xcb_req = { 4714 /* count */ 2, 4715 /* ext */ &xcb_glx_id, 4716 /* opcode */ XCB_GLX_NEW_LIST, 4717 /* isvoid */ 1 4718 }; 4719 4720 struct iovec xcb_parts[4]; 4721 xcb_void_cookie_t xcb_ret; 4722 xcb_glx_new_list_request_t xcb_out; 4723 4724 xcb_out.context_tag = context_tag; 4725 xcb_out.list = list; 4726 xcb_out.mode = mode; 4727 4728 xcb_parts[2].iov_base = (char *) &xcb_out; 4729 xcb_parts[2].iov_len = sizeof(xcb_out); 4730 xcb_parts[3].iov_base = 0; 4731 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4732 4733 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4734 return xcb_ret; 4735 } 4736 4737 4738 /***************************************************************************** 4739 ** 4740 ** xcb_void_cookie_t xcb_glx_new_list 4741 ** 4742 ** @param xcb_connection_t *c 4743 ** @param xcb_glx_context_tag_t context_tag 4744 ** @param uint32_t list 4745 ** @param uint32_t mode 4746 ** @returns xcb_void_cookie_t 4747 ** 4748 *****************************************************************************/ 4749 4750 xcb_void_cookie_t 4751 xcb_glx_new_list (xcb_connection_t *c /**< */, 4752 xcb_glx_context_tag_t context_tag /**< */, 4753 uint32_t list /**< */, 4754 uint32_t mode /**< */) 4755 { 4756 static const xcb_protocol_request_t xcb_req = { 4757 /* count */ 2, 4758 /* ext */ &xcb_glx_id, 4759 /* opcode */ XCB_GLX_NEW_LIST, 4760 /* isvoid */ 1 4761 }; 4762 4763 struct iovec xcb_parts[4]; 4764 xcb_void_cookie_t xcb_ret; 4765 xcb_glx_new_list_request_t xcb_out; 4766 4767 xcb_out.context_tag = context_tag; 4768 xcb_out.list = list; 4769 xcb_out.mode = mode; 4770 4771 xcb_parts[2].iov_base = (char *) &xcb_out; 4772 xcb_parts[2].iov_len = sizeof(xcb_out); 4773 xcb_parts[3].iov_base = 0; 4774 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4775 4776 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4777 return xcb_ret; 4778 } 4779 4780 4781 /***************************************************************************** 4782 ** 4783 ** xcb_void_cookie_t xcb_glx_end_list_checked 4784 ** 4785 ** @param xcb_connection_t *c 4786 ** @param xcb_glx_context_tag_t context_tag 4787 ** @returns xcb_void_cookie_t 4788 ** 4789 *****************************************************************************/ 4790 4791 xcb_void_cookie_t 4792 xcb_glx_end_list_checked (xcb_connection_t *c /**< */, 4793 xcb_glx_context_tag_t context_tag /**< */) 4794 { 4795 static const xcb_protocol_request_t xcb_req = { 4796 /* count */ 2, 4797 /* ext */ &xcb_glx_id, 4798 /* opcode */ XCB_GLX_END_LIST, 4799 /* isvoid */ 1 4800 }; 4801 4802 struct iovec xcb_parts[4]; 4803 xcb_void_cookie_t xcb_ret; 4804 xcb_glx_end_list_request_t xcb_out; 4805 4806 xcb_out.context_tag = context_tag; 4807 4808 xcb_parts[2].iov_base = (char *) &xcb_out; 4809 xcb_parts[2].iov_len = sizeof(xcb_out); 4810 xcb_parts[3].iov_base = 0; 4811 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4812 4813 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4814 return xcb_ret; 4815 } 4816 4817 4818 /***************************************************************************** 4819 ** 4820 ** xcb_void_cookie_t xcb_glx_end_list 4821 ** 4822 ** @param xcb_connection_t *c 4823 ** @param xcb_glx_context_tag_t context_tag 4824 ** @returns xcb_void_cookie_t 4825 ** 4826 *****************************************************************************/ 4827 4828 xcb_void_cookie_t 4829 xcb_glx_end_list (xcb_connection_t *c /**< */, 4830 xcb_glx_context_tag_t context_tag /**< */) 4831 { 4832 static const xcb_protocol_request_t xcb_req = { 4833 /* count */ 2, 4834 /* ext */ &xcb_glx_id, 4835 /* opcode */ XCB_GLX_END_LIST, 4836 /* isvoid */ 1 4837 }; 4838 4839 struct iovec xcb_parts[4]; 4840 xcb_void_cookie_t xcb_ret; 4841 xcb_glx_end_list_request_t xcb_out; 4842 4843 xcb_out.context_tag = context_tag; 4844 4845 xcb_parts[2].iov_base = (char *) &xcb_out; 4846 xcb_parts[2].iov_len = sizeof(xcb_out); 4847 xcb_parts[3].iov_base = 0; 4848 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4849 4850 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4851 return xcb_ret; 4852 } 4853 4854 4855 /***************************************************************************** 4856 ** 4857 ** xcb_void_cookie_t xcb_glx_delete_lists_checked 4858 ** 4859 ** @param xcb_connection_t *c 4860 ** @param xcb_glx_context_tag_t context_tag 4861 ** @param uint32_t list 4862 ** @param int32_t range 4863 ** @returns xcb_void_cookie_t 4864 ** 4865 *****************************************************************************/ 4866 4867 xcb_void_cookie_t 4868 xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, 4869 xcb_glx_context_tag_t context_tag /**< */, 4870 uint32_t list /**< */, 4871 int32_t range /**< */) 4872 { 4873 static const xcb_protocol_request_t xcb_req = { 4874 /* count */ 2, 4875 /* ext */ &xcb_glx_id, 4876 /* opcode */ XCB_GLX_DELETE_LISTS, 4877 /* isvoid */ 1 4878 }; 4879 4880 struct iovec xcb_parts[4]; 4881 xcb_void_cookie_t xcb_ret; 4882 xcb_glx_delete_lists_request_t xcb_out; 4883 4884 xcb_out.context_tag = context_tag; 4885 xcb_out.list = list; 4886 xcb_out.range = range; 4887 4888 xcb_parts[2].iov_base = (char *) &xcb_out; 4889 xcb_parts[2].iov_len = sizeof(xcb_out); 4890 xcb_parts[3].iov_base = 0; 4891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4892 4893 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4894 return xcb_ret; 4895 } 4896 4897 4898 /***************************************************************************** 4899 ** 4900 ** xcb_void_cookie_t xcb_glx_delete_lists 4901 ** 4902 ** @param xcb_connection_t *c 4903 ** @param xcb_glx_context_tag_t context_tag 4904 ** @param uint32_t list 4905 ** @param int32_t range 4906 ** @returns xcb_void_cookie_t 4907 ** 4908 *****************************************************************************/ 4909 4910 xcb_void_cookie_t 4911 xcb_glx_delete_lists (xcb_connection_t *c /**< */, 4912 xcb_glx_context_tag_t context_tag /**< */, 4913 uint32_t list /**< */, 4914 int32_t range /**< */) 4915 { 4916 static const xcb_protocol_request_t xcb_req = { 4917 /* count */ 2, 4918 /* ext */ &xcb_glx_id, 4919 /* opcode */ XCB_GLX_DELETE_LISTS, 4920 /* isvoid */ 1 4921 }; 4922 4923 struct iovec xcb_parts[4]; 4924 xcb_void_cookie_t xcb_ret; 4925 xcb_glx_delete_lists_request_t xcb_out; 4926 4927 xcb_out.context_tag = context_tag; 4928 xcb_out.list = list; 4929 xcb_out.range = range; 4930 4931 xcb_parts[2].iov_base = (char *) &xcb_out; 4932 xcb_parts[2].iov_len = sizeof(xcb_out); 4933 xcb_parts[3].iov_base = 0; 4934 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4935 4936 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4937 return xcb_ret; 4938 } 4939 4940 4941 /***************************************************************************** 4942 ** 4943 ** xcb_glx_gen_lists_cookie_t xcb_glx_gen_lists 4944 ** 4945 ** @param xcb_connection_t *c 4946 ** @param xcb_glx_context_tag_t context_tag 4947 ** @param int32_t range 4948 ** @returns xcb_glx_gen_lists_cookie_t 4949 ** 4950 *****************************************************************************/ 4951 4952 xcb_glx_gen_lists_cookie_t 4953 xcb_glx_gen_lists (xcb_connection_t *c /**< */, 4954 xcb_glx_context_tag_t context_tag /**< */, 4955 int32_t range /**< */) 4956 { 4957 static const xcb_protocol_request_t xcb_req = { 4958 /* count */ 2, 4959 /* ext */ &xcb_glx_id, 4960 /* opcode */ XCB_GLX_GEN_LISTS, 4961 /* isvoid */ 0 4962 }; 4963 4964 struct iovec xcb_parts[4]; 4965 xcb_glx_gen_lists_cookie_t xcb_ret; 4966 xcb_glx_gen_lists_request_t xcb_out; 4967 4968 xcb_out.context_tag = context_tag; 4969 xcb_out.range = range; 4970 4971 xcb_parts[2].iov_base = (char *) &xcb_out; 4972 xcb_parts[2].iov_len = sizeof(xcb_out); 4973 xcb_parts[3].iov_base = 0; 4974 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4975 4976 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4977 return xcb_ret; 4978 } 4979 4980 4981 /***************************************************************************** 4982 ** 4983 ** xcb_glx_gen_lists_cookie_t xcb_glx_gen_lists_unchecked 4984 ** 4985 ** @param xcb_connection_t *c 4986 ** @param xcb_glx_context_tag_t context_tag 4987 ** @param int32_t range 4988 ** @returns xcb_glx_gen_lists_cookie_t 4989 ** 4990 *****************************************************************************/ 4991 4992 xcb_glx_gen_lists_cookie_t 4993 xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, 4994 xcb_glx_context_tag_t context_tag /**< */, 4995 int32_t range /**< */) 4996 { 4997 static const xcb_protocol_request_t xcb_req = { 4998 /* count */ 2, 4999 /* ext */ &xcb_glx_id, 5000 /* opcode */ XCB_GLX_GEN_LISTS, 5001 /* isvoid */ 0 5002 }; 5003 5004 struct iovec xcb_parts[4]; 5005 xcb_glx_gen_lists_cookie_t xcb_ret; 5006 xcb_glx_gen_lists_request_t xcb_out; 5007 5008 xcb_out.context_tag = context_tag; 5009 xcb_out.range = range; 5010 5011 xcb_parts[2].iov_base = (char *) &xcb_out; 5012 xcb_parts[2].iov_len = sizeof(xcb_out); 5013 xcb_parts[3].iov_base = 0; 5014 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5015 5016 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5017 return xcb_ret; 5018 } 5019 5020 5021 /***************************************************************************** 5022 ** 5023 ** xcb_glx_gen_lists_reply_t * xcb_glx_gen_lists_reply 5024 ** 5025 ** @param xcb_connection_t *c 5026 ** @param xcb_glx_gen_lists_cookie_t cookie 5027 ** @param xcb_generic_error_t **e 5028 ** @returns xcb_glx_gen_lists_reply_t * 5029 ** 5030 *****************************************************************************/ 5031 5032 xcb_glx_gen_lists_reply_t * 5033 xcb_glx_gen_lists_reply (xcb_connection_t *c /**< */, 5034 xcb_glx_gen_lists_cookie_t cookie /**< */, 5035 xcb_generic_error_t **e /**< */) 5036 { 5037 return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5038 } 5039 5040 5041 /***************************************************************************** 5042 ** 5043 ** xcb_void_cookie_t xcb_glx_feedback_buffer_checked 5044 ** 5045 ** @param xcb_connection_t *c 5046 ** @param xcb_glx_context_tag_t context_tag 5047 ** @param int32_t size 5048 ** @param int32_t type 5049 ** @returns xcb_void_cookie_t 5050 ** 5051 *****************************************************************************/ 5052 5053 xcb_void_cookie_t 5054 xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, 5055 xcb_glx_context_tag_t context_tag /**< */, 5056 int32_t size /**< */, 5057 int32_t type /**< */) 5058 { 5059 static const xcb_protocol_request_t xcb_req = { 5060 /* count */ 2, 5061 /* ext */ &xcb_glx_id, 5062 /* opcode */ XCB_GLX_FEEDBACK_BUFFER, 5063 /* isvoid */ 1 5064 }; 5065 5066 struct iovec xcb_parts[4]; 5067 xcb_void_cookie_t xcb_ret; 5068 xcb_glx_feedback_buffer_request_t xcb_out; 5069 5070 xcb_out.context_tag = context_tag; 5071 xcb_out.size = size; 5072 xcb_out.type = type; 5073 5074 xcb_parts[2].iov_base = (char *) &xcb_out; 5075 xcb_parts[2].iov_len = sizeof(xcb_out); 5076 xcb_parts[3].iov_base = 0; 5077 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5078 5079 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5080 return xcb_ret; 5081 } 5082 5083 5084 /***************************************************************************** 5085 ** 5086 ** xcb_void_cookie_t xcb_glx_feedback_buffer 5087 ** 5088 ** @param xcb_connection_t *c 5089 ** @param xcb_glx_context_tag_t context_tag 5090 ** @param int32_t size 5091 ** @param int32_t type 5092 ** @returns xcb_void_cookie_t 5093 ** 5094 *****************************************************************************/ 5095 5096 xcb_void_cookie_t 5097 xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, 5098 xcb_glx_context_tag_t context_tag /**< */, 5099 int32_t size /**< */, 5100 int32_t type /**< */) 5101 { 5102 static const xcb_protocol_request_t xcb_req = { 5103 /* count */ 2, 5104 /* ext */ &xcb_glx_id, 5105 /* opcode */ XCB_GLX_FEEDBACK_BUFFER, 5106 /* isvoid */ 1 5107 }; 5108 5109 struct iovec xcb_parts[4]; 5110 xcb_void_cookie_t xcb_ret; 5111 xcb_glx_feedback_buffer_request_t xcb_out; 5112 5113 xcb_out.context_tag = context_tag; 5114 xcb_out.size = size; 5115 xcb_out.type = type; 5116 5117 xcb_parts[2].iov_base = (char *) &xcb_out; 5118 xcb_parts[2].iov_len = sizeof(xcb_out); 5119 xcb_parts[3].iov_base = 0; 5120 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5121 5122 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5123 return xcb_ret; 5124 } 5125 5126 5127 /***************************************************************************** 5128 ** 5129 ** xcb_void_cookie_t xcb_glx_select_buffer_checked 5130 ** 5131 ** @param xcb_connection_t *c 5132 ** @param xcb_glx_context_tag_t context_tag 5133 ** @param int32_t size 5134 ** @returns xcb_void_cookie_t 5135 ** 5136 *****************************************************************************/ 5137 5138 xcb_void_cookie_t 5139 xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, 5140 xcb_glx_context_tag_t context_tag /**< */, 5141 int32_t size /**< */) 5142 { 5143 static const xcb_protocol_request_t xcb_req = { 5144 /* count */ 2, 5145 /* ext */ &xcb_glx_id, 5146 /* opcode */ XCB_GLX_SELECT_BUFFER, 5147 /* isvoid */ 1 5148 }; 5149 5150 struct iovec xcb_parts[4]; 5151 xcb_void_cookie_t xcb_ret; 5152 xcb_glx_select_buffer_request_t xcb_out; 5153 5154 xcb_out.context_tag = context_tag; 5155 xcb_out.size = size; 5156 5157 xcb_parts[2].iov_base = (char *) &xcb_out; 5158 xcb_parts[2].iov_len = sizeof(xcb_out); 5159 xcb_parts[3].iov_base = 0; 5160 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5161 5162 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5163 return xcb_ret; 5164 } 5165 5166 5167 /***************************************************************************** 5168 ** 5169 ** xcb_void_cookie_t xcb_glx_select_buffer 5170 ** 5171 ** @param xcb_connection_t *c 5172 ** @param xcb_glx_context_tag_t context_tag 5173 ** @param int32_t size 5174 ** @returns xcb_void_cookie_t 5175 ** 5176 *****************************************************************************/ 5177 5178 xcb_void_cookie_t 5179 xcb_glx_select_buffer (xcb_connection_t *c /**< */, 5180 xcb_glx_context_tag_t context_tag /**< */, 5181 int32_t size /**< */) 5182 { 5183 static const xcb_protocol_request_t xcb_req = { 5184 /* count */ 2, 5185 /* ext */ &xcb_glx_id, 5186 /* opcode */ XCB_GLX_SELECT_BUFFER, 5187 /* isvoid */ 1 5188 }; 5189 5190 struct iovec xcb_parts[4]; 5191 xcb_void_cookie_t xcb_ret; 5192 xcb_glx_select_buffer_request_t xcb_out; 5193 5194 xcb_out.context_tag = context_tag; 5195 xcb_out.size = size; 5196 5197 xcb_parts[2].iov_base = (char *) &xcb_out; 5198 xcb_parts[2].iov_len = sizeof(xcb_out); 5199 xcb_parts[3].iov_base = 0; 5200 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5201 5202 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5203 return xcb_ret; 5204 } 5205 5206 int 5207 xcb_glx_render_mode_sizeof (const void *_buffer /**< */) 5208 { 5209 char *xcb_tmp = (char *)_buffer; 5210 const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer; 5211 unsigned int xcb_buffer_len = 0; 5212 unsigned int xcb_block_len = 0; 5213 unsigned int xcb_pad = 0; 5214 unsigned int xcb_align_to = 0; 5215 5216 5217 xcb_block_len += sizeof(xcb_glx_render_mode_reply_t); 5218 xcb_tmp += xcb_block_len; 5219 xcb_buffer_len += xcb_block_len; 5220 xcb_block_len = 0; 5221 /* data */ 5222 xcb_block_len += _aux->n * sizeof(uint32_t); 5223 xcb_tmp += xcb_block_len; 5224 xcb_align_to = ALIGNOF(uint32_t); 5225 /* insert padding */ 5226 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5227 xcb_buffer_len += xcb_block_len + xcb_pad; 5228 if (0 != xcb_pad) { 5229 xcb_tmp += xcb_pad; 5230 xcb_pad = 0; 5231 } 5232 xcb_block_len = 0; 5233 5234 return xcb_buffer_len; 5235 } 5236 5237 5238 /***************************************************************************** 5239 ** 5240 ** xcb_glx_render_mode_cookie_t xcb_glx_render_mode 5241 ** 5242 ** @param xcb_connection_t *c 5243 ** @param xcb_glx_context_tag_t context_tag 5244 ** @param uint32_t mode 5245 ** @returns xcb_glx_render_mode_cookie_t 5246 ** 5247 *****************************************************************************/ 5248 5249 xcb_glx_render_mode_cookie_t 5250 xcb_glx_render_mode (xcb_connection_t *c /**< */, 5251 xcb_glx_context_tag_t context_tag /**< */, 5252 uint32_t mode /**< */) 5253 { 5254 static const xcb_protocol_request_t xcb_req = { 5255 /* count */ 2, 5256 /* ext */ &xcb_glx_id, 5257 /* opcode */ XCB_GLX_RENDER_MODE, 5258 /* isvoid */ 0 5259 }; 5260 5261 struct iovec xcb_parts[4]; 5262 xcb_glx_render_mode_cookie_t xcb_ret; 5263 xcb_glx_render_mode_request_t xcb_out; 5264 5265 xcb_out.context_tag = context_tag; 5266 xcb_out.mode = mode; 5267 5268 xcb_parts[2].iov_base = (char *) &xcb_out; 5269 xcb_parts[2].iov_len = sizeof(xcb_out); 5270 xcb_parts[3].iov_base = 0; 5271 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5272 5273 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5274 return xcb_ret; 5275 } 5276 5277 5278 /***************************************************************************** 5279 ** 5280 ** xcb_glx_render_mode_cookie_t xcb_glx_render_mode_unchecked 5281 ** 5282 ** @param xcb_connection_t *c 5283 ** @param xcb_glx_context_tag_t context_tag 5284 ** @param uint32_t mode 5285 ** @returns xcb_glx_render_mode_cookie_t 5286 ** 5287 *****************************************************************************/ 5288 5289 xcb_glx_render_mode_cookie_t 5290 xcb_glx_render_mode_unchecked (xcb_connection_t *c /**< */, 5291 xcb_glx_context_tag_t context_tag /**< */, 5292 uint32_t mode /**< */) 5293 { 5294 static const xcb_protocol_request_t xcb_req = { 5295 /* count */ 2, 5296 /* ext */ &xcb_glx_id, 5297 /* opcode */ XCB_GLX_RENDER_MODE, 5298 /* isvoid */ 0 5299 }; 5300 5301 struct iovec xcb_parts[4]; 5302 xcb_glx_render_mode_cookie_t xcb_ret; 5303 xcb_glx_render_mode_request_t xcb_out; 5304 5305 xcb_out.context_tag = context_tag; 5306 xcb_out.mode = mode; 5307 5308 xcb_parts[2].iov_base = (char *) &xcb_out; 5309 xcb_parts[2].iov_len = sizeof(xcb_out); 5310 xcb_parts[3].iov_base = 0; 5311 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5312 5313 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5314 return xcb_ret; 5315 } 5316 5317 5318 /***************************************************************************** 5319 ** 5320 ** uint32_t * xcb_glx_render_mode_data 5321 ** 5322 ** @param const xcb_glx_render_mode_reply_t *R 5323 ** @returns uint32_t * 5324 ** 5325 *****************************************************************************/ 5326 5327 uint32_t * 5328 xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R /**< */) 5329 { 5330 return (uint32_t *) (R + 1); 5331 } 5332 5333 5334 /***************************************************************************** 5335 ** 5336 ** int xcb_glx_render_mode_data_length 5337 ** 5338 ** @param const xcb_glx_render_mode_reply_t *R 5339 ** @returns int 5340 ** 5341 *****************************************************************************/ 5342 5343 int 5344 xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R /**< */) 5345 { 5346 return R->n; 5347 } 5348 5349 5350 /***************************************************************************** 5351 ** 5352 ** xcb_generic_iterator_t xcb_glx_render_mode_data_end 5353 ** 5354 ** @param const xcb_glx_render_mode_reply_t *R 5355 ** @returns xcb_generic_iterator_t 5356 ** 5357 *****************************************************************************/ 5358 5359 xcb_generic_iterator_t 5360 xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */) 5361 { 5362 xcb_generic_iterator_t i; 5363 i.data = ((uint32_t *) (R + 1)) + (R->n); 5364 i.rem = 0; 5365 i.index = (char *) i.data - (char *) R; 5366 return i; 5367 } 5368 5369 5370 /***************************************************************************** 5371 ** 5372 ** xcb_glx_render_mode_reply_t * xcb_glx_render_mode_reply 5373 ** 5374 ** @param xcb_connection_t *c 5375 ** @param xcb_glx_render_mode_cookie_t cookie 5376 ** @param xcb_generic_error_t **e 5377 ** @returns xcb_glx_render_mode_reply_t * 5378 ** 5379 *****************************************************************************/ 5380 5381 xcb_glx_render_mode_reply_t * 5382 xcb_glx_render_mode_reply (xcb_connection_t *c /**< */, 5383 xcb_glx_render_mode_cookie_t cookie /**< */, 5384 xcb_generic_error_t **e /**< */) 5385 { 5386 return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5387 } 5388 5389 5390 /***************************************************************************** 5391 ** 5392 ** xcb_glx_finish_cookie_t xcb_glx_finish 5393 ** 5394 ** @param xcb_connection_t *c 5395 ** @param xcb_glx_context_tag_t context_tag 5396 ** @returns xcb_glx_finish_cookie_t 5397 ** 5398 *****************************************************************************/ 5399 5400 xcb_glx_finish_cookie_t 5401 xcb_glx_finish (xcb_connection_t *c /**< */, 5402 xcb_glx_context_tag_t context_tag /**< */) 5403 { 5404 static const xcb_protocol_request_t xcb_req = { 5405 /* count */ 2, 5406 /* ext */ &xcb_glx_id, 5407 /* opcode */ XCB_GLX_FINISH, 5408 /* isvoid */ 0 5409 }; 5410 5411 struct iovec xcb_parts[4]; 5412 xcb_glx_finish_cookie_t xcb_ret; 5413 xcb_glx_finish_request_t xcb_out; 5414 5415 xcb_out.context_tag = context_tag; 5416 5417 xcb_parts[2].iov_base = (char *) &xcb_out; 5418 xcb_parts[2].iov_len = sizeof(xcb_out); 5419 xcb_parts[3].iov_base = 0; 5420 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5421 5422 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5423 return xcb_ret; 5424 } 5425 5426 5427 /***************************************************************************** 5428 ** 5429 ** xcb_glx_finish_cookie_t xcb_glx_finish_unchecked 5430 ** 5431 ** @param xcb_connection_t *c 5432 ** @param xcb_glx_context_tag_t context_tag 5433 ** @returns xcb_glx_finish_cookie_t 5434 ** 5435 *****************************************************************************/ 5436 5437 xcb_glx_finish_cookie_t 5438 xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, 5439 xcb_glx_context_tag_t context_tag /**< */) 5440 { 5441 static const xcb_protocol_request_t xcb_req = { 5442 /* count */ 2, 5443 /* ext */ &xcb_glx_id, 5444 /* opcode */ XCB_GLX_FINISH, 5445 /* isvoid */ 0 5446 }; 5447 5448 struct iovec xcb_parts[4]; 5449 xcb_glx_finish_cookie_t xcb_ret; 5450 xcb_glx_finish_request_t xcb_out; 5451 5452 xcb_out.context_tag = context_tag; 5453 5454 xcb_parts[2].iov_base = (char *) &xcb_out; 5455 xcb_parts[2].iov_len = sizeof(xcb_out); 5456 xcb_parts[3].iov_base = 0; 5457 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5458 5459 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5460 return xcb_ret; 5461 } 5462 5463 5464 /***************************************************************************** 5465 ** 5466 ** xcb_glx_finish_reply_t * xcb_glx_finish_reply 5467 ** 5468 ** @param xcb_connection_t *c 5469 ** @param xcb_glx_finish_cookie_t cookie 5470 ** @param xcb_generic_error_t **e 5471 ** @returns xcb_glx_finish_reply_t * 5472 ** 5473 *****************************************************************************/ 5474 5475 xcb_glx_finish_reply_t * 5476 xcb_glx_finish_reply (xcb_connection_t *c /**< */, 5477 xcb_glx_finish_cookie_t cookie /**< */, 5478 xcb_generic_error_t **e /**< */) 5479 { 5480 return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5481 } 5482 5483 5484 /***************************************************************************** 5485 ** 5486 ** xcb_void_cookie_t xcb_glx_pixel_storef_checked 5487 ** 5488 ** @param xcb_connection_t *c 5489 ** @param xcb_glx_context_tag_t context_tag 5490 ** @param uint32_t pname 5491 ** @param xcb_glx_float32_t datum 5492 ** @returns xcb_void_cookie_t 5493 ** 5494 *****************************************************************************/ 5495 5496 xcb_void_cookie_t 5497 xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, 5498 xcb_glx_context_tag_t context_tag /**< */, 5499 uint32_t pname /**< */, 5500 xcb_glx_float32_t datum /**< */) 5501 { 5502 static const xcb_protocol_request_t xcb_req = { 5503 /* count */ 2, 5504 /* ext */ &xcb_glx_id, 5505 /* opcode */ XCB_GLX_PIXEL_STOREF, 5506 /* isvoid */ 1 5507 }; 5508 5509 struct iovec xcb_parts[4]; 5510 xcb_void_cookie_t xcb_ret; 5511 xcb_glx_pixel_storef_request_t xcb_out; 5512 5513 xcb_out.context_tag = context_tag; 5514 xcb_out.pname = pname; 5515 xcb_out.datum = datum; 5516 5517 xcb_parts[2].iov_base = (char *) &xcb_out; 5518 xcb_parts[2].iov_len = sizeof(xcb_out); 5519 xcb_parts[3].iov_base = 0; 5520 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5521 5522 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5523 return xcb_ret; 5524 } 5525 5526 5527 /***************************************************************************** 5528 ** 5529 ** xcb_void_cookie_t xcb_glx_pixel_storef 5530 ** 5531 ** @param xcb_connection_t *c 5532 ** @param xcb_glx_context_tag_t context_tag 5533 ** @param uint32_t pname 5534 ** @param xcb_glx_float32_t datum 5535 ** @returns xcb_void_cookie_t 5536 ** 5537 *****************************************************************************/ 5538 5539 xcb_void_cookie_t 5540 xcb_glx_pixel_storef (xcb_connection_t *c /**< */, 5541 xcb_glx_context_tag_t context_tag /**< */, 5542 uint32_t pname /**< */, 5543 xcb_glx_float32_t datum /**< */) 5544 { 5545 static const xcb_protocol_request_t xcb_req = { 5546 /* count */ 2, 5547 /* ext */ &xcb_glx_id, 5548 /* opcode */ XCB_GLX_PIXEL_STOREF, 5549 /* isvoid */ 1 5550 }; 5551 5552 struct iovec xcb_parts[4]; 5553 xcb_void_cookie_t xcb_ret; 5554 xcb_glx_pixel_storef_request_t xcb_out; 5555 5556 xcb_out.context_tag = context_tag; 5557 xcb_out.pname = pname; 5558 xcb_out.datum = datum; 5559 5560 xcb_parts[2].iov_base = (char *) &xcb_out; 5561 xcb_parts[2].iov_len = sizeof(xcb_out); 5562 xcb_parts[3].iov_base = 0; 5563 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5564 5565 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5566 return xcb_ret; 5567 } 5568 5569 5570 /***************************************************************************** 5571 ** 5572 ** xcb_void_cookie_t xcb_glx_pixel_storei_checked 5573 ** 5574 ** @param xcb_connection_t *c 5575 ** @param xcb_glx_context_tag_t context_tag 5576 ** @param uint32_t pname 5577 ** @param int32_t datum 5578 ** @returns xcb_void_cookie_t 5579 ** 5580 *****************************************************************************/ 5581 5582 xcb_void_cookie_t 5583 xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, 5584 xcb_glx_context_tag_t context_tag /**< */, 5585 uint32_t pname /**< */, 5586 int32_t datum /**< */) 5587 { 5588 static const xcb_protocol_request_t xcb_req = { 5589 /* count */ 2, 5590 /* ext */ &xcb_glx_id, 5591 /* opcode */ XCB_GLX_PIXEL_STOREI, 5592 /* isvoid */ 1 5593 }; 5594 5595 struct iovec xcb_parts[4]; 5596 xcb_void_cookie_t xcb_ret; 5597 xcb_glx_pixel_storei_request_t xcb_out; 5598 5599 xcb_out.context_tag = context_tag; 5600 xcb_out.pname = pname; 5601 xcb_out.datum = datum; 5602 5603 xcb_parts[2].iov_base = (char *) &xcb_out; 5604 xcb_parts[2].iov_len = sizeof(xcb_out); 5605 xcb_parts[3].iov_base = 0; 5606 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5607 5608 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5609 return xcb_ret; 5610 } 5611 5612 5613 /***************************************************************************** 5614 ** 5615 ** xcb_void_cookie_t xcb_glx_pixel_storei 5616 ** 5617 ** @param xcb_connection_t *c 5618 ** @param xcb_glx_context_tag_t context_tag 5619 ** @param uint32_t pname 5620 ** @param int32_t datum 5621 ** @returns xcb_void_cookie_t 5622 ** 5623 *****************************************************************************/ 5624 5625 xcb_void_cookie_t 5626 xcb_glx_pixel_storei (xcb_connection_t *c /**< */, 5627 xcb_glx_context_tag_t context_tag /**< */, 5628 uint32_t pname /**< */, 5629 int32_t datum /**< */) 5630 { 5631 static const xcb_protocol_request_t xcb_req = { 5632 /* count */ 2, 5633 /* ext */ &xcb_glx_id, 5634 /* opcode */ XCB_GLX_PIXEL_STOREI, 5635 /* isvoid */ 1 5636 }; 5637 5638 struct iovec xcb_parts[4]; 5639 xcb_void_cookie_t xcb_ret; 5640 xcb_glx_pixel_storei_request_t xcb_out; 5641 5642 xcb_out.context_tag = context_tag; 5643 xcb_out.pname = pname; 5644 xcb_out.datum = datum; 5645 5646 xcb_parts[2].iov_base = (char *) &xcb_out; 5647 xcb_parts[2].iov_len = sizeof(xcb_out); 5648 xcb_parts[3].iov_base = 0; 5649 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5650 5651 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5652 return xcb_ret; 5653 } 5654 5655 int 5656 xcb_glx_read_pixels_sizeof (const void *_buffer /**< */) 5657 { 5658 char *xcb_tmp = (char *)_buffer; 5659 const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer; 5660 unsigned int xcb_buffer_len = 0; 5661 unsigned int xcb_block_len = 0; 5662 unsigned int xcb_pad = 0; 5663 unsigned int xcb_align_to = 0; 5664 5665 5666 xcb_block_len += sizeof(xcb_glx_read_pixels_reply_t); 5667 xcb_tmp += xcb_block_len; 5668 xcb_buffer_len += xcb_block_len; 5669 xcb_block_len = 0; 5670 /* data */ 5671 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 5672 xcb_tmp += xcb_block_len; 5673 xcb_align_to = ALIGNOF(uint8_t); 5674 /* insert padding */ 5675 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5676 xcb_buffer_len += xcb_block_len + xcb_pad; 5677 if (0 != xcb_pad) { 5678 xcb_tmp += xcb_pad; 5679 xcb_pad = 0; 5680 } 5681 xcb_block_len = 0; 5682 5683 return xcb_buffer_len; 5684 } 5685 5686 5687 /***************************************************************************** 5688 ** 5689 ** xcb_glx_read_pixels_cookie_t xcb_glx_read_pixels 5690 ** 5691 ** @param xcb_connection_t *c 5692 ** @param xcb_glx_context_tag_t context_tag 5693 ** @param int32_t x 5694 ** @param int32_t y 5695 ** @param int32_t width 5696 ** @param int32_t height 5697 ** @param uint32_t format 5698 ** @param uint32_t type 5699 ** @param uint8_t swap_bytes 5700 ** @param uint8_t lsb_first 5701 ** @returns xcb_glx_read_pixels_cookie_t 5702 ** 5703 *****************************************************************************/ 5704 5705 xcb_glx_read_pixels_cookie_t 5706 xcb_glx_read_pixels (xcb_connection_t *c /**< */, 5707 xcb_glx_context_tag_t context_tag /**< */, 5708 int32_t x /**< */, 5709 int32_t y /**< */, 5710 int32_t width /**< */, 5711 int32_t height /**< */, 5712 uint32_t format /**< */, 5713 uint32_t type /**< */, 5714 uint8_t swap_bytes /**< */, 5715 uint8_t lsb_first /**< */) 5716 { 5717 static const xcb_protocol_request_t xcb_req = { 5718 /* count */ 2, 5719 /* ext */ &xcb_glx_id, 5720 /* opcode */ XCB_GLX_READ_PIXELS, 5721 /* isvoid */ 0 5722 }; 5723 5724 struct iovec xcb_parts[4]; 5725 xcb_glx_read_pixels_cookie_t xcb_ret; 5726 xcb_glx_read_pixels_request_t xcb_out; 5727 5728 xcb_out.context_tag = context_tag; 5729 xcb_out.x = x; 5730 xcb_out.y = y; 5731 xcb_out.width = width; 5732 xcb_out.height = height; 5733 xcb_out.format = format; 5734 xcb_out.type = type; 5735 xcb_out.swap_bytes = swap_bytes; 5736 xcb_out.lsb_first = lsb_first; 5737 5738 xcb_parts[2].iov_base = (char *) &xcb_out; 5739 xcb_parts[2].iov_len = sizeof(xcb_out); 5740 xcb_parts[3].iov_base = 0; 5741 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5742 5743 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5744 return xcb_ret; 5745 } 5746 5747 5748 /***************************************************************************** 5749 ** 5750 ** xcb_glx_read_pixels_cookie_t xcb_glx_read_pixels_unchecked 5751 ** 5752 ** @param xcb_connection_t *c 5753 ** @param xcb_glx_context_tag_t context_tag 5754 ** @param int32_t x 5755 ** @param int32_t y 5756 ** @param int32_t width 5757 ** @param int32_t height 5758 ** @param uint32_t format 5759 ** @param uint32_t type 5760 ** @param uint8_t swap_bytes 5761 ** @param uint8_t lsb_first 5762 ** @returns xcb_glx_read_pixels_cookie_t 5763 ** 5764 *****************************************************************************/ 5765 5766 xcb_glx_read_pixels_cookie_t 5767 xcb_glx_read_pixels_unchecked (xcb_connection_t *c /**< */, 5768 xcb_glx_context_tag_t context_tag /**< */, 5769 int32_t x /**< */, 5770 int32_t y /**< */, 5771 int32_t width /**< */, 5772 int32_t height /**< */, 5773 uint32_t format /**< */, 5774 uint32_t type /**< */, 5775 uint8_t swap_bytes /**< */, 5776 uint8_t lsb_first /**< */) 5777 { 5778 static const xcb_protocol_request_t xcb_req = { 5779 /* count */ 2, 5780 /* ext */ &xcb_glx_id, 5781 /* opcode */ XCB_GLX_READ_PIXELS, 5782 /* isvoid */ 0 5783 }; 5784 5785 struct iovec xcb_parts[4]; 5786 xcb_glx_read_pixels_cookie_t xcb_ret; 5787 xcb_glx_read_pixels_request_t xcb_out; 5788 5789 xcb_out.context_tag = context_tag; 5790 xcb_out.x = x; 5791 xcb_out.y = y; 5792 xcb_out.width = width; 5793 xcb_out.height = height; 5794 xcb_out.format = format; 5795 xcb_out.type = type; 5796 xcb_out.swap_bytes = swap_bytes; 5797 xcb_out.lsb_first = lsb_first; 5798 5799 xcb_parts[2].iov_base = (char *) &xcb_out; 5800 xcb_parts[2].iov_len = sizeof(xcb_out); 5801 xcb_parts[3].iov_base = 0; 5802 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5803 5804 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5805 return xcb_ret; 5806 } 5807 5808 5809 /***************************************************************************** 5810 ** 5811 ** uint8_t * xcb_glx_read_pixels_data 5812 ** 5813 ** @param const xcb_glx_read_pixels_reply_t *R 5814 ** @returns uint8_t * 5815 ** 5816 *****************************************************************************/ 5817 5818 uint8_t * 5819 xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R /**< */) 5820 { 5821 return (uint8_t *) (R + 1); 5822 } 5823 5824 5825 /***************************************************************************** 5826 ** 5827 ** int xcb_glx_read_pixels_data_length 5828 ** 5829 ** @param const xcb_glx_read_pixels_reply_t *R 5830 ** @returns int 5831 ** 5832 *****************************************************************************/ 5833 5834 int 5835 xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R /**< */) 5836 { 5837 return (R->length * 4); 5838 } 5839 5840 5841 /***************************************************************************** 5842 ** 5843 ** xcb_generic_iterator_t xcb_glx_read_pixels_data_end 5844 ** 5845 ** @param const xcb_glx_read_pixels_reply_t *R 5846 ** @returns xcb_generic_iterator_t 5847 ** 5848 *****************************************************************************/ 5849 5850 xcb_generic_iterator_t 5851 xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */) 5852 { 5853 xcb_generic_iterator_t i; 5854 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 5855 i.rem = 0; 5856 i.index = (char *) i.data - (char *) R; 5857 return i; 5858 } 5859 5860 5861 /***************************************************************************** 5862 ** 5863 ** xcb_glx_read_pixels_reply_t * xcb_glx_read_pixels_reply 5864 ** 5865 ** @param xcb_connection_t *c 5866 ** @param xcb_glx_read_pixels_cookie_t cookie 5867 ** @param xcb_generic_error_t **e 5868 ** @returns xcb_glx_read_pixels_reply_t * 5869 ** 5870 *****************************************************************************/ 5871 5872 xcb_glx_read_pixels_reply_t * 5873 xcb_glx_read_pixels_reply (xcb_connection_t *c /**< */, 5874 xcb_glx_read_pixels_cookie_t cookie /**< */, 5875 xcb_generic_error_t **e /**< */) 5876 { 5877 return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5878 } 5879 5880 int 5881 xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */) 5882 { 5883 char *xcb_tmp = (char *)_buffer; 5884 const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer; 5885 unsigned int xcb_buffer_len = 0; 5886 unsigned int xcb_block_len = 0; 5887 unsigned int xcb_pad = 0; 5888 unsigned int xcb_align_to = 0; 5889 5890 5891 xcb_block_len += sizeof(xcb_glx_get_booleanv_reply_t); 5892 xcb_tmp += xcb_block_len; 5893 xcb_buffer_len += xcb_block_len; 5894 xcb_block_len = 0; 5895 /* data */ 5896 xcb_block_len += _aux->n * sizeof(uint8_t); 5897 xcb_tmp += xcb_block_len; 5898 xcb_align_to = ALIGNOF(uint8_t); 5899 /* insert padding */ 5900 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5901 xcb_buffer_len += xcb_block_len + xcb_pad; 5902 if (0 != xcb_pad) { 5903 xcb_tmp += xcb_pad; 5904 xcb_pad = 0; 5905 } 5906 xcb_block_len = 0; 5907 5908 return xcb_buffer_len; 5909 } 5910 5911 5912 /***************************************************************************** 5913 ** 5914 ** xcb_glx_get_booleanv_cookie_t xcb_glx_get_booleanv 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 (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, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5948 return xcb_ret; 5949 } 5950 5951 5952 /***************************************************************************** 5953 ** 5954 ** xcb_glx_get_booleanv_cookie_t xcb_glx_get_booleanv_unchecked 5955 ** 5956 ** @param xcb_connection_t *c 5957 ** @param xcb_glx_context_tag_t context_tag 5958 ** @param int32_t pname 5959 ** @returns xcb_glx_get_booleanv_cookie_t 5960 ** 5961 *****************************************************************************/ 5962 5963 xcb_glx_get_booleanv_cookie_t 5964 xcb_glx_get_booleanv_unchecked (xcb_connection_t *c /**< */, 5965 xcb_glx_context_tag_t context_tag /**< */, 5966 int32_t pname /**< */) 5967 { 5968 static const xcb_protocol_request_t xcb_req = { 5969 /* count */ 2, 5970 /* ext */ &xcb_glx_id, 5971 /* opcode */ XCB_GLX_GET_BOOLEANV, 5972 /* isvoid */ 0 5973 }; 5974 5975 struct iovec xcb_parts[4]; 5976 xcb_glx_get_booleanv_cookie_t xcb_ret; 5977 xcb_glx_get_booleanv_request_t xcb_out; 5978 5979 xcb_out.context_tag = context_tag; 5980 xcb_out.pname = pname; 5981 5982 xcb_parts[2].iov_base = (char *) &xcb_out; 5983 xcb_parts[2].iov_len = sizeof(xcb_out); 5984 xcb_parts[3].iov_base = 0; 5985 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5986 5987 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5988 return xcb_ret; 5989 } 5990 5991 5992 /***************************************************************************** 5993 ** 5994 ** uint8_t * xcb_glx_get_booleanv_data 5995 ** 5996 ** @param const xcb_glx_get_booleanv_reply_t *R 5997 ** @returns uint8_t * 5998 ** 5999 *****************************************************************************/ 6000 6001 uint8_t * 6002 xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R /**< */) 6003 { 6004 return (uint8_t *) (R + 1); 6005 } 6006 6007 6008 /***************************************************************************** 6009 ** 6010 ** int xcb_glx_get_booleanv_data_length 6011 ** 6012 ** @param const xcb_glx_get_booleanv_reply_t *R 6013 ** @returns int 6014 ** 6015 *****************************************************************************/ 6016 6017 int 6018 xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R /**< */) 6019 { 6020 return R->n; 6021 } 6022 6023 6024 /***************************************************************************** 6025 ** 6026 ** xcb_generic_iterator_t xcb_glx_get_booleanv_data_end 6027 ** 6028 ** @param const xcb_glx_get_booleanv_reply_t *R 6029 ** @returns xcb_generic_iterator_t 6030 ** 6031 *****************************************************************************/ 6032 6033 xcb_generic_iterator_t 6034 xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */) 6035 { 6036 xcb_generic_iterator_t i; 6037 i.data = ((uint8_t *) (R + 1)) + (R->n); 6038 i.rem = 0; 6039 i.index = (char *) i.data - (char *) R; 6040 return i; 6041 } 6042 6043 6044 /***************************************************************************** 6045 ** 6046 ** xcb_glx_get_booleanv_reply_t * xcb_glx_get_booleanv_reply 6047 ** 6048 ** @param xcb_connection_t *c 6049 ** @param xcb_glx_get_booleanv_cookie_t cookie 6050 ** @param xcb_generic_error_t **e 6051 ** @returns xcb_glx_get_booleanv_reply_t * 6052 ** 6053 *****************************************************************************/ 6054 6055 xcb_glx_get_booleanv_reply_t * 6056 xcb_glx_get_booleanv_reply (xcb_connection_t *c /**< */, 6057 xcb_glx_get_booleanv_cookie_t cookie /**< */, 6058 xcb_generic_error_t **e /**< */) 6059 { 6060 return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6061 } 6062 6063 int 6064 xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */) 6065 { 6066 char *xcb_tmp = (char *)_buffer; 6067 const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer; 6068 unsigned int xcb_buffer_len = 0; 6069 unsigned int xcb_block_len = 0; 6070 unsigned int xcb_pad = 0; 6071 unsigned int xcb_align_to = 0; 6072 6073 6074 xcb_block_len += sizeof(xcb_glx_get_clip_plane_reply_t); 6075 xcb_tmp += xcb_block_len; 6076 xcb_buffer_len += xcb_block_len; 6077 xcb_block_len = 0; 6078 /* data */ 6079 xcb_block_len += (_aux->length / 2) * sizeof(xcb_glx_float64_t); 6080 xcb_tmp += xcb_block_len; 6081 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6082 /* insert padding */ 6083 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6084 xcb_buffer_len += xcb_block_len + xcb_pad; 6085 if (0 != xcb_pad) { 6086 xcb_tmp += xcb_pad; 6087 xcb_pad = 0; 6088 } 6089 xcb_block_len = 0; 6090 6091 return xcb_buffer_len; 6092 } 6093 6094 6095 /***************************************************************************** 6096 ** 6097 ** xcb_glx_get_clip_plane_cookie_t xcb_glx_get_clip_plane 6098 ** 6099 ** @param xcb_connection_t *c 6100 ** @param xcb_glx_context_tag_t context_tag 6101 ** @param int32_t plane 6102 ** @returns xcb_glx_get_clip_plane_cookie_t 6103 ** 6104 *****************************************************************************/ 6105 6106 xcb_glx_get_clip_plane_cookie_t 6107 xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, 6108 xcb_glx_context_tag_t context_tag /**< */, 6109 int32_t plane /**< */) 6110 { 6111 static const xcb_protocol_request_t xcb_req = { 6112 /* count */ 2, 6113 /* ext */ &xcb_glx_id, 6114 /* opcode */ XCB_GLX_GET_CLIP_PLANE, 6115 /* isvoid */ 0 6116 }; 6117 6118 struct iovec xcb_parts[4]; 6119 xcb_glx_get_clip_plane_cookie_t xcb_ret; 6120 xcb_glx_get_clip_plane_request_t xcb_out; 6121 6122 xcb_out.context_tag = context_tag; 6123 xcb_out.plane = plane; 6124 6125 xcb_parts[2].iov_base = (char *) &xcb_out; 6126 xcb_parts[2].iov_len = sizeof(xcb_out); 6127 xcb_parts[3].iov_base = 0; 6128 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6129 6130 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6131 return xcb_ret; 6132 } 6133 6134 6135 /***************************************************************************** 6136 ** 6137 ** xcb_glx_get_clip_plane_cookie_t xcb_glx_get_clip_plane_unchecked 6138 ** 6139 ** @param xcb_connection_t *c 6140 ** @param xcb_glx_context_tag_t context_tag 6141 ** @param int32_t plane 6142 ** @returns xcb_glx_get_clip_plane_cookie_t 6143 ** 6144 *****************************************************************************/ 6145 6146 xcb_glx_get_clip_plane_cookie_t 6147 xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c /**< */, 6148 xcb_glx_context_tag_t context_tag /**< */, 6149 int32_t plane /**< */) 6150 { 6151 static const xcb_protocol_request_t xcb_req = { 6152 /* count */ 2, 6153 /* ext */ &xcb_glx_id, 6154 /* opcode */ XCB_GLX_GET_CLIP_PLANE, 6155 /* isvoid */ 0 6156 }; 6157 6158 struct iovec xcb_parts[4]; 6159 xcb_glx_get_clip_plane_cookie_t xcb_ret; 6160 xcb_glx_get_clip_plane_request_t xcb_out; 6161 6162 xcb_out.context_tag = context_tag; 6163 xcb_out.plane = plane; 6164 6165 xcb_parts[2].iov_base = (char *) &xcb_out; 6166 xcb_parts[2].iov_len = sizeof(xcb_out); 6167 xcb_parts[3].iov_base = 0; 6168 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6169 6170 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6171 return xcb_ret; 6172 } 6173 6174 6175 /***************************************************************************** 6176 ** 6177 ** xcb_glx_float64_t * xcb_glx_get_clip_plane_data 6178 ** 6179 ** @param const xcb_glx_get_clip_plane_reply_t *R 6180 ** @returns xcb_glx_float64_t * 6181 ** 6182 *****************************************************************************/ 6183 6184 xcb_glx_float64_t * 6185 xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6186 { 6187 return (xcb_glx_float64_t *) (R + 1); 6188 } 6189 6190 6191 /***************************************************************************** 6192 ** 6193 ** int xcb_glx_get_clip_plane_data_length 6194 ** 6195 ** @param const xcb_glx_get_clip_plane_reply_t *R 6196 ** @returns int 6197 ** 6198 *****************************************************************************/ 6199 6200 int 6201 xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6202 { 6203 return (R->length / 2); 6204 } 6205 6206 6207 /***************************************************************************** 6208 ** 6209 ** xcb_generic_iterator_t xcb_glx_get_clip_plane_data_end 6210 ** 6211 ** @param const xcb_glx_get_clip_plane_reply_t *R 6212 ** @returns xcb_generic_iterator_t 6213 ** 6214 *****************************************************************************/ 6215 6216 xcb_generic_iterator_t 6217 xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< */) 6218 { 6219 xcb_generic_iterator_t i; 6220 i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2)); 6221 i.rem = 0; 6222 i.index = (char *) i.data - (char *) R; 6223 return i; 6224 } 6225 6226 6227 /***************************************************************************** 6228 ** 6229 ** xcb_glx_get_clip_plane_reply_t * xcb_glx_get_clip_plane_reply 6230 ** 6231 ** @param xcb_connection_t *c 6232 ** @param xcb_glx_get_clip_plane_cookie_t cookie 6233 ** @param xcb_generic_error_t **e 6234 ** @returns xcb_glx_get_clip_plane_reply_t * 6235 ** 6236 *****************************************************************************/ 6237 6238 xcb_glx_get_clip_plane_reply_t * 6239 xcb_glx_get_clip_plane_reply (xcb_connection_t *c /**< */, 6240 xcb_glx_get_clip_plane_cookie_t cookie /**< */, 6241 xcb_generic_error_t **e /**< */) 6242 { 6243 return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6244 } 6245 6246 int 6247 xcb_glx_get_doublev_sizeof (const void *_buffer /**< */) 6248 { 6249 char *xcb_tmp = (char *)_buffer; 6250 const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer; 6251 unsigned int xcb_buffer_len = 0; 6252 unsigned int xcb_block_len = 0; 6253 unsigned int xcb_pad = 0; 6254 unsigned int xcb_align_to = 0; 6255 6256 6257 xcb_block_len += sizeof(xcb_glx_get_doublev_reply_t); 6258 xcb_tmp += xcb_block_len; 6259 xcb_buffer_len += xcb_block_len; 6260 xcb_block_len = 0; 6261 /* data */ 6262 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 6263 xcb_tmp += xcb_block_len; 6264 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6265 /* insert padding */ 6266 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6267 xcb_buffer_len += xcb_block_len + xcb_pad; 6268 if (0 != xcb_pad) { 6269 xcb_tmp += xcb_pad; 6270 xcb_pad = 0; 6271 } 6272 xcb_block_len = 0; 6273 6274 return xcb_buffer_len; 6275 } 6276 6277 6278 /***************************************************************************** 6279 ** 6280 ** xcb_glx_get_doublev_cookie_t xcb_glx_get_doublev 6281 ** 6282 ** @param xcb_connection_t *c 6283 ** @param xcb_glx_context_tag_t context_tag 6284 ** @param uint32_t pname 6285 ** @returns xcb_glx_get_doublev_cookie_t 6286 ** 6287 *****************************************************************************/ 6288 6289 xcb_glx_get_doublev_cookie_t 6290 xcb_glx_get_doublev (xcb_connection_t *c /**< */, 6291 xcb_glx_context_tag_t context_tag /**< */, 6292 uint32_t pname /**< */) 6293 { 6294 static const xcb_protocol_request_t xcb_req = { 6295 /* count */ 2, 6296 /* ext */ &xcb_glx_id, 6297 /* opcode */ XCB_GLX_GET_DOUBLEV, 6298 /* isvoid */ 0 6299 }; 6300 6301 struct iovec xcb_parts[4]; 6302 xcb_glx_get_doublev_cookie_t xcb_ret; 6303 xcb_glx_get_doublev_request_t xcb_out; 6304 6305 xcb_out.context_tag = context_tag; 6306 xcb_out.pname = pname; 6307 6308 xcb_parts[2].iov_base = (char *) &xcb_out; 6309 xcb_parts[2].iov_len = sizeof(xcb_out); 6310 xcb_parts[3].iov_base = 0; 6311 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6312 6313 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6314 return xcb_ret; 6315 } 6316 6317 6318 /***************************************************************************** 6319 ** 6320 ** xcb_glx_get_doublev_cookie_t xcb_glx_get_doublev_unchecked 6321 ** 6322 ** @param xcb_connection_t *c 6323 ** @param xcb_glx_context_tag_t context_tag 6324 ** @param uint32_t pname 6325 ** @returns xcb_glx_get_doublev_cookie_t 6326 ** 6327 *****************************************************************************/ 6328 6329 xcb_glx_get_doublev_cookie_t 6330 xcb_glx_get_doublev_unchecked (xcb_connection_t *c /**< */, 6331 xcb_glx_context_tag_t context_tag /**< */, 6332 uint32_t pname /**< */) 6333 { 6334 static const xcb_protocol_request_t xcb_req = { 6335 /* count */ 2, 6336 /* ext */ &xcb_glx_id, 6337 /* opcode */ XCB_GLX_GET_DOUBLEV, 6338 /* isvoid */ 0 6339 }; 6340 6341 struct iovec xcb_parts[4]; 6342 xcb_glx_get_doublev_cookie_t xcb_ret; 6343 xcb_glx_get_doublev_request_t xcb_out; 6344 6345 xcb_out.context_tag = context_tag; 6346 xcb_out.pname = pname; 6347 6348 xcb_parts[2].iov_base = (char *) &xcb_out; 6349 xcb_parts[2].iov_len = sizeof(xcb_out); 6350 xcb_parts[3].iov_base = 0; 6351 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6352 6353 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6354 return xcb_ret; 6355 } 6356 6357 6358 /***************************************************************************** 6359 ** 6360 ** xcb_glx_float64_t * xcb_glx_get_doublev_data 6361 ** 6362 ** @param const xcb_glx_get_doublev_reply_t *R 6363 ** @returns xcb_glx_float64_t * 6364 ** 6365 *****************************************************************************/ 6366 6367 xcb_glx_float64_t * 6368 xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R /**< */) 6369 { 6370 return (xcb_glx_float64_t *) (R + 1); 6371 } 6372 6373 6374 /***************************************************************************** 6375 ** 6376 ** int xcb_glx_get_doublev_data_length 6377 ** 6378 ** @param const xcb_glx_get_doublev_reply_t *R 6379 ** @returns int 6380 ** 6381 *****************************************************************************/ 6382 6383 int 6384 xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R /**< */) 6385 { 6386 return R->n; 6387 } 6388 6389 6390 /***************************************************************************** 6391 ** 6392 ** xcb_generic_iterator_t xcb_glx_get_doublev_data_end 6393 ** 6394 ** @param const xcb_glx_get_doublev_reply_t *R 6395 ** @returns xcb_generic_iterator_t 6396 ** 6397 *****************************************************************************/ 6398 6399 xcb_generic_iterator_t 6400 xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */) 6401 { 6402 xcb_generic_iterator_t i; 6403 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 6404 i.rem = 0; 6405 i.index = (char *) i.data - (char *) R; 6406 return i; 6407 } 6408 6409 6410 /***************************************************************************** 6411 ** 6412 ** xcb_glx_get_doublev_reply_t * xcb_glx_get_doublev_reply 6413 ** 6414 ** @param xcb_connection_t *c 6415 ** @param xcb_glx_get_doublev_cookie_t cookie 6416 ** @param xcb_generic_error_t **e 6417 ** @returns xcb_glx_get_doublev_reply_t * 6418 ** 6419 *****************************************************************************/ 6420 6421 xcb_glx_get_doublev_reply_t * 6422 xcb_glx_get_doublev_reply (xcb_connection_t *c /**< */, 6423 xcb_glx_get_doublev_cookie_t cookie /**< */, 6424 xcb_generic_error_t **e /**< */) 6425 { 6426 return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6427 } 6428 6429 6430 /***************************************************************************** 6431 ** 6432 ** xcb_glx_get_error_cookie_t xcb_glx_get_error 6433 ** 6434 ** @param xcb_connection_t *c 6435 ** @param xcb_glx_context_tag_t context_tag 6436 ** @returns xcb_glx_get_error_cookie_t 6437 ** 6438 *****************************************************************************/ 6439 6440 xcb_glx_get_error_cookie_t 6441 xcb_glx_get_error (xcb_connection_t *c /**< */, 6442 xcb_glx_context_tag_t context_tag /**< */) 6443 { 6444 static const xcb_protocol_request_t xcb_req = { 6445 /* count */ 2, 6446 /* ext */ &xcb_glx_id, 6447 /* opcode */ XCB_GLX_GET_ERROR, 6448 /* isvoid */ 0 6449 }; 6450 6451 struct iovec xcb_parts[4]; 6452 xcb_glx_get_error_cookie_t xcb_ret; 6453 xcb_glx_get_error_request_t xcb_out; 6454 6455 xcb_out.context_tag = context_tag; 6456 6457 xcb_parts[2].iov_base = (char *) &xcb_out; 6458 xcb_parts[2].iov_len = sizeof(xcb_out); 6459 xcb_parts[3].iov_base = 0; 6460 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6461 6462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6463 return xcb_ret; 6464 } 6465 6466 6467 /***************************************************************************** 6468 ** 6469 ** xcb_glx_get_error_cookie_t xcb_glx_get_error_unchecked 6470 ** 6471 ** @param xcb_connection_t *c 6472 ** @param xcb_glx_context_tag_t context_tag 6473 ** @returns xcb_glx_get_error_cookie_t 6474 ** 6475 *****************************************************************************/ 6476 6477 xcb_glx_get_error_cookie_t 6478 xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, 6479 xcb_glx_context_tag_t context_tag /**< */) 6480 { 6481 static const xcb_protocol_request_t xcb_req = { 6482 /* count */ 2, 6483 /* ext */ &xcb_glx_id, 6484 /* opcode */ XCB_GLX_GET_ERROR, 6485 /* isvoid */ 0 6486 }; 6487 6488 struct iovec xcb_parts[4]; 6489 xcb_glx_get_error_cookie_t xcb_ret; 6490 xcb_glx_get_error_request_t xcb_out; 6491 6492 xcb_out.context_tag = context_tag; 6493 6494 xcb_parts[2].iov_base = (char *) &xcb_out; 6495 xcb_parts[2].iov_len = sizeof(xcb_out); 6496 xcb_parts[3].iov_base = 0; 6497 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6498 6499 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6500 return xcb_ret; 6501 } 6502 6503 6504 /***************************************************************************** 6505 ** 6506 ** xcb_glx_get_error_reply_t * xcb_glx_get_error_reply 6507 ** 6508 ** @param xcb_connection_t *c 6509 ** @param xcb_glx_get_error_cookie_t cookie 6510 ** @param xcb_generic_error_t **e 6511 ** @returns xcb_glx_get_error_reply_t * 6512 ** 6513 *****************************************************************************/ 6514 6515 xcb_glx_get_error_reply_t * 6516 xcb_glx_get_error_reply (xcb_connection_t *c /**< */, 6517 xcb_glx_get_error_cookie_t cookie /**< */, 6518 xcb_generic_error_t **e /**< */) 6519 { 6520 return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6521 } 6522 6523 int 6524 xcb_glx_get_floatv_sizeof (const void *_buffer /**< */) 6525 { 6526 char *xcb_tmp = (char *)_buffer; 6527 const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer; 6528 unsigned int xcb_buffer_len = 0; 6529 unsigned int xcb_block_len = 0; 6530 unsigned int xcb_pad = 0; 6531 unsigned int xcb_align_to = 0; 6532 6533 6534 xcb_block_len += sizeof(xcb_glx_get_floatv_reply_t); 6535 xcb_tmp += xcb_block_len; 6536 xcb_buffer_len += xcb_block_len; 6537 xcb_block_len = 0; 6538 /* data */ 6539 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6540 xcb_tmp += xcb_block_len; 6541 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6542 /* insert padding */ 6543 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6544 xcb_buffer_len += xcb_block_len + xcb_pad; 6545 if (0 != xcb_pad) { 6546 xcb_tmp += xcb_pad; 6547 xcb_pad = 0; 6548 } 6549 xcb_block_len = 0; 6550 6551 return xcb_buffer_len; 6552 } 6553 6554 6555 /***************************************************************************** 6556 ** 6557 ** xcb_glx_get_floatv_cookie_t xcb_glx_get_floatv 6558 ** 6559 ** @param xcb_connection_t *c 6560 ** @param xcb_glx_context_tag_t context_tag 6561 ** @param uint32_t pname 6562 ** @returns xcb_glx_get_floatv_cookie_t 6563 ** 6564 *****************************************************************************/ 6565 6566 xcb_glx_get_floatv_cookie_t 6567 xcb_glx_get_floatv (xcb_connection_t *c /**< */, 6568 xcb_glx_context_tag_t context_tag /**< */, 6569 uint32_t pname /**< */) 6570 { 6571 static const xcb_protocol_request_t xcb_req = { 6572 /* count */ 2, 6573 /* ext */ &xcb_glx_id, 6574 /* opcode */ XCB_GLX_GET_FLOATV, 6575 /* isvoid */ 0 6576 }; 6577 6578 struct iovec xcb_parts[4]; 6579 xcb_glx_get_floatv_cookie_t xcb_ret; 6580 xcb_glx_get_floatv_request_t xcb_out; 6581 6582 xcb_out.context_tag = context_tag; 6583 xcb_out.pname = pname; 6584 6585 xcb_parts[2].iov_base = (char *) &xcb_out; 6586 xcb_parts[2].iov_len = sizeof(xcb_out); 6587 xcb_parts[3].iov_base = 0; 6588 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6589 6590 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6591 return xcb_ret; 6592 } 6593 6594 6595 /***************************************************************************** 6596 ** 6597 ** xcb_glx_get_floatv_cookie_t xcb_glx_get_floatv_unchecked 6598 ** 6599 ** @param xcb_connection_t *c 6600 ** @param xcb_glx_context_tag_t context_tag 6601 ** @param uint32_t pname 6602 ** @returns xcb_glx_get_floatv_cookie_t 6603 ** 6604 *****************************************************************************/ 6605 6606 xcb_glx_get_floatv_cookie_t 6607 xcb_glx_get_floatv_unchecked (xcb_connection_t *c /**< */, 6608 xcb_glx_context_tag_t context_tag /**< */, 6609 uint32_t pname /**< */) 6610 { 6611 static const xcb_protocol_request_t xcb_req = { 6612 /* count */ 2, 6613 /* ext */ &xcb_glx_id, 6614 /* opcode */ XCB_GLX_GET_FLOATV, 6615 /* isvoid */ 0 6616 }; 6617 6618 struct iovec xcb_parts[4]; 6619 xcb_glx_get_floatv_cookie_t xcb_ret; 6620 xcb_glx_get_floatv_request_t xcb_out; 6621 6622 xcb_out.context_tag = context_tag; 6623 xcb_out.pname = pname; 6624 6625 xcb_parts[2].iov_base = (char *) &xcb_out; 6626 xcb_parts[2].iov_len = sizeof(xcb_out); 6627 xcb_parts[3].iov_base = 0; 6628 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6629 6630 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6631 return xcb_ret; 6632 } 6633 6634 6635 /***************************************************************************** 6636 ** 6637 ** xcb_glx_float32_t * xcb_glx_get_floatv_data 6638 ** 6639 ** @param const xcb_glx_get_floatv_reply_t *R 6640 ** @returns xcb_glx_float32_t * 6641 ** 6642 *****************************************************************************/ 6643 6644 xcb_glx_float32_t * 6645 xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R /**< */) 6646 { 6647 return (xcb_glx_float32_t *) (R + 1); 6648 } 6649 6650 6651 /***************************************************************************** 6652 ** 6653 ** int xcb_glx_get_floatv_data_length 6654 ** 6655 ** @param const xcb_glx_get_floatv_reply_t *R 6656 ** @returns int 6657 ** 6658 *****************************************************************************/ 6659 6660 int 6661 xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R /**< */) 6662 { 6663 return R->n; 6664 } 6665 6666 6667 /***************************************************************************** 6668 ** 6669 ** xcb_generic_iterator_t xcb_glx_get_floatv_data_end 6670 ** 6671 ** @param const xcb_glx_get_floatv_reply_t *R 6672 ** @returns xcb_generic_iterator_t 6673 ** 6674 *****************************************************************************/ 6675 6676 xcb_generic_iterator_t 6677 xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */) 6678 { 6679 xcb_generic_iterator_t i; 6680 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6681 i.rem = 0; 6682 i.index = (char *) i.data - (char *) R; 6683 return i; 6684 } 6685 6686 6687 /***************************************************************************** 6688 ** 6689 ** xcb_glx_get_floatv_reply_t * xcb_glx_get_floatv_reply 6690 ** 6691 ** @param xcb_connection_t *c 6692 ** @param xcb_glx_get_floatv_cookie_t cookie 6693 ** @param xcb_generic_error_t **e 6694 ** @returns xcb_glx_get_floatv_reply_t * 6695 ** 6696 *****************************************************************************/ 6697 6698 xcb_glx_get_floatv_reply_t * 6699 xcb_glx_get_floatv_reply (xcb_connection_t *c /**< */, 6700 xcb_glx_get_floatv_cookie_t cookie /**< */, 6701 xcb_generic_error_t **e /**< */) 6702 { 6703 return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6704 } 6705 6706 int 6707 xcb_glx_get_integerv_sizeof (const void *_buffer /**< */) 6708 { 6709 char *xcb_tmp = (char *)_buffer; 6710 const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer; 6711 unsigned int xcb_buffer_len = 0; 6712 unsigned int xcb_block_len = 0; 6713 unsigned int xcb_pad = 0; 6714 unsigned int xcb_align_to = 0; 6715 6716 6717 xcb_block_len += sizeof(xcb_glx_get_integerv_reply_t); 6718 xcb_tmp += xcb_block_len; 6719 xcb_buffer_len += xcb_block_len; 6720 xcb_block_len = 0; 6721 /* data */ 6722 xcb_block_len += _aux->n * sizeof(int32_t); 6723 xcb_tmp += xcb_block_len; 6724 xcb_align_to = ALIGNOF(int32_t); 6725 /* insert padding */ 6726 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6727 xcb_buffer_len += xcb_block_len + xcb_pad; 6728 if (0 != xcb_pad) { 6729 xcb_tmp += xcb_pad; 6730 xcb_pad = 0; 6731 } 6732 xcb_block_len = 0; 6733 6734 return xcb_buffer_len; 6735 } 6736 6737 6738 /***************************************************************************** 6739 ** 6740 ** xcb_glx_get_integerv_cookie_t xcb_glx_get_integerv 6741 ** 6742 ** @param xcb_connection_t *c 6743 ** @param xcb_glx_context_tag_t context_tag 6744 ** @param uint32_t pname 6745 ** @returns xcb_glx_get_integerv_cookie_t 6746 ** 6747 *****************************************************************************/ 6748 6749 xcb_glx_get_integerv_cookie_t 6750 xcb_glx_get_integerv (xcb_connection_t *c /**< */, 6751 xcb_glx_context_tag_t context_tag /**< */, 6752 uint32_t pname /**< */) 6753 { 6754 static const xcb_protocol_request_t xcb_req = { 6755 /* count */ 2, 6756 /* ext */ &xcb_glx_id, 6757 /* opcode */ XCB_GLX_GET_INTEGERV, 6758 /* isvoid */ 0 6759 }; 6760 6761 struct iovec xcb_parts[4]; 6762 xcb_glx_get_integerv_cookie_t xcb_ret; 6763 xcb_glx_get_integerv_request_t xcb_out; 6764 6765 xcb_out.context_tag = context_tag; 6766 xcb_out.pname = pname; 6767 6768 xcb_parts[2].iov_base = (char *) &xcb_out; 6769 xcb_parts[2].iov_len = sizeof(xcb_out); 6770 xcb_parts[3].iov_base = 0; 6771 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6772 6773 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6774 return xcb_ret; 6775 } 6776 6777 6778 /***************************************************************************** 6779 ** 6780 ** xcb_glx_get_integerv_cookie_t xcb_glx_get_integerv_unchecked 6781 ** 6782 ** @param xcb_connection_t *c 6783 ** @param xcb_glx_context_tag_t context_tag 6784 ** @param uint32_t pname 6785 ** @returns xcb_glx_get_integerv_cookie_t 6786 ** 6787 *****************************************************************************/ 6788 6789 xcb_glx_get_integerv_cookie_t 6790 xcb_glx_get_integerv_unchecked (xcb_connection_t *c /**< */, 6791 xcb_glx_context_tag_t context_tag /**< */, 6792 uint32_t pname /**< */) 6793 { 6794 static const xcb_protocol_request_t xcb_req = { 6795 /* count */ 2, 6796 /* ext */ &xcb_glx_id, 6797 /* opcode */ XCB_GLX_GET_INTEGERV, 6798 /* isvoid */ 0 6799 }; 6800 6801 struct iovec xcb_parts[4]; 6802 xcb_glx_get_integerv_cookie_t xcb_ret; 6803 xcb_glx_get_integerv_request_t xcb_out; 6804 6805 xcb_out.context_tag = context_tag; 6806 xcb_out.pname = pname; 6807 6808 xcb_parts[2].iov_base = (char *) &xcb_out; 6809 xcb_parts[2].iov_len = sizeof(xcb_out); 6810 xcb_parts[3].iov_base = 0; 6811 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6812 6813 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6814 return xcb_ret; 6815 } 6816 6817 6818 /***************************************************************************** 6819 ** 6820 ** int32_t * xcb_glx_get_integerv_data 6821 ** 6822 ** @param const xcb_glx_get_integerv_reply_t *R 6823 ** @returns int32_t * 6824 ** 6825 *****************************************************************************/ 6826 6827 int32_t * 6828 xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R /**< */) 6829 { 6830 return (int32_t *) (R + 1); 6831 } 6832 6833 6834 /***************************************************************************** 6835 ** 6836 ** int xcb_glx_get_integerv_data_length 6837 ** 6838 ** @param const xcb_glx_get_integerv_reply_t *R 6839 ** @returns int 6840 ** 6841 *****************************************************************************/ 6842 6843 int 6844 xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R /**< */) 6845 { 6846 return R->n; 6847 } 6848 6849 6850 /***************************************************************************** 6851 ** 6852 ** xcb_generic_iterator_t xcb_glx_get_integerv_data_end 6853 ** 6854 ** @param const xcb_glx_get_integerv_reply_t *R 6855 ** @returns xcb_generic_iterator_t 6856 ** 6857 *****************************************************************************/ 6858 6859 xcb_generic_iterator_t 6860 xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */) 6861 { 6862 xcb_generic_iterator_t i; 6863 i.data = ((int32_t *) (R + 1)) + (R->n); 6864 i.rem = 0; 6865 i.index = (char *) i.data - (char *) R; 6866 return i; 6867 } 6868 6869 6870 /***************************************************************************** 6871 ** 6872 ** xcb_glx_get_integerv_reply_t * xcb_glx_get_integerv_reply 6873 ** 6874 ** @param xcb_connection_t *c 6875 ** @param xcb_glx_get_integerv_cookie_t cookie 6876 ** @param xcb_generic_error_t **e 6877 ** @returns xcb_glx_get_integerv_reply_t * 6878 ** 6879 *****************************************************************************/ 6880 6881 xcb_glx_get_integerv_reply_t * 6882 xcb_glx_get_integerv_reply (xcb_connection_t *c /**< */, 6883 xcb_glx_get_integerv_cookie_t cookie /**< */, 6884 xcb_generic_error_t **e /**< */) 6885 { 6886 return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6887 } 6888 6889 int 6890 xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */) 6891 { 6892 char *xcb_tmp = (char *)_buffer; 6893 const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer; 6894 unsigned int xcb_buffer_len = 0; 6895 unsigned int xcb_block_len = 0; 6896 unsigned int xcb_pad = 0; 6897 unsigned int xcb_align_to = 0; 6898 6899 6900 xcb_block_len += sizeof(xcb_glx_get_lightfv_reply_t); 6901 xcb_tmp += xcb_block_len; 6902 xcb_buffer_len += xcb_block_len; 6903 xcb_block_len = 0; 6904 /* data */ 6905 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6906 xcb_tmp += xcb_block_len; 6907 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6908 /* insert padding */ 6909 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6910 xcb_buffer_len += xcb_block_len + xcb_pad; 6911 if (0 != xcb_pad) { 6912 xcb_tmp += xcb_pad; 6913 xcb_pad = 0; 6914 } 6915 xcb_block_len = 0; 6916 6917 return xcb_buffer_len; 6918 } 6919 6920 6921 /***************************************************************************** 6922 ** 6923 ** xcb_glx_get_lightfv_cookie_t xcb_glx_get_lightfv 6924 ** 6925 ** @param xcb_connection_t *c 6926 ** @param xcb_glx_context_tag_t context_tag 6927 ** @param uint32_t light 6928 ** @param uint32_t pname 6929 ** @returns xcb_glx_get_lightfv_cookie_t 6930 ** 6931 *****************************************************************************/ 6932 6933 xcb_glx_get_lightfv_cookie_t 6934 xcb_glx_get_lightfv (xcb_connection_t *c /**< */, 6935 xcb_glx_context_tag_t context_tag /**< */, 6936 uint32_t light /**< */, 6937 uint32_t pname /**< */) 6938 { 6939 static const xcb_protocol_request_t xcb_req = { 6940 /* count */ 2, 6941 /* ext */ &xcb_glx_id, 6942 /* opcode */ XCB_GLX_GET_LIGHTFV, 6943 /* isvoid */ 0 6944 }; 6945 6946 struct iovec xcb_parts[4]; 6947 xcb_glx_get_lightfv_cookie_t xcb_ret; 6948 xcb_glx_get_lightfv_request_t xcb_out; 6949 6950 xcb_out.context_tag = context_tag; 6951 xcb_out.light = light; 6952 xcb_out.pname = pname; 6953 6954 xcb_parts[2].iov_base = (char *) &xcb_out; 6955 xcb_parts[2].iov_len = sizeof(xcb_out); 6956 xcb_parts[3].iov_base = 0; 6957 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6958 6959 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6960 return xcb_ret; 6961 } 6962 6963 6964 /***************************************************************************** 6965 ** 6966 ** xcb_glx_get_lightfv_cookie_t xcb_glx_get_lightfv_unchecked 6967 ** 6968 ** @param xcb_connection_t *c 6969 ** @param xcb_glx_context_tag_t context_tag 6970 ** @param uint32_t light 6971 ** @param uint32_t pname 6972 ** @returns xcb_glx_get_lightfv_cookie_t 6973 ** 6974 *****************************************************************************/ 6975 6976 xcb_glx_get_lightfv_cookie_t 6977 xcb_glx_get_lightfv_unchecked (xcb_connection_t *c /**< */, 6978 xcb_glx_context_tag_t context_tag /**< */, 6979 uint32_t light /**< */, 6980 uint32_t pname /**< */) 6981 { 6982 static const xcb_protocol_request_t xcb_req = { 6983 /* count */ 2, 6984 /* ext */ &xcb_glx_id, 6985 /* opcode */ XCB_GLX_GET_LIGHTFV, 6986 /* isvoid */ 0 6987 }; 6988 6989 struct iovec xcb_parts[4]; 6990 xcb_glx_get_lightfv_cookie_t xcb_ret; 6991 xcb_glx_get_lightfv_request_t xcb_out; 6992 6993 xcb_out.context_tag = context_tag; 6994 xcb_out.light = light; 6995 xcb_out.pname = pname; 6996 6997 xcb_parts[2].iov_base = (char *) &xcb_out; 6998 xcb_parts[2].iov_len = sizeof(xcb_out); 6999 xcb_parts[3].iov_base = 0; 7000 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7001 7002 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7003 return xcb_ret; 7004 } 7005 7006 7007 /***************************************************************************** 7008 ** 7009 ** xcb_glx_float32_t * xcb_glx_get_lightfv_data 7010 ** 7011 ** @param const xcb_glx_get_lightfv_reply_t *R 7012 ** @returns xcb_glx_float32_t * 7013 ** 7014 *****************************************************************************/ 7015 7016 xcb_glx_float32_t * 7017 xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R /**< */) 7018 { 7019 return (xcb_glx_float32_t *) (R + 1); 7020 } 7021 7022 7023 /***************************************************************************** 7024 ** 7025 ** int xcb_glx_get_lightfv_data_length 7026 ** 7027 ** @param const xcb_glx_get_lightfv_reply_t *R 7028 ** @returns int 7029 ** 7030 *****************************************************************************/ 7031 7032 int 7033 xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R /**< */) 7034 { 7035 return R->n; 7036 } 7037 7038 7039 /***************************************************************************** 7040 ** 7041 ** xcb_generic_iterator_t xcb_glx_get_lightfv_data_end 7042 ** 7043 ** @param const xcb_glx_get_lightfv_reply_t *R 7044 ** @returns xcb_generic_iterator_t 7045 ** 7046 *****************************************************************************/ 7047 7048 xcb_generic_iterator_t 7049 xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */) 7050 { 7051 xcb_generic_iterator_t i; 7052 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7053 i.rem = 0; 7054 i.index = (char *) i.data - (char *) R; 7055 return i; 7056 } 7057 7058 7059 /***************************************************************************** 7060 ** 7061 ** xcb_glx_get_lightfv_reply_t * xcb_glx_get_lightfv_reply 7062 ** 7063 ** @param xcb_connection_t *c 7064 ** @param xcb_glx_get_lightfv_cookie_t cookie 7065 ** @param xcb_generic_error_t **e 7066 ** @returns xcb_glx_get_lightfv_reply_t * 7067 ** 7068 *****************************************************************************/ 7069 7070 xcb_glx_get_lightfv_reply_t * 7071 xcb_glx_get_lightfv_reply (xcb_connection_t *c /**< */, 7072 xcb_glx_get_lightfv_cookie_t cookie /**< */, 7073 xcb_generic_error_t **e /**< */) 7074 { 7075 return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7076 } 7077 7078 int 7079 xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */) 7080 { 7081 char *xcb_tmp = (char *)_buffer; 7082 const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer; 7083 unsigned int xcb_buffer_len = 0; 7084 unsigned int xcb_block_len = 0; 7085 unsigned int xcb_pad = 0; 7086 unsigned int xcb_align_to = 0; 7087 7088 7089 xcb_block_len += sizeof(xcb_glx_get_lightiv_reply_t); 7090 xcb_tmp += xcb_block_len; 7091 xcb_buffer_len += xcb_block_len; 7092 xcb_block_len = 0; 7093 /* data */ 7094 xcb_block_len += _aux->n * sizeof(int32_t); 7095 xcb_tmp += xcb_block_len; 7096 xcb_align_to = ALIGNOF(int32_t); 7097 /* insert padding */ 7098 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7099 xcb_buffer_len += xcb_block_len + xcb_pad; 7100 if (0 != xcb_pad) { 7101 xcb_tmp += xcb_pad; 7102 xcb_pad = 0; 7103 } 7104 xcb_block_len = 0; 7105 7106 return xcb_buffer_len; 7107 } 7108 7109 7110 /***************************************************************************** 7111 ** 7112 ** xcb_glx_get_lightiv_cookie_t xcb_glx_get_lightiv 7113 ** 7114 ** @param xcb_connection_t *c 7115 ** @param xcb_glx_context_tag_t context_tag 7116 ** @param uint32_t light 7117 ** @param uint32_t pname 7118 ** @returns xcb_glx_get_lightiv_cookie_t 7119 ** 7120 *****************************************************************************/ 7121 7122 xcb_glx_get_lightiv_cookie_t 7123 xcb_glx_get_lightiv (xcb_connection_t *c /**< */, 7124 xcb_glx_context_tag_t context_tag /**< */, 7125 uint32_t light /**< */, 7126 uint32_t pname /**< */) 7127 { 7128 static const xcb_protocol_request_t xcb_req = { 7129 /* count */ 2, 7130 /* ext */ &xcb_glx_id, 7131 /* opcode */ XCB_GLX_GET_LIGHTIV, 7132 /* isvoid */ 0 7133 }; 7134 7135 struct iovec xcb_parts[4]; 7136 xcb_glx_get_lightiv_cookie_t xcb_ret; 7137 xcb_glx_get_lightiv_request_t xcb_out; 7138 7139 xcb_out.context_tag = context_tag; 7140 xcb_out.light = light; 7141 xcb_out.pname = pname; 7142 7143 xcb_parts[2].iov_base = (char *) &xcb_out; 7144 xcb_parts[2].iov_len = sizeof(xcb_out); 7145 xcb_parts[3].iov_base = 0; 7146 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7147 7148 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7149 return xcb_ret; 7150 } 7151 7152 7153 /***************************************************************************** 7154 ** 7155 ** xcb_glx_get_lightiv_cookie_t xcb_glx_get_lightiv_unchecked 7156 ** 7157 ** @param xcb_connection_t *c 7158 ** @param xcb_glx_context_tag_t context_tag 7159 ** @param uint32_t light 7160 ** @param uint32_t pname 7161 ** @returns xcb_glx_get_lightiv_cookie_t 7162 ** 7163 *****************************************************************************/ 7164 7165 xcb_glx_get_lightiv_cookie_t 7166 xcb_glx_get_lightiv_unchecked (xcb_connection_t *c /**< */, 7167 xcb_glx_context_tag_t context_tag /**< */, 7168 uint32_t light /**< */, 7169 uint32_t pname /**< */) 7170 { 7171 static const xcb_protocol_request_t xcb_req = { 7172 /* count */ 2, 7173 /* ext */ &xcb_glx_id, 7174 /* opcode */ XCB_GLX_GET_LIGHTIV, 7175 /* isvoid */ 0 7176 }; 7177 7178 struct iovec xcb_parts[4]; 7179 xcb_glx_get_lightiv_cookie_t xcb_ret; 7180 xcb_glx_get_lightiv_request_t xcb_out; 7181 7182 xcb_out.context_tag = context_tag; 7183 xcb_out.light = light; 7184 xcb_out.pname = pname; 7185 7186 xcb_parts[2].iov_base = (char *) &xcb_out; 7187 xcb_parts[2].iov_len = sizeof(xcb_out); 7188 xcb_parts[3].iov_base = 0; 7189 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7190 7191 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7192 return xcb_ret; 7193 } 7194 7195 7196 /***************************************************************************** 7197 ** 7198 ** int32_t * xcb_glx_get_lightiv_data 7199 ** 7200 ** @param const xcb_glx_get_lightiv_reply_t *R 7201 ** @returns int32_t * 7202 ** 7203 *****************************************************************************/ 7204 7205 int32_t * 7206 xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R /**< */) 7207 { 7208 return (int32_t *) (R + 1); 7209 } 7210 7211 7212 /***************************************************************************** 7213 ** 7214 ** int xcb_glx_get_lightiv_data_length 7215 ** 7216 ** @param const xcb_glx_get_lightiv_reply_t *R 7217 ** @returns int 7218 ** 7219 *****************************************************************************/ 7220 7221 int 7222 xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R /**< */) 7223 { 7224 return R->n; 7225 } 7226 7227 7228 /***************************************************************************** 7229 ** 7230 ** xcb_generic_iterator_t xcb_glx_get_lightiv_data_end 7231 ** 7232 ** @param const xcb_glx_get_lightiv_reply_t *R 7233 ** @returns xcb_generic_iterator_t 7234 ** 7235 *****************************************************************************/ 7236 7237 xcb_generic_iterator_t 7238 xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */) 7239 { 7240 xcb_generic_iterator_t i; 7241 i.data = ((int32_t *) (R + 1)) + (R->n); 7242 i.rem = 0; 7243 i.index = (char *) i.data - (char *) R; 7244 return i; 7245 } 7246 7247 7248 /***************************************************************************** 7249 ** 7250 ** xcb_glx_get_lightiv_reply_t * xcb_glx_get_lightiv_reply 7251 ** 7252 ** @param xcb_connection_t *c 7253 ** @param xcb_glx_get_lightiv_cookie_t cookie 7254 ** @param xcb_generic_error_t **e 7255 ** @returns xcb_glx_get_lightiv_reply_t * 7256 ** 7257 *****************************************************************************/ 7258 7259 xcb_glx_get_lightiv_reply_t * 7260 xcb_glx_get_lightiv_reply (xcb_connection_t *c /**< */, 7261 xcb_glx_get_lightiv_cookie_t cookie /**< */, 7262 xcb_generic_error_t **e /**< */) 7263 { 7264 return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7265 } 7266 7267 int 7268 xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */) 7269 { 7270 char *xcb_tmp = (char *)_buffer; 7271 const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer; 7272 unsigned int xcb_buffer_len = 0; 7273 unsigned int xcb_block_len = 0; 7274 unsigned int xcb_pad = 0; 7275 unsigned int xcb_align_to = 0; 7276 7277 7278 xcb_block_len += sizeof(xcb_glx_get_mapdv_reply_t); 7279 xcb_tmp += xcb_block_len; 7280 xcb_buffer_len += xcb_block_len; 7281 xcb_block_len = 0; 7282 /* data */ 7283 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 7284 xcb_tmp += xcb_block_len; 7285 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 7286 /* insert padding */ 7287 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7288 xcb_buffer_len += xcb_block_len + xcb_pad; 7289 if (0 != xcb_pad) { 7290 xcb_tmp += xcb_pad; 7291 xcb_pad = 0; 7292 } 7293 xcb_block_len = 0; 7294 7295 return xcb_buffer_len; 7296 } 7297 7298 7299 /***************************************************************************** 7300 ** 7301 ** xcb_glx_get_mapdv_cookie_t xcb_glx_get_mapdv 7302 ** 7303 ** @param xcb_connection_t *c 7304 ** @param xcb_glx_context_tag_t context_tag 7305 ** @param uint32_t target 7306 ** @param uint32_t query 7307 ** @returns xcb_glx_get_mapdv_cookie_t 7308 ** 7309 *****************************************************************************/ 7310 7311 xcb_glx_get_mapdv_cookie_t 7312 xcb_glx_get_mapdv (xcb_connection_t *c /**< */, 7313 xcb_glx_context_tag_t context_tag /**< */, 7314 uint32_t target /**< */, 7315 uint32_t query /**< */) 7316 { 7317 static const xcb_protocol_request_t xcb_req = { 7318 /* count */ 2, 7319 /* ext */ &xcb_glx_id, 7320 /* opcode */ XCB_GLX_GET_MAPDV, 7321 /* isvoid */ 0 7322 }; 7323 7324 struct iovec xcb_parts[4]; 7325 xcb_glx_get_mapdv_cookie_t xcb_ret; 7326 xcb_glx_get_mapdv_request_t xcb_out; 7327 7328 xcb_out.context_tag = context_tag; 7329 xcb_out.target = target; 7330 xcb_out.query = query; 7331 7332 xcb_parts[2].iov_base = (char *) &xcb_out; 7333 xcb_parts[2].iov_len = sizeof(xcb_out); 7334 xcb_parts[3].iov_base = 0; 7335 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7336 7337 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7338 return xcb_ret; 7339 } 7340 7341 7342 /***************************************************************************** 7343 ** 7344 ** xcb_glx_get_mapdv_cookie_t xcb_glx_get_mapdv_unchecked 7345 ** 7346 ** @param xcb_connection_t *c 7347 ** @param xcb_glx_context_tag_t context_tag 7348 ** @param uint32_t target 7349 ** @param uint32_t query 7350 ** @returns xcb_glx_get_mapdv_cookie_t 7351 ** 7352 *****************************************************************************/ 7353 7354 xcb_glx_get_mapdv_cookie_t 7355 xcb_glx_get_mapdv_unchecked (xcb_connection_t *c /**< */, 7356 xcb_glx_context_tag_t context_tag /**< */, 7357 uint32_t target /**< */, 7358 uint32_t query /**< */) 7359 { 7360 static const xcb_protocol_request_t xcb_req = { 7361 /* count */ 2, 7362 /* ext */ &xcb_glx_id, 7363 /* opcode */ XCB_GLX_GET_MAPDV, 7364 /* isvoid */ 0 7365 }; 7366 7367 struct iovec xcb_parts[4]; 7368 xcb_glx_get_mapdv_cookie_t xcb_ret; 7369 xcb_glx_get_mapdv_request_t xcb_out; 7370 7371 xcb_out.context_tag = context_tag; 7372 xcb_out.target = target; 7373 xcb_out.query = query; 7374 7375 xcb_parts[2].iov_base = (char *) &xcb_out; 7376 xcb_parts[2].iov_len = sizeof(xcb_out); 7377 xcb_parts[3].iov_base = 0; 7378 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7379 7380 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7381 return xcb_ret; 7382 } 7383 7384 7385 /***************************************************************************** 7386 ** 7387 ** xcb_glx_float64_t * xcb_glx_get_mapdv_data 7388 ** 7389 ** @param const xcb_glx_get_mapdv_reply_t *R 7390 ** @returns xcb_glx_float64_t * 7391 ** 7392 *****************************************************************************/ 7393 7394 xcb_glx_float64_t * 7395 xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R /**< */) 7396 { 7397 return (xcb_glx_float64_t *) (R + 1); 7398 } 7399 7400 7401 /***************************************************************************** 7402 ** 7403 ** int xcb_glx_get_mapdv_data_length 7404 ** 7405 ** @param const xcb_glx_get_mapdv_reply_t *R 7406 ** @returns int 7407 ** 7408 *****************************************************************************/ 7409 7410 int 7411 xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R /**< */) 7412 { 7413 return R->n; 7414 } 7415 7416 7417 /***************************************************************************** 7418 ** 7419 ** xcb_generic_iterator_t xcb_glx_get_mapdv_data_end 7420 ** 7421 ** @param const xcb_glx_get_mapdv_reply_t *R 7422 ** @returns xcb_generic_iterator_t 7423 ** 7424 *****************************************************************************/ 7425 7426 xcb_generic_iterator_t 7427 xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */) 7428 { 7429 xcb_generic_iterator_t i; 7430 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 7431 i.rem = 0; 7432 i.index = (char *) i.data - (char *) R; 7433 return i; 7434 } 7435 7436 7437 /***************************************************************************** 7438 ** 7439 ** xcb_glx_get_mapdv_reply_t * xcb_glx_get_mapdv_reply 7440 ** 7441 ** @param xcb_connection_t *c 7442 ** @param xcb_glx_get_mapdv_cookie_t cookie 7443 ** @param xcb_generic_error_t **e 7444 ** @returns xcb_glx_get_mapdv_reply_t * 7445 ** 7446 *****************************************************************************/ 7447 7448 xcb_glx_get_mapdv_reply_t * 7449 xcb_glx_get_mapdv_reply (xcb_connection_t *c /**< */, 7450 xcb_glx_get_mapdv_cookie_t cookie /**< */, 7451 xcb_generic_error_t **e /**< */) 7452 { 7453 return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7454 } 7455 7456 int 7457 xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */) 7458 { 7459 char *xcb_tmp = (char *)_buffer; 7460 const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer; 7461 unsigned int xcb_buffer_len = 0; 7462 unsigned int xcb_block_len = 0; 7463 unsigned int xcb_pad = 0; 7464 unsigned int xcb_align_to = 0; 7465 7466 7467 xcb_block_len += sizeof(xcb_glx_get_mapfv_reply_t); 7468 xcb_tmp += xcb_block_len; 7469 xcb_buffer_len += xcb_block_len; 7470 xcb_block_len = 0; 7471 /* data */ 7472 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7473 xcb_tmp += xcb_block_len; 7474 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7475 /* insert padding */ 7476 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7477 xcb_buffer_len += xcb_block_len + xcb_pad; 7478 if (0 != xcb_pad) { 7479 xcb_tmp += xcb_pad; 7480 xcb_pad = 0; 7481 } 7482 xcb_block_len = 0; 7483 7484 return xcb_buffer_len; 7485 } 7486 7487 7488 /***************************************************************************** 7489 ** 7490 ** xcb_glx_get_mapfv_cookie_t xcb_glx_get_mapfv 7491 ** 7492 ** @param xcb_connection_t *c 7493 ** @param xcb_glx_context_tag_t context_tag 7494 ** @param uint32_t target 7495 ** @param uint32_t query 7496 ** @returns xcb_glx_get_mapfv_cookie_t 7497 ** 7498 *****************************************************************************/ 7499 7500 xcb_glx_get_mapfv_cookie_t 7501 xcb_glx_get_mapfv (xcb_connection_t *c /**< */, 7502 xcb_glx_context_tag_t context_tag /**< */, 7503 uint32_t target /**< */, 7504 uint32_t query /**< */) 7505 { 7506 static const xcb_protocol_request_t xcb_req = { 7507 /* count */ 2, 7508 /* ext */ &xcb_glx_id, 7509 /* opcode */ XCB_GLX_GET_MAPFV, 7510 /* isvoid */ 0 7511 }; 7512 7513 struct iovec xcb_parts[4]; 7514 xcb_glx_get_mapfv_cookie_t xcb_ret; 7515 xcb_glx_get_mapfv_request_t xcb_out; 7516 7517 xcb_out.context_tag = context_tag; 7518 xcb_out.target = target; 7519 xcb_out.query = query; 7520 7521 xcb_parts[2].iov_base = (char *) &xcb_out; 7522 xcb_parts[2].iov_len = sizeof(xcb_out); 7523 xcb_parts[3].iov_base = 0; 7524 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7525 7526 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7527 return xcb_ret; 7528 } 7529 7530 7531 /***************************************************************************** 7532 ** 7533 ** xcb_glx_get_mapfv_cookie_t xcb_glx_get_mapfv_unchecked 7534 ** 7535 ** @param xcb_connection_t *c 7536 ** @param xcb_glx_context_tag_t context_tag 7537 ** @param uint32_t target 7538 ** @param uint32_t query 7539 ** @returns xcb_glx_get_mapfv_cookie_t 7540 ** 7541 *****************************************************************************/ 7542 7543 xcb_glx_get_mapfv_cookie_t 7544 xcb_glx_get_mapfv_unchecked (xcb_connection_t *c /**< */, 7545 xcb_glx_context_tag_t context_tag /**< */, 7546 uint32_t target /**< */, 7547 uint32_t query /**< */) 7548 { 7549 static const xcb_protocol_request_t xcb_req = { 7550 /* count */ 2, 7551 /* ext */ &xcb_glx_id, 7552 /* opcode */ XCB_GLX_GET_MAPFV, 7553 /* isvoid */ 0 7554 }; 7555 7556 struct iovec xcb_parts[4]; 7557 xcb_glx_get_mapfv_cookie_t xcb_ret; 7558 xcb_glx_get_mapfv_request_t xcb_out; 7559 7560 xcb_out.context_tag = context_tag; 7561 xcb_out.target = target; 7562 xcb_out.query = query; 7563 7564 xcb_parts[2].iov_base = (char *) &xcb_out; 7565 xcb_parts[2].iov_len = sizeof(xcb_out); 7566 xcb_parts[3].iov_base = 0; 7567 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7568 7569 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7570 return xcb_ret; 7571 } 7572 7573 7574 /***************************************************************************** 7575 ** 7576 ** xcb_glx_float32_t * xcb_glx_get_mapfv_data 7577 ** 7578 ** @param const xcb_glx_get_mapfv_reply_t *R 7579 ** @returns xcb_glx_float32_t * 7580 ** 7581 *****************************************************************************/ 7582 7583 xcb_glx_float32_t * 7584 xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R /**< */) 7585 { 7586 return (xcb_glx_float32_t *) (R + 1); 7587 } 7588 7589 7590 /***************************************************************************** 7591 ** 7592 ** int xcb_glx_get_mapfv_data_length 7593 ** 7594 ** @param const xcb_glx_get_mapfv_reply_t *R 7595 ** @returns int 7596 ** 7597 *****************************************************************************/ 7598 7599 int 7600 xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R /**< */) 7601 { 7602 return R->n; 7603 } 7604 7605 7606 /***************************************************************************** 7607 ** 7608 ** xcb_generic_iterator_t xcb_glx_get_mapfv_data_end 7609 ** 7610 ** @param const xcb_glx_get_mapfv_reply_t *R 7611 ** @returns xcb_generic_iterator_t 7612 ** 7613 *****************************************************************************/ 7614 7615 xcb_generic_iterator_t 7616 xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */) 7617 { 7618 xcb_generic_iterator_t i; 7619 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7620 i.rem = 0; 7621 i.index = (char *) i.data - (char *) R; 7622 return i; 7623 } 7624 7625 7626 /***************************************************************************** 7627 ** 7628 ** xcb_glx_get_mapfv_reply_t * xcb_glx_get_mapfv_reply 7629 ** 7630 ** @param xcb_connection_t *c 7631 ** @param xcb_glx_get_mapfv_cookie_t cookie 7632 ** @param xcb_generic_error_t **e 7633 ** @returns xcb_glx_get_mapfv_reply_t * 7634 ** 7635 *****************************************************************************/ 7636 7637 xcb_glx_get_mapfv_reply_t * 7638 xcb_glx_get_mapfv_reply (xcb_connection_t *c /**< */, 7639 xcb_glx_get_mapfv_cookie_t cookie /**< */, 7640 xcb_generic_error_t **e /**< */) 7641 { 7642 return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7643 } 7644 7645 int 7646 xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */) 7647 { 7648 char *xcb_tmp = (char *)_buffer; 7649 const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer; 7650 unsigned int xcb_buffer_len = 0; 7651 unsigned int xcb_block_len = 0; 7652 unsigned int xcb_pad = 0; 7653 unsigned int xcb_align_to = 0; 7654 7655 7656 xcb_block_len += sizeof(xcb_glx_get_mapiv_reply_t); 7657 xcb_tmp += xcb_block_len; 7658 xcb_buffer_len += xcb_block_len; 7659 xcb_block_len = 0; 7660 /* data */ 7661 xcb_block_len += _aux->n * sizeof(int32_t); 7662 xcb_tmp += xcb_block_len; 7663 xcb_align_to = ALIGNOF(int32_t); 7664 /* insert padding */ 7665 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7666 xcb_buffer_len += xcb_block_len + xcb_pad; 7667 if (0 != xcb_pad) { 7668 xcb_tmp += xcb_pad; 7669 xcb_pad = 0; 7670 } 7671 xcb_block_len = 0; 7672 7673 return xcb_buffer_len; 7674 } 7675 7676 7677 /***************************************************************************** 7678 ** 7679 ** xcb_glx_get_mapiv_cookie_t xcb_glx_get_mapiv 7680 ** 7681 ** @param xcb_connection_t *c 7682 ** @param xcb_glx_context_tag_t context_tag 7683 ** @param uint32_t target 7684 ** @param uint32_t query 7685 ** @returns xcb_glx_get_mapiv_cookie_t 7686 ** 7687 *****************************************************************************/ 7688 7689 xcb_glx_get_mapiv_cookie_t 7690 xcb_glx_get_mapiv (xcb_connection_t *c /**< */, 7691 xcb_glx_context_tag_t context_tag /**< */, 7692 uint32_t target /**< */, 7693 uint32_t query /**< */) 7694 { 7695 static const xcb_protocol_request_t xcb_req = { 7696 /* count */ 2, 7697 /* ext */ &xcb_glx_id, 7698 /* opcode */ XCB_GLX_GET_MAPIV, 7699 /* isvoid */ 0 7700 }; 7701 7702 struct iovec xcb_parts[4]; 7703 xcb_glx_get_mapiv_cookie_t xcb_ret; 7704 xcb_glx_get_mapiv_request_t xcb_out; 7705 7706 xcb_out.context_tag = context_tag; 7707 xcb_out.target = target; 7708 xcb_out.query = query; 7709 7710 xcb_parts[2].iov_base = (char *) &xcb_out; 7711 xcb_parts[2].iov_len = sizeof(xcb_out); 7712 xcb_parts[3].iov_base = 0; 7713 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7714 7715 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7716 return xcb_ret; 7717 } 7718 7719 7720 /***************************************************************************** 7721 ** 7722 ** xcb_glx_get_mapiv_cookie_t xcb_glx_get_mapiv_unchecked 7723 ** 7724 ** @param xcb_connection_t *c 7725 ** @param xcb_glx_context_tag_t context_tag 7726 ** @param uint32_t target 7727 ** @param uint32_t query 7728 ** @returns xcb_glx_get_mapiv_cookie_t 7729 ** 7730 *****************************************************************************/ 7731 7732 xcb_glx_get_mapiv_cookie_t 7733 xcb_glx_get_mapiv_unchecked (xcb_connection_t *c /**< */, 7734 xcb_glx_context_tag_t context_tag /**< */, 7735 uint32_t target /**< */, 7736 uint32_t query /**< */) 7737 { 7738 static const xcb_protocol_request_t xcb_req = { 7739 /* count */ 2, 7740 /* ext */ &xcb_glx_id, 7741 /* opcode */ XCB_GLX_GET_MAPIV, 7742 /* isvoid */ 0 7743 }; 7744 7745 struct iovec xcb_parts[4]; 7746 xcb_glx_get_mapiv_cookie_t xcb_ret; 7747 xcb_glx_get_mapiv_request_t xcb_out; 7748 7749 xcb_out.context_tag = context_tag; 7750 xcb_out.target = target; 7751 xcb_out.query = query; 7752 7753 xcb_parts[2].iov_base = (char *) &xcb_out; 7754 xcb_parts[2].iov_len = sizeof(xcb_out); 7755 xcb_parts[3].iov_base = 0; 7756 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7757 7758 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7759 return xcb_ret; 7760 } 7761 7762 7763 /***************************************************************************** 7764 ** 7765 ** int32_t * xcb_glx_get_mapiv_data 7766 ** 7767 ** @param const xcb_glx_get_mapiv_reply_t *R 7768 ** @returns int32_t * 7769 ** 7770 *****************************************************************************/ 7771 7772 int32_t * 7773 xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R /**< */) 7774 { 7775 return (int32_t *) (R + 1); 7776 } 7777 7778 7779 /***************************************************************************** 7780 ** 7781 ** int xcb_glx_get_mapiv_data_length 7782 ** 7783 ** @param const xcb_glx_get_mapiv_reply_t *R 7784 ** @returns int 7785 ** 7786 *****************************************************************************/ 7787 7788 int 7789 xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R /**< */) 7790 { 7791 return R->n; 7792 } 7793 7794 7795 /***************************************************************************** 7796 ** 7797 ** xcb_generic_iterator_t xcb_glx_get_mapiv_data_end 7798 ** 7799 ** @param const xcb_glx_get_mapiv_reply_t *R 7800 ** @returns xcb_generic_iterator_t 7801 ** 7802 *****************************************************************************/ 7803 7804 xcb_generic_iterator_t 7805 xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */) 7806 { 7807 xcb_generic_iterator_t i; 7808 i.data = ((int32_t *) (R + 1)) + (R->n); 7809 i.rem = 0; 7810 i.index = (char *) i.data - (char *) R; 7811 return i; 7812 } 7813 7814 7815 /***************************************************************************** 7816 ** 7817 ** xcb_glx_get_mapiv_reply_t * xcb_glx_get_mapiv_reply 7818 ** 7819 ** @param xcb_connection_t *c 7820 ** @param xcb_glx_get_mapiv_cookie_t cookie 7821 ** @param xcb_generic_error_t **e 7822 ** @returns xcb_glx_get_mapiv_reply_t * 7823 ** 7824 *****************************************************************************/ 7825 7826 xcb_glx_get_mapiv_reply_t * 7827 xcb_glx_get_mapiv_reply (xcb_connection_t *c /**< */, 7828 xcb_glx_get_mapiv_cookie_t cookie /**< */, 7829 xcb_generic_error_t **e /**< */) 7830 { 7831 return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7832 } 7833 7834 int 7835 xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */) 7836 { 7837 char *xcb_tmp = (char *)_buffer; 7838 const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer; 7839 unsigned int xcb_buffer_len = 0; 7840 unsigned int xcb_block_len = 0; 7841 unsigned int xcb_pad = 0; 7842 unsigned int xcb_align_to = 0; 7843 7844 7845 xcb_block_len += sizeof(xcb_glx_get_materialfv_reply_t); 7846 xcb_tmp += xcb_block_len; 7847 xcb_buffer_len += xcb_block_len; 7848 xcb_block_len = 0; 7849 /* data */ 7850 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7851 xcb_tmp += xcb_block_len; 7852 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7853 /* insert padding */ 7854 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7855 xcb_buffer_len += xcb_block_len + xcb_pad; 7856 if (0 != xcb_pad) { 7857 xcb_tmp += xcb_pad; 7858 xcb_pad = 0; 7859 } 7860 xcb_block_len = 0; 7861 7862 return xcb_buffer_len; 7863 } 7864 7865 7866 /***************************************************************************** 7867 ** 7868 ** xcb_glx_get_materialfv_cookie_t xcb_glx_get_materialfv 7869 ** 7870 ** @param xcb_connection_t *c 7871 ** @param xcb_glx_context_tag_t context_tag 7872 ** @param uint32_t face 7873 ** @param uint32_t pname 7874 ** @returns xcb_glx_get_materialfv_cookie_t 7875 ** 7876 *****************************************************************************/ 7877 7878 xcb_glx_get_materialfv_cookie_t 7879 xcb_glx_get_materialfv (xcb_connection_t *c /**< */, 7880 xcb_glx_context_tag_t context_tag /**< */, 7881 uint32_t face /**< */, 7882 uint32_t pname /**< */) 7883 { 7884 static const xcb_protocol_request_t xcb_req = { 7885 /* count */ 2, 7886 /* ext */ &xcb_glx_id, 7887 /* opcode */ XCB_GLX_GET_MATERIALFV, 7888 /* isvoid */ 0 7889 }; 7890 7891 struct iovec xcb_parts[4]; 7892 xcb_glx_get_materialfv_cookie_t xcb_ret; 7893 xcb_glx_get_materialfv_request_t xcb_out; 7894 7895 xcb_out.context_tag = context_tag; 7896 xcb_out.face = face; 7897 xcb_out.pname = pname; 7898 7899 xcb_parts[2].iov_base = (char *) &xcb_out; 7900 xcb_parts[2].iov_len = sizeof(xcb_out); 7901 xcb_parts[3].iov_base = 0; 7902 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7903 7904 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7905 return xcb_ret; 7906 } 7907 7908 7909 /***************************************************************************** 7910 ** 7911 ** xcb_glx_get_materialfv_cookie_t xcb_glx_get_materialfv_unchecked 7912 ** 7913 ** @param xcb_connection_t *c 7914 ** @param xcb_glx_context_tag_t context_tag 7915 ** @param uint32_t face 7916 ** @param uint32_t pname 7917 ** @returns xcb_glx_get_materialfv_cookie_t 7918 ** 7919 *****************************************************************************/ 7920 7921 xcb_glx_get_materialfv_cookie_t 7922 xcb_glx_get_materialfv_unchecked (xcb_connection_t *c /**< */, 7923 xcb_glx_context_tag_t context_tag /**< */, 7924 uint32_t face /**< */, 7925 uint32_t pname /**< */) 7926 { 7927 static const xcb_protocol_request_t xcb_req = { 7928 /* count */ 2, 7929 /* ext */ &xcb_glx_id, 7930 /* opcode */ XCB_GLX_GET_MATERIALFV, 7931 /* isvoid */ 0 7932 }; 7933 7934 struct iovec xcb_parts[4]; 7935 xcb_glx_get_materialfv_cookie_t xcb_ret; 7936 xcb_glx_get_materialfv_request_t xcb_out; 7937 7938 xcb_out.context_tag = context_tag; 7939 xcb_out.face = face; 7940 xcb_out.pname = pname; 7941 7942 xcb_parts[2].iov_base = (char *) &xcb_out; 7943 xcb_parts[2].iov_len = sizeof(xcb_out); 7944 xcb_parts[3].iov_base = 0; 7945 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7946 7947 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7948 return xcb_ret; 7949 } 7950 7951 7952 /***************************************************************************** 7953 ** 7954 ** xcb_glx_float32_t * xcb_glx_get_materialfv_data 7955 ** 7956 ** @param const xcb_glx_get_materialfv_reply_t *R 7957 ** @returns xcb_glx_float32_t * 7958 ** 7959 *****************************************************************************/ 7960 7961 xcb_glx_float32_t * 7962 xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R /**< */) 7963 { 7964 return (xcb_glx_float32_t *) (R + 1); 7965 } 7966 7967 7968 /***************************************************************************** 7969 ** 7970 ** int xcb_glx_get_materialfv_data_length 7971 ** 7972 ** @param const xcb_glx_get_materialfv_reply_t *R 7973 ** @returns int 7974 ** 7975 *****************************************************************************/ 7976 7977 int 7978 xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R /**< */) 7979 { 7980 return R->n; 7981 } 7982 7983 7984 /***************************************************************************** 7985 ** 7986 ** xcb_generic_iterator_t xcb_glx_get_materialfv_data_end 7987 ** 7988 ** @param const xcb_glx_get_materialfv_reply_t *R 7989 ** @returns xcb_generic_iterator_t 7990 ** 7991 *****************************************************************************/ 7992 7993 xcb_generic_iterator_t 7994 xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< */) 7995 { 7996 xcb_generic_iterator_t i; 7997 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7998 i.rem = 0; 7999 i.index = (char *) i.data - (char *) R; 8000 return i; 8001 } 8002 8003 8004 /***************************************************************************** 8005 ** 8006 ** xcb_glx_get_materialfv_reply_t * xcb_glx_get_materialfv_reply 8007 ** 8008 ** @param xcb_connection_t *c 8009 ** @param xcb_glx_get_materialfv_cookie_t cookie 8010 ** @param xcb_generic_error_t **e 8011 ** @returns xcb_glx_get_materialfv_reply_t * 8012 ** 8013 *****************************************************************************/ 8014 8015 xcb_glx_get_materialfv_reply_t * 8016 xcb_glx_get_materialfv_reply (xcb_connection_t *c /**< */, 8017 xcb_glx_get_materialfv_cookie_t cookie /**< */, 8018 xcb_generic_error_t **e /**< */) 8019 { 8020 return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8021 } 8022 8023 int 8024 xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */) 8025 { 8026 char *xcb_tmp = (char *)_buffer; 8027 const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer; 8028 unsigned int xcb_buffer_len = 0; 8029 unsigned int xcb_block_len = 0; 8030 unsigned int xcb_pad = 0; 8031 unsigned int xcb_align_to = 0; 8032 8033 8034 xcb_block_len += sizeof(xcb_glx_get_materialiv_reply_t); 8035 xcb_tmp += xcb_block_len; 8036 xcb_buffer_len += xcb_block_len; 8037 xcb_block_len = 0; 8038 /* data */ 8039 xcb_block_len += _aux->n * sizeof(int32_t); 8040 xcb_tmp += xcb_block_len; 8041 xcb_align_to = ALIGNOF(int32_t); 8042 /* insert padding */ 8043 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8044 xcb_buffer_len += xcb_block_len + xcb_pad; 8045 if (0 != xcb_pad) { 8046 xcb_tmp += xcb_pad; 8047 xcb_pad = 0; 8048 } 8049 xcb_block_len = 0; 8050 8051 return xcb_buffer_len; 8052 } 8053 8054 8055 /***************************************************************************** 8056 ** 8057 ** xcb_glx_get_materialiv_cookie_t xcb_glx_get_materialiv 8058 ** 8059 ** @param xcb_connection_t *c 8060 ** @param xcb_glx_context_tag_t context_tag 8061 ** @param uint32_t face 8062 ** @param uint32_t pname 8063 ** @returns xcb_glx_get_materialiv_cookie_t 8064 ** 8065 *****************************************************************************/ 8066 8067 xcb_glx_get_materialiv_cookie_t 8068 xcb_glx_get_materialiv (xcb_connection_t *c /**< */, 8069 xcb_glx_context_tag_t context_tag /**< */, 8070 uint32_t face /**< */, 8071 uint32_t pname /**< */) 8072 { 8073 static const xcb_protocol_request_t xcb_req = { 8074 /* count */ 2, 8075 /* ext */ &xcb_glx_id, 8076 /* opcode */ XCB_GLX_GET_MATERIALIV, 8077 /* isvoid */ 0 8078 }; 8079 8080 struct iovec xcb_parts[4]; 8081 xcb_glx_get_materialiv_cookie_t xcb_ret; 8082 xcb_glx_get_materialiv_request_t xcb_out; 8083 8084 xcb_out.context_tag = context_tag; 8085 xcb_out.face = face; 8086 xcb_out.pname = pname; 8087 8088 xcb_parts[2].iov_base = (char *) &xcb_out; 8089 xcb_parts[2].iov_len = sizeof(xcb_out); 8090 xcb_parts[3].iov_base = 0; 8091 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8092 8093 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8094 return xcb_ret; 8095 } 8096 8097 8098 /***************************************************************************** 8099 ** 8100 ** xcb_glx_get_materialiv_cookie_t xcb_glx_get_materialiv_unchecked 8101 ** 8102 ** @param xcb_connection_t *c 8103 ** @param xcb_glx_context_tag_t context_tag 8104 ** @param uint32_t face 8105 ** @param uint32_t pname 8106 ** @returns xcb_glx_get_materialiv_cookie_t 8107 ** 8108 *****************************************************************************/ 8109 8110 xcb_glx_get_materialiv_cookie_t 8111 xcb_glx_get_materialiv_unchecked (xcb_connection_t *c /**< */, 8112 xcb_glx_context_tag_t context_tag /**< */, 8113 uint32_t face /**< */, 8114 uint32_t pname /**< */) 8115 { 8116 static const xcb_protocol_request_t xcb_req = { 8117 /* count */ 2, 8118 /* ext */ &xcb_glx_id, 8119 /* opcode */ XCB_GLX_GET_MATERIALIV, 8120 /* isvoid */ 0 8121 }; 8122 8123 struct iovec xcb_parts[4]; 8124 xcb_glx_get_materialiv_cookie_t xcb_ret; 8125 xcb_glx_get_materialiv_request_t xcb_out; 8126 8127 xcb_out.context_tag = context_tag; 8128 xcb_out.face = face; 8129 xcb_out.pname = pname; 8130 8131 xcb_parts[2].iov_base = (char *) &xcb_out; 8132 xcb_parts[2].iov_len = sizeof(xcb_out); 8133 xcb_parts[3].iov_base = 0; 8134 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8135 8136 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8137 return xcb_ret; 8138 } 8139 8140 8141 /***************************************************************************** 8142 ** 8143 ** int32_t * xcb_glx_get_materialiv_data 8144 ** 8145 ** @param const xcb_glx_get_materialiv_reply_t *R 8146 ** @returns int32_t * 8147 ** 8148 *****************************************************************************/ 8149 8150 int32_t * 8151 xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R /**< */) 8152 { 8153 return (int32_t *) (R + 1); 8154 } 8155 8156 8157 /***************************************************************************** 8158 ** 8159 ** int xcb_glx_get_materialiv_data_length 8160 ** 8161 ** @param const xcb_glx_get_materialiv_reply_t *R 8162 ** @returns int 8163 ** 8164 *****************************************************************************/ 8165 8166 int 8167 xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R /**< */) 8168 { 8169 return R->n; 8170 } 8171 8172 8173 /***************************************************************************** 8174 ** 8175 ** xcb_generic_iterator_t xcb_glx_get_materialiv_data_end 8176 ** 8177 ** @param const xcb_glx_get_materialiv_reply_t *R 8178 ** @returns xcb_generic_iterator_t 8179 ** 8180 *****************************************************************************/ 8181 8182 xcb_generic_iterator_t 8183 xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< */) 8184 { 8185 xcb_generic_iterator_t i; 8186 i.data = ((int32_t *) (R + 1)) + (R->n); 8187 i.rem = 0; 8188 i.index = (char *) i.data - (char *) R; 8189 return i; 8190 } 8191 8192 8193 /***************************************************************************** 8194 ** 8195 ** xcb_glx_get_materialiv_reply_t * xcb_glx_get_materialiv_reply 8196 ** 8197 ** @param xcb_connection_t *c 8198 ** @param xcb_glx_get_materialiv_cookie_t cookie 8199 ** @param xcb_generic_error_t **e 8200 ** @returns xcb_glx_get_materialiv_reply_t * 8201 ** 8202 *****************************************************************************/ 8203 8204 xcb_glx_get_materialiv_reply_t * 8205 xcb_glx_get_materialiv_reply (xcb_connection_t *c /**< */, 8206 xcb_glx_get_materialiv_cookie_t cookie /**< */, 8207 xcb_generic_error_t **e /**< */) 8208 { 8209 return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8210 } 8211 8212 int 8213 xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */) 8214 { 8215 char *xcb_tmp = (char *)_buffer; 8216 const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer; 8217 unsigned int xcb_buffer_len = 0; 8218 unsigned int xcb_block_len = 0; 8219 unsigned int xcb_pad = 0; 8220 unsigned int xcb_align_to = 0; 8221 8222 8223 xcb_block_len += sizeof(xcb_glx_get_pixel_mapfv_reply_t); 8224 xcb_tmp += xcb_block_len; 8225 xcb_buffer_len += xcb_block_len; 8226 xcb_block_len = 0; 8227 /* data */ 8228 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8229 xcb_tmp += xcb_block_len; 8230 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8231 /* insert padding */ 8232 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8233 xcb_buffer_len += xcb_block_len + xcb_pad; 8234 if (0 != xcb_pad) { 8235 xcb_tmp += xcb_pad; 8236 xcb_pad = 0; 8237 } 8238 xcb_block_len = 0; 8239 8240 return xcb_buffer_len; 8241 } 8242 8243 8244 /***************************************************************************** 8245 ** 8246 ** xcb_glx_get_pixel_mapfv_cookie_t xcb_glx_get_pixel_mapfv 8247 ** 8248 ** @param xcb_connection_t *c 8249 ** @param xcb_glx_context_tag_t context_tag 8250 ** @param uint32_t map 8251 ** @returns xcb_glx_get_pixel_mapfv_cookie_t 8252 ** 8253 *****************************************************************************/ 8254 8255 xcb_glx_get_pixel_mapfv_cookie_t 8256 xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, 8257 xcb_glx_context_tag_t context_tag /**< */, 8258 uint32_t map /**< */) 8259 { 8260 static const xcb_protocol_request_t xcb_req = { 8261 /* count */ 2, 8262 /* ext */ &xcb_glx_id, 8263 /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, 8264 /* isvoid */ 0 8265 }; 8266 8267 struct iovec xcb_parts[4]; 8268 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 8269 xcb_glx_get_pixel_mapfv_request_t xcb_out; 8270 8271 xcb_out.context_tag = context_tag; 8272 xcb_out.map = map; 8273 8274 xcb_parts[2].iov_base = (char *) &xcb_out; 8275 xcb_parts[2].iov_len = sizeof(xcb_out); 8276 xcb_parts[3].iov_base = 0; 8277 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8278 8279 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8280 return xcb_ret; 8281 } 8282 8283 8284 /***************************************************************************** 8285 ** 8286 ** xcb_glx_get_pixel_mapfv_cookie_t xcb_glx_get_pixel_mapfv_unchecked 8287 ** 8288 ** @param xcb_connection_t *c 8289 ** @param xcb_glx_context_tag_t context_tag 8290 ** @param uint32_t map 8291 ** @returns xcb_glx_get_pixel_mapfv_cookie_t 8292 ** 8293 *****************************************************************************/ 8294 8295 xcb_glx_get_pixel_mapfv_cookie_t 8296 xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c /**< */, 8297 xcb_glx_context_tag_t context_tag /**< */, 8298 uint32_t map /**< */) 8299 { 8300 static const xcb_protocol_request_t xcb_req = { 8301 /* count */ 2, 8302 /* ext */ &xcb_glx_id, 8303 /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, 8304 /* isvoid */ 0 8305 }; 8306 8307 struct iovec xcb_parts[4]; 8308 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 8309 xcb_glx_get_pixel_mapfv_request_t xcb_out; 8310 8311 xcb_out.context_tag = context_tag; 8312 xcb_out.map = map; 8313 8314 xcb_parts[2].iov_base = (char *) &xcb_out; 8315 xcb_parts[2].iov_len = sizeof(xcb_out); 8316 xcb_parts[3].iov_base = 0; 8317 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8318 8319 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8320 return xcb_ret; 8321 } 8322 8323 8324 /***************************************************************************** 8325 ** 8326 ** xcb_glx_float32_t * xcb_glx_get_pixel_mapfv_data 8327 ** 8328 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8329 ** @returns xcb_glx_float32_t * 8330 ** 8331 *****************************************************************************/ 8332 8333 xcb_glx_float32_t * 8334 xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8335 { 8336 return (xcb_glx_float32_t *) (R + 1); 8337 } 8338 8339 8340 /***************************************************************************** 8341 ** 8342 ** int xcb_glx_get_pixel_mapfv_data_length 8343 ** 8344 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8345 ** @returns int 8346 ** 8347 *****************************************************************************/ 8348 8349 int 8350 xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8351 { 8352 return R->n; 8353 } 8354 8355 8356 /***************************************************************************** 8357 ** 8358 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapfv_data_end 8359 ** 8360 ** @param const xcb_glx_get_pixel_mapfv_reply_t *R 8361 ** @returns xcb_generic_iterator_t 8362 ** 8363 *****************************************************************************/ 8364 8365 xcb_generic_iterator_t 8366 xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) 8367 { 8368 xcb_generic_iterator_t i; 8369 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8370 i.rem = 0; 8371 i.index = (char *) i.data - (char *) R; 8372 return i; 8373 } 8374 8375 8376 /***************************************************************************** 8377 ** 8378 ** xcb_glx_get_pixel_mapfv_reply_t * xcb_glx_get_pixel_mapfv_reply 8379 ** 8380 ** @param xcb_connection_t *c 8381 ** @param xcb_glx_get_pixel_mapfv_cookie_t cookie 8382 ** @param xcb_generic_error_t **e 8383 ** @returns xcb_glx_get_pixel_mapfv_reply_t * 8384 ** 8385 *****************************************************************************/ 8386 8387 xcb_glx_get_pixel_mapfv_reply_t * 8388 xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c /**< */, 8389 xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, 8390 xcb_generic_error_t **e /**< */) 8391 { 8392 return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8393 } 8394 8395 int 8396 xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */) 8397 { 8398 char *xcb_tmp = (char *)_buffer; 8399 const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer; 8400 unsigned int xcb_buffer_len = 0; 8401 unsigned int xcb_block_len = 0; 8402 unsigned int xcb_pad = 0; 8403 unsigned int xcb_align_to = 0; 8404 8405 8406 xcb_block_len += sizeof(xcb_glx_get_pixel_mapuiv_reply_t); 8407 xcb_tmp += xcb_block_len; 8408 xcb_buffer_len += xcb_block_len; 8409 xcb_block_len = 0; 8410 /* data */ 8411 xcb_block_len += _aux->n * sizeof(uint32_t); 8412 xcb_tmp += xcb_block_len; 8413 xcb_align_to = ALIGNOF(uint32_t); 8414 /* insert padding */ 8415 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8416 xcb_buffer_len += xcb_block_len + xcb_pad; 8417 if (0 != xcb_pad) { 8418 xcb_tmp += xcb_pad; 8419 xcb_pad = 0; 8420 } 8421 xcb_block_len = 0; 8422 8423 return xcb_buffer_len; 8424 } 8425 8426 8427 /***************************************************************************** 8428 ** 8429 ** xcb_glx_get_pixel_mapuiv_cookie_t xcb_glx_get_pixel_mapuiv 8430 ** 8431 ** @param xcb_connection_t *c 8432 ** @param xcb_glx_context_tag_t context_tag 8433 ** @param uint32_t map 8434 ** @returns xcb_glx_get_pixel_mapuiv_cookie_t 8435 ** 8436 *****************************************************************************/ 8437 8438 xcb_glx_get_pixel_mapuiv_cookie_t 8439 xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, 8440 xcb_glx_context_tag_t context_tag /**< */, 8441 uint32_t map /**< */) 8442 { 8443 static const xcb_protocol_request_t xcb_req = { 8444 /* count */ 2, 8445 /* ext */ &xcb_glx_id, 8446 /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, 8447 /* isvoid */ 0 8448 }; 8449 8450 struct iovec xcb_parts[4]; 8451 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 8452 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 8453 8454 xcb_out.context_tag = context_tag; 8455 xcb_out.map = map; 8456 8457 xcb_parts[2].iov_base = (char *) &xcb_out; 8458 xcb_parts[2].iov_len = sizeof(xcb_out); 8459 xcb_parts[3].iov_base = 0; 8460 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8461 8462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8463 return xcb_ret; 8464 } 8465 8466 8467 /***************************************************************************** 8468 ** 8469 ** xcb_glx_get_pixel_mapuiv_cookie_t xcb_glx_get_pixel_mapuiv_unchecked 8470 ** 8471 ** @param xcb_connection_t *c 8472 ** @param xcb_glx_context_tag_t context_tag 8473 ** @param uint32_t map 8474 ** @returns xcb_glx_get_pixel_mapuiv_cookie_t 8475 ** 8476 *****************************************************************************/ 8477 8478 xcb_glx_get_pixel_mapuiv_cookie_t 8479 xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c /**< */, 8480 xcb_glx_context_tag_t context_tag /**< */, 8481 uint32_t map /**< */) 8482 { 8483 static const xcb_protocol_request_t xcb_req = { 8484 /* count */ 2, 8485 /* ext */ &xcb_glx_id, 8486 /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, 8487 /* isvoid */ 0 8488 }; 8489 8490 struct iovec xcb_parts[4]; 8491 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 8492 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 8493 8494 xcb_out.context_tag = context_tag; 8495 xcb_out.map = map; 8496 8497 xcb_parts[2].iov_base = (char *) &xcb_out; 8498 xcb_parts[2].iov_len = sizeof(xcb_out); 8499 xcb_parts[3].iov_base = 0; 8500 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8501 8502 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8503 return xcb_ret; 8504 } 8505 8506 8507 /***************************************************************************** 8508 ** 8509 ** uint32_t * xcb_glx_get_pixel_mapuiv_data 8510 ** 8511 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8512 ** @returns uint32_t * 8513 ** 8514 *****************************************************************************/ 8515 8516 uint32_t * 8517 xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8518 { 8519 return (uint32_t *) (R + 1); 8520 } 8521 8522 8523 /***************************************************************************** 8524 ** 8525 ** int xcb_glx_get_pixel_mapuiv_data_length 8526 ** 8527 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8528 ** @returns int 8529 ** 8530 *****************************************************************************/ 8531 8532 int 8533 xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8534 { 8535 return R->n; 8536 } 8537 8538 8539 /***************************************************************************** 8540 ** 8541 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapuiv_data_end 8542 ** 8543 ** @param const xcb_glx_get_pixel_mapuiv_reply_t *R 8544 ** @returns xcb_generic_iterator_t 8545 ** 8546 *****************************************************************************/ 8547 8548 xcb_generic_iterator_t 8549 xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) 8550 { 8551 xcb_generic_iterator_t i; 8552 i.data = ((uint32_t *) (R + 1)) + (R->n); 8553 i.rem = 0; 8554 i.index = (char *) i.data - (char *) R; 8555 return i; 8556 } 8557 8558 8559 /***************************************************************************** 8560 ** 8561 ** xcb_glx_get_pixel_mapuiv_reply_t * xcb_glx_get_pixel_mapuiv_reply 8562 ** 8563 ** @param xcb_connection_t *c 8564 ** @param xcb_glx_get_pixel_mapuiv_cookie_t cookie 8565 ** @param xcb_generic_error_t **e 8566 ** @returns xcb_glx_get_pixel_mapuiv_reply_t * 8567 ** 8568 *****************************************************************************/ 8569 8570 xcb_glx_get_pixel_mapuiv_reply_t * 8571 xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c /**< */, 8572 xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, 8573 xcb_generic_error_t **e /**< */) 8574 { 8575 return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8576 } 8577 8578 int 8579 xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */) 8580 { 8581 char *xcb_tmp = (char *)_buffer; 8582 const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer; 8583 unsigned int xcb_buffer_len = 0; 8584 unsigned int xcb_block_len = 0; 8585 unsigned int xcb_pad = 0; 8586 unsigned int xcb_align_to = 0; 8587 8588 8589 xcb_block_len += sizeof(xcb_glx_get_pixel_mapusv_reply_t); 8590 xcb_tmp += xcb_block_len; 8591 xcb_buffer_len += xcb_block_len; 8592 xcb_block_len = 0; 8593 /* data */ 8594 xcb_block_len += _aux->n * sizeof(uint16_t); 8595 xcb_tmp += xcb_block_len; 8596 xcb_align_to = ALIGNOF(uint16_t); 8597 /* insert padding */ 8598 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8599 xcb_buffer_len += xcb_block_len + xcb_pad; 8600 if (0 != xcb_pad) { 8601 xcb_tmp += xcb_pad; 8602 xcb_pad = 0; 8603 } 8604 xcb_block_len = 0; 8605 8606 return xcb_buffer_len; 8607 } 8608 8609 8610 /***************************************************************************** 8611 ** 8612 ** xcb_glx_get_pixel_mapusv_cookie_t xcb_glx_get_pixel_mapusv 8613 ** 8614 ** @param xcb_connection_t *c 8615 ** @param xcb_glx_context_tag_t context_tag 8616 ** @param uint32_t map 8617 ** @returns xcb_glx_get_pixel_mapusv_cookie_t 8618 ** 8619 *****************************************************************************/ 8620 8621 xcb_glx_get_pixel_mapusv_cookie_t 8622 xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, 8623 xcb_glx_context_tag_t context_tag /**< */, 8624 uint32_t map /**< */) 8625 { 8626 static const xcb_protocol_request_t xcb_req = { 8627 /* count */ 2, 8628 /* ext */ &xcb_glx_id, 8629 /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, 8630 /* isvoid */ 0 8631 }; 8632 8633 struct iovec xcb_parts[4]; 8634 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 8635 xcb_glx_get_pixel_mapusv_request_t xcb_out; 8636 8637 xcb_out.context_tag = context_tag; 8638 xcb_out.map = map; 8639 8640 xcb_parts[2].iov_base = (char *) &xcb_out; 8641 xcb_parts[2].iov_len = sizeof(xcb_out); 8642 xcb_parts[3].iov_base = 0; 8643 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8644 8645 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8646 return xcb_ret; 8647 } 8648 8649 8650 /***************************************************************************** 8651 ** 8652 ** xcb_glx_get_pixel_mapusv_cookie_t xcb_glx_get_pixel_mapusv_unchecked 8653 ** 8654 ** @param xcb_connection_t *c 8655 ** @param xcb_glx_context_tag_t context_tag 8656 ** @param uint32_t map 8657 ** @returns xcb_glx_get_pixel_mapusv_cookie_t 8658 ** 8659 *****************************************************************************/ 8660 8661 xcb_glx_get_pixel_mapusv_cookie_t 8662 xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c /**< */, 8663 xcb_glx_context_tag_t context_tag /**< */, 8664 uint32_t map /**< */) 8665 { 8666 static const xcb_protocol_request_t xcb_req = { 8667 /* count */ 2, 8668 /* ext */ &xcb_glx_id, 8669 /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, 8670 /* isvoid */ 0 8671 }; 8672 8673 struct iovec xcb_parts[4]; 8674 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 8675 xcb_glx_get_pixel_mapusv_request_t xcb_out; 8676 8677 xcb_out.context_tag = context_tag; 8678 xcb_out.map = map; 8679 8680 xcb_parts[2].iov_base = (char *) &xcb_out; 8681 xcb_parts[2].iov_len = sizeof(xcb_out); 8682 xcb_parts[3].iov_base = 0; 8683 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8684 8685 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8686 return xcb_ret; 8687 } 8688 8689 8690 /***************************************************************************** 8691 ** 8692 ** uint16_t * xcb_glx_get_pixel_mapusv_data 8693 ** 8694 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8695 ** @returns uint16_t * 8696 ** 8697 *****************************************************************************/ 8698 8699 uint16_t * 8700 xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8701 { 8702 return (uint16_t *) (R + 1); 8703 } 8704 8705 8706 /***************************************************************************** 8707 ** 8708 ** int xcb_glx_get_pixel_mapusv_data_length 8709 ** 8710 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8711 ** @returns int 8712 ** 8713 *****************************************************************************/ 8714 8715 int 8716 xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8717 { 8718 return R->n; 8719 } 8720 8721 8722 /***************************************************************************** 8723 ** 8724 ** xcb_generic_iterator_t xcb_glx_get_pixel_mapusv_data_end 8725 ** 8726 ** @param const xcb_glx_get_pixel_mapusv_reply_t *R 8727 ** @returns xcb_generic_iterator_t 8728 ** 8729 *****************************************************************************/ 8730 8731 xcb_generic_iterator_t 8732 xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) 8733 { 8734 xcb_generic_iterator_t i; 8735 i.data = ((uint16_t *) (R + 1)) + (R->n); 8736 i.rem = 0; 8737 i.index = (char *) i.data - (char *) R; 8738 return i; 8739 } 8740 8741 8742 /***************************************************************************** 8743 ** 8744 ** xcb_glx_get_pixel_mapusv_reply_t * xcb_glx_get_pixel_mapusv_reply 8745 ** 8746 ** @param xcb_connection_t *c 8747 ** @param xcb_glx_get_pixel_mapusv_cookie_t cookie 8748 ** @param xcb_generic_error_t **e 8749 ** @returns xcb_glx_get_pixel_mapusv_reply_t * 8750 ** 8751 *****************************************************************************/ 8752 8753 xcb_glx_get_pixel_mapusv_reply_t * 8754 xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c /**< */, 8755 xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, 8756 xcb_generic_error_t **e /**< */) 8757 { 8758 return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8759 } 8760 8761 int 8762 xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */) 8763 { 8764 char *xcb_tmp = (char *)_buffer; 8765 const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer; 8766 unsigned int xcb_buffer_len = 0; 8767 unsigned int xcb_block_len = 0; 8768 unsigned int xcb_pad = 0; 8769 unsigned int xcb_align_to = 0; 8770 8771 8772 xcb_block_len += sizeof(xcb_glx_get_polygon_stipple_reply_t); 8773 xcb_tmp += xcb_block_len; 8774 xcb_buffer_len += xcb_block_len; 8775 xcb_block_len = 0; 8776 /* data */ 8777 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8778 xcb_tmp += xcb_block_len; 8779 xcb_align_to = ALIGNOF(uint8_t); 8780 /* insert padding */ 8781 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8782 xcb_buffer_len += xcb_block_len + xcb_pad; 8783 if (0 != xcb_pad) { 8784 xcb_tmp += xcb_pad; 8785 xcb_pad = 0; 8786 } 8787 xcb_block_len = 0; 8788 8789 return xcb_buffer_len; 8790 } 8791 8792 8793 /***************************************************************************** 8794 ** 8795 ** xcb_glx_get_polygon_stipple_cookie_t xcb_glx_get_polygon_stipple 8796 ** 8797 ** @param xcb_connection_t *c 8798 ** @param xcb_glx_context_tag_t context_tag 8799 ** @param uint8_t lsb_first 8800 ** @returns xcb_glx_get_polygon_stipple_cookie_t 8801 ** 8802 *****************************************************************************/ 8803 8804 xcb_glx_get_polygon_stipple_cookie_t 8805 xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, 8806 xcb_glx_context_tag_t context_tag /**< */, 8807 uint8_t lsb_first /**< */) 8808 { 8809 static const xcb_protocol_request_t xcb_req = { 8810 /* count */ 2, 8811 /* ext */ &xcb_glx_id, 8812 /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, 8813 /* isvoid */ 0 8814 }; 8815 8816 struct iovec xcb_parts[4]; 8817 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 8818 xcb_glx_get_polygon_stipple_request_t xcb_out; 8819 8820 xcb_out.context_tag = context_tag; 8821 xcb_out.lsb_first = lsb_first; 8822 8823 xcb_parts[2].iov_base = (char *) &xcb_out; 8824 xcb_parts[2].iov_len = sizeof(xcb_out); 8825 xcb_parts[3].iov_base = 0; 8826 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8827 8828 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8829 return xcb_ret; 8830 } 8831 8832 8833 /***************************************************************************** 8834 ** 8835 ** xcb_glx_get_polygon_stipple_cookie_t xcb_glx_get_polygon_stipple_unchecked 8836 ** 8837 ** @param xcb_connection_t *c 8838 ** @param xcb_glx_context_tag_t context_tag 8839 ** @param uint8_t lsb_first 8840 ** @returns xcb_glx_get_polygon_stipple_cookie_t 8841 ** 8842 *****************************************************************************/ 8843 8844 xcb_glx_get_polygon_stipple_cookie_t 8845 xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c /**< */, 8846 xcb_glx_context_tag_t context_tag /**< */, 8847 uint8_t lsb_first /**< */) 8848 { 8849 static const xcb_protocol_request_t xcb_req = { 8850 /* count */ 2, 8851 /* ext */ &xcb_glx_id, 8852 /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, 8853 /* isvoid */ 0 8854 }; 8855 8856 struct iovec xcb_parts[4]; 8857 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 8858 xcb_glx_get_polygon_stipple_request_t xcb_out; 8859 8860 xcb_out.context_tag = context_tag; 8861 xcb_out.lsb_first = lsb_first; 8862 8863 xcb_parts[2].iov_base = (char *) &xcb_out; 8864 xcb_parts[2].iov_len = sizeof(xcb_out); 8865 xcb_parts[3].iov_base = 0; 8866 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8867 8868 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8869 return xcb_ret; 8870 } 8871 8872 8873 /***************************************************************************** 8874 ** 8875 ** uint8_t * xcb_glx_get_polygon_stipple_data 8876 ** 8877 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8878 ** @returns uint8_t * 8879 ** 8880 *****************************************************************************/ 8881 8882 uint8_t * 8883 xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8884 { 8885 return (uint8_t *) (R + 1); 8886 } 8887 8888 8889 /***************************************************************************** 8890 ** 8891 ** int xcb_glx_get_polygon_stipple_data_length 8892 ** 8893 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8894 ** @returns int 8895 ** 8896 *****************************************************************************/ 8897 8898 int 8899 xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8900 { 8901 return (R->length * 4); 8902 } 8903 8904 8905 /***************************************************************************** 8906 ** 8907 ** xcb_generic_iterator_t xcb_glx_get_polygon_stipple_data_end 8908 ** 8909 ** @param const xcb_glx_get_polygon_stipple_reply_t *R 8910 ** @returns xcb_generic_iterator_t 8911 ** 8912 *****************************************************************************/ 8913 8914 xcb_generic_iterator_t 8915 xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) 8916 { 8917 xcb_generic_iterator_t i; 8918 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8919 i.rem = 0; 8920 i.index = (char *) i.data - (char *) R; 8921 return i; 8922 } 8923 8924 8925 /***************************************************************************** 8926 ** 8927 ** xcb_glx_get_polygon_stipple_reply_t * xcb_glx_get_polygon_stipple_reply 8928 ** 8929 ** @param xcb_connection_t *c 8930 ** @param xcb_glx_get_polygon_stipple_cookie_t cookie 8931 ** @param xcb_generic_error_t **e 8932 ** @returns xcb_glx_get_polygon_stipple_reply_t * 8933 ** 8934 *****************************************************************************/ 8935 8936 xcb_glx_get_polygon_stipple_reply_t * 8937 xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c /**< */, 8938 xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, 8939 xcb_generic_error_t **e /**< */) 8940 { 8941 return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8942 } 8943 8944 int 8945 xcb_glx_get_string_sizeof (const void *_buffer /**< */) 8946 { 8947 char *xcb_tmp = (char *)_buffer; 8948 const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer; 8949 unsigned int xcb_buffer_len = 0; 8950 unsigned int xcb_block_len = 0; 8951 unsigned int xcb_pad = 0; 8952 unsigned int xcb_align_to = 0; 8953 8954 8955 xcb_block_len += sizeof(xcb_glx_get_string_reply_t); 8956 xcb_tmp += xcb_block_len; 8957 xcb_buffer_len += xcb_block_len; 8958 xcb_block_len = 0; 8959 /* string */ 8960 xcb_block_len += _aux->n * sizeof(char); 8961 xcb_tmp += xcb_block_len; 8962 xcb_align_to = ALIGNOF(char); 8963 /* insert padding */ 8964 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8965 xcb_buffer_len += xcb_block_len + xcb_pad; 8966 if (0 != xcb_pad) { 8967 xcb_tmp += xcb_pad; 8968 xcb_pad = 0; 8969 } 8970 xcb_block_len = 0; 8971 8972 return xcb_buffer_len; 8973 } 8974 8975 8976 /***************************************************************************** 8977 ** 8978 ** xcb_glx_get_string_cookie_t xcb_glx_get_string 8979 ** 8980 ** @param xcb_connection_t *c 8981 ** @param xcb_glx_context_tag_t context_tag 8982 ** @param uint32_t name 8983 ** @returns xcb_glx_get_string_cookie_t 8984 ** 8985 *****************************************************************************/ 8986 8987 xcb_glx_get_string_cookie_t 8988 xcb_glx_get_string (xcb_connection_t *c /**< */, 8989 xcb_glx_context_tag_t context_tag /**< */, 8990 uint32_t name /**< */) 8991 { 8992 static const xcb_protocol_request_t xcb_req = { 8993 /* count */ 2, 8994 /* ext */ &xcb_glx_id, 8995 /* opcode */ XCB_GLX_GET_STRING, 8996 /* isvoid */ 0 8997 }; 8998 8999 struct iovec xcb_parts[4]; 9000 xcb_glx_get_string_cookie_t xcb_ret; 9001 xcb_glx_get_string_request_t xcb_out; 9002 9003 xcb_out.context_tag = context_tag; 9004 xcb_out.name = name; 9005 9006 xcb_parts[2].iov_base = (char *) &xcb_out; 9007 xcb_parts[2].iov_len = sizeof(xcb_out); 9008 xcb_parts[3].iov_base = 0; 9009 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9010 9011 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9012 return xcb_ret; 9013 } 9014 9015 9016 /***************************************************************************** 9017 ** 9018 ** xcb_glx_get_string_cookie_t xcb_glx_get_string_unchecked 9019 ** 9020 ** @param xcb_connection_t *c 9021 ** @param xcb_glx_context_tag_t context_tag 9022 ** @param uint32_t name 9023 ** @returns xcb_glx_get_string_cookie_t 9024 ** 9025 *****************************************************************************/ 9026 9027 xcb_glx_get_string_cookie_t 9028 xcb_glx_get_string_unchecked (xcb_connection_t *c /**< */, 9029 xcb_glx_context_tag_t context_tag /**< */, 9030 uint32_t name /**< */) 9031 { 9032 static const xcb_protocol_request_t xcb_req = { 9033 /* count */ 2, 9034 /* ext */ &xcb_glx_id, 9035 /* opcode */ XCB_GLX_GET_STRING, 9036 /* isvoid */ 0 9037 }; 9038 9039 struct iovec xcb_parts[4]; 9040 xcb_glx_get_string_cookie_t xcb_ret; 9041 xcb_glx_get_string_request_t xcb_out; 9042 9043 xcb_out.context_tag = context_tag; 9044 xcb_out.name = name; 9045 9046 xcb_parts[2].iov_base = (char *) &xcb_out; 9047 xcb_parts[2].iov_len = sizeof(xcb_out); 9048 xcb_parts[3].iov_base = 0; 9049 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9050 9051 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9052 return xcb_ret; 9053 } 9054 9055 9056 /***************************************************************************** 9057 ** 9058 ** char * xcb_glx_get_string_string 9059 ** 9060 ** @param const xcb_glx_get_string_reply_t *R 9061 ** @returns char * 9062 ** 9063 *****************************************************************************/ 9064 9065 char * 9066 xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R /**< */) 9067 { 9068 return (char *) (R + 1); 9069 } 9070 9071 9072 /***************************************************************************** 9073 ** 9074 ** int xcb_glx_get_string_string_length 9075 ** 9076 ** @param const xcb_glx_get_string_reply_t *R 9077 ** @returns int 9078 ** 9079 *****************************************************************************/ 9080 9081 int 9082 xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R /**< */) 9083 { 9084 return R->n; 9085 } 9086 9087 9088 /***************************************************************************** 9089 ** 9090 ** xcb_generic_iterator_t xcb_glx_get_string_string_end 9091 ** 9092 ** @param const xcb_glx_get_string_reply_t *R 9093 ** @returns xcb_generic_iterator_t 9094 ** 9095 *****************************************************************************/ 9096 9097 xcb_generic_iterator_t 9098 xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */) 9099 { 9100 xcb_generic_iterator_t i; 9101 i.data = ((char *) (R + 1)) + (R->n); 9102 i.rem = 0; 9103 i.index = (char *) i.data - (char *) R; 9104 return i; 9105 } 9106 9107 9108 /***************************************************************************** 9109 ** 9110 ** xcb_glx_get_string_reply_t * xcb_glx_get_string_reply 9111 ** 9112 ** @param xcb_connection_t *c 9113 ** @param xcb_glx_get_string_cookie_t cookie 9114 ** @param xcb_generic_error_t **e 9115 ** @returns xcb_glx_get_string_reply_t * 9116 ** 9117 *****************************************************************************/ 9118 9119 xcb_glx_get_string_reply_t * 9120 xcb_glx_get_string_reply (xcb_connection_t *c /**< */, 9121 xcb_glx_get_string_cookie_t cookie /**< */, 9122 xcb_generic_error_t **e /**< */) 9123 { 9124 return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9125 } 9126 9127 int 9128 xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */) 9129 { 9130 char *xcb_tmp = (char *)_buffer; 9131 const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer; 9132 unsigned int xcb_buffer_len = 0; 9133 unsigned int xcb_block_len = 0; 9134 unsigned int xcb_pad = 0; 9135 unsigned int xcb_align_to = 0; 9136 9137 9138 xcb_block_len += sizeof(xcb_glx_get_tex_envfv_reply_t); 9139 xcb_tmp += xcb_block_len; 9140 xcb_buffer_len += xcb_block_len; 9141 xcb_block_len = 0; 9142 /* data */ 9143 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9144 xcb_tmp += xcb_block_len; 9145 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9146 /* insert padding */ 9147 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9148 xcb_buffer_len += xcb_block_len + xcb_pad; 9149 if (0 != xcb_pad) { 9150 xcb_tmp += xcb_pad; 9151 xcb_pad = 0; 9152 } 9153 xcb_block_len = 0; 9154 9155 return xcb_buffer_len; 9156 } 9157 9158 9159 /***************************************************************************** 9160 ** 9161 ** xcb_glx_get_tex_envfv_cookie_t xcb_glx_get_tex_envfv 9162 ** 9163 ** @param xcb_connection_t *c 9164 ** @param xcb_glx_context_tag_t context_tag 9165 ** @param uint32_t target 9166 ** @param uint32_t pname 9167 ** @returns xcb_glx_get_tex_envfv_cookie_t 9168 ** 9169 *****************************************************************************/ 9170 9171 xcb_glx_get_tex_envfv_cookie_t 9172 xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, 9173 xcb_glx_context_tag_t context_tag /**< */, 9174 uint32_t target /**< */, 9175 uint32_t pname /**< */) 9176 { 9177 static const xcb_protocol_request_t xcb_req = { 9178 /* count */ 2, 9179 /* ext */ &xcb_glx_id, 9180 /* opcode */ XCB_GLX_GET_TEX_ENVFV, 9181 /* isvoid */ 0 9182 }; 9183 9184 struct iovec xcb_parts[4]; 9185 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 9186 xcb_glx_get_tex_envfv_request_t xcb_out; 9187 9188 xcb_out.context_tag = context_tag; 9189 xcb_out.target = target; 9190 xcb_out.pname = pname; 9191 9192 xcb_parts[2].iov_base = (char *) &xcb_out; 9193 xcb_parts[2].iov_len = sizeof(xcb_out); 9194 xcb_parts[3].iov_base = 0; 9195 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9196 9197 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9198 return xcb_ret; 9199 } 9200 9201 9202 /***************************************************************************** 9203 ** 9204 ** xcb_glx_get_tex_envfv_cookie_t xcb_glx_get_tex_envfv_unchecked 9205 ** 9206 ** @param xcb_connection_t *c 9207 ** @param xcb_glx_context_tag_t context_tag 9208 ** @param uint32_t target 9209 ** @param uint32_t pname 9210 ** @returns xcb_glx_get_tex_envfv_cookie_t 9211 ** 9212 *****************************************************************************/ 9213 9214 xcb_glx_get_tex_envfv_cookie_t 9215 xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c /**< */, 9216 xcb_glx_context_tag_t context_tag /**< */, 9217 uint32_t target /**< */, 9218 uint32_t pname /**< */) 9219 { 9220 static const xcb_protocol_request_t xcb_req = { 9221 /* count */ 2, 9222 /* ext */ &xcb_glx_id, 9223 /* opcode */ XCB_GLX_GET_TEX_ENVFV, 9224 /* isvoid */ 0 9225 }; 9226 9227 struct iovec xcb_parts[4]; 9228 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 9229 xcb_glx_get_tex_envfv_request_t xcb_out; 9230 9231 xcb_out.context_tag = context_tag; 9232 xcb_out.target = target; 9233 xcb_out.pname = pname; 9234 9235 xcb_parts[2].iov_base = (char *) &xcb_out; 9236 xcb_parts[2].iov_len = sizeof(xcb_out); 9237 xcb_parts[3].iov_base = 0; 9238 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9239 9240 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9241 return xcb_ret; 9242 } 9243 9244 9245 /***************************************************************************** 9246 ** 9247 ** xcb_glx_float32_t * xcb_glx_get_tex_envfv_data 9248 ** 9249 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9250 ** @returns xcb_glx_float32_t * 9251 ** 9252 *****************************************************************************/ 9253 9254 xcb_glx_float32_t * 9255 xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9256 { 9257 return (xcb_glx_float32_t *) (R + 1); 9258 } 9259 9260 9261 /***************************************************************************** 9262 ** 9263 ** int xcb_glx_get_tex_envfv_data_length 9264 ** 9265 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9266 ** @returns int 9267 ** 9268 *****************************************************************************/ 9269 9270 int 9271 xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9272 { 9273 return R->n; 9274 } 9275 9276 9277 /***************************************************************************** 9278 ** 9279 ** xcb_generic_iterator_t xcb_glx_get_tex_envfv_data_end 9280 ** 9281 ** @param const xcb_glx_get_tex_envfv_reply_t *R 9282 ** @returns xcb_generic_iterator_t 9283 ** 9284 *****************************************************************************/ 9285 9286 xcb_generic_iterator_t 9287 xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */) 9288 { 9289 xcb_generic_iterator_t i; 9290 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9291 i.rem = 0; 9292 i.index = (char *) i.data - (char *) R; 9293 return i; 9294 } 9295 9296 9297 /***************************************************************************** 9298 ** 9299 ** xcb_glx_get_tex_envfv_reply_t * xcb_glx_get_tex_envfv_reply 9300 ** 9301 ** @param xcb_connection_t *c 9302 ** @param xcb_glx_get_tex_envfv_cookie_t cookie 9303 ** @param xcb_generic_error_t **e 9304 ** @returns xcb_glx_get_tex_envfv_reply_t * 9305 ** 9306 *****************************************************************************/ 9307 9308 xcb_glx_get_tex_envfv_reply_t * 9309 xcb_glx_get_tex_envfv_reply (xcb_connection_t *c /**< */, 9310 xcb_glx_get_tex_envfv_cookie_t cookie /**< */, 9311 xcb_generic_error_t **e /**< */) 9312 { 9313 return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9314 } 9315 9316 int 9317 xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */) 9318 { 9319 char *xcb_tmp = (char *)_buffer; 9320 const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer; 9321 unsigned int xcb_buffer_len = 0; 9322 unsigned int xcb_block_len = 0; 9323 unsigned int xcb_pad = 0; 9324 unsigned int xcb_align_to = 0; 9325 9326 9327 xcb_block_len += sizeof(xcb_glx_get_tex_enviv_reply_t); 9328 xcb_tmp += xcb_block_len; 9329 xcb_buffer_len += xcb_block_len; 9330 xcb_block_len = 0; 9331 /* data */ 9332 xcb_block_len += _aux->n * sizeof(int32_t); 9333 xcb_tmp += xcb_block_len; 9334 xcb_align_to = ALIGNOF(int32_t); 9335 /* insert padding */ 9336 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9337 xcb_buffer_len += xcb_block_len + xcb_pad; 9338 if (0 != xcb_pad) { 9339 xcb_tmp += xcb_pad; 9340 xcb_pad = 0; 9341 } 9342 xcb_block_len = 0; 9343 9344 return xcb_buffer_len; 9345 } 9346 9347 9348 /***************************************************************************** 9349 ** 9350 ** xcb_glx_get_tex_enviv_cookie_t xcb_glx_get_tex_enviv 9351 ** 9352 ** @param xcb_connection_t *c 9353 ** @param xcb_glx_context_tag_t context_tag 9354 ** @param uint32_t target 9355 ** @param uint32_t pname 9356 ** @returns xcb_glx_get_tex_enviv_cookie_t 9357 ** 9358 *****************************************************************************/ 9359 9360 xcb_glx_get_tex_enviv_cookie_t 9361 xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, 9362 xcb_glx_context_tag_t context_tag /**< */, 9363 uint32_t target /**< */, 9364 uint32_t pname /**< */) 9365 { 9366 static const xcb_protocol_request_t xcb_req = { 9367 /* count */ 2, 9368 /* ext */ &xcb_glx_id, 9369 /* opcode */ XCB_GLX_GET_TEX_ENVIV, 9370 /* isvoid */ 0 9371 }; 9372 9373 struct iovec xcb_parts[4]; 9374 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 9375 xcb_glx_get_tex_enviv_request_t xcb_out; 9376 9377 xcb_out.context_tag = context_tag; 9378 xcb_out.target = target; 9379 xcb_out.pname = pname; 9380 9381 xcb_parts[2].iov_base = (char *) &xcb_out; 9382 xcb_parts[2].iov_len = sizeof(xcb_out); 9383 xcb_parts[3].iov_base = 0; 9384 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9385 9386 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9387 return xcb_ret; 9388 } 9389 9390 9391 /***************************************************************************** 9392 ** 9393 ** xcb_glx_get_tex_enviv_cookie_t xcb_glx_get_tex_enviv_unchecked 9394 ** 9395 ** @param xcb_connection_t *c 9396 ** @param xcb_glx_context_tag_t context_tag 9397 ** @param uint32_t target 9398 ** @param uint32_t pname 9399 ** @returns xcb_glx_get_tex_enviv_cookie_t 9400 ** 9401 *****************************************************************************/ 9402 9403 xcb_glx_get_tex_enviv_cookie_t 9404 xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c /**< */, 9405 xcb_glx_context_tag_t context_tag /**< */, 9406 uint32_t target /**< */, 9407 uint32_t pname /**< */) 9408 { 9409 static const xcb_protocol_request_t xcb_req = { 9410 /* count */ 2, 9411 /* ext */ &xcb_glx_id, 9412 /* opcode */ XCB_GLX_GET_TEX_ENVIV, 9413 /* isvoid */ 0 9414 }; 9415 9416 struct iovec xcb_parts[4]; 9417 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 9418 xcb_glx_get_tex_enviv_request_t xcb_out; 9419 9420 xcb_out.context_tag = context_tag; 9421 xcb_out.target = target; 9422 xcb_out.pname = pname; 9423 9424 xcb_parts[2].iov_base = (char *) &xcb_out; 9425 xcb_parts[2].iov_len = sizeof(xcb_out); 9426 xcb_parts[3].iov_base = 0; 9427 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9428 9429 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9430 return xcb_ret; 9431 } 9432 9433 9434 /***************************************************************************** 9435 ** 9436 ** int32_t * xcb_glx_get_tex_enviv_data 9437 ** 9438 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9439 ** @returns int32_t * 9440 ** 9441 *****************************************************************************/ 9442 9443 int32_t * 9444 xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9445 { 9446 return (int32_t *) (R + 1); 9447 } 9448 9449 9450 /***************************************************************************** 9451 ** 9452 ** int xcb_glx_get_tex_enviv_data_length 9453 ** 9454 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9455 ** @returns int 9456 ** 9457 *****************************************************************************/ 9458 9459 int 9460 xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9461 { 9462 return R->n; 9463 } 9464 9465 9466 /***************************************************************************** 9467 ** 9468 ** xcb_generic_iterator_t xcb_glx_get_tex_enviv_data_end 9469 ** 9470 ** @param const xcb_glx_get_tex_enviv_reply_t *R 9471 ** @returns xcb_generic_iterator_t 9472 ** 9473 *****************************************************************************/ 9474 9475 xcb_generic_iterator_t 9476 xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */) 9477 { 9478 xcb_generic_iterator_t i; 9479 i.data = ((int32_t *) (R + 1)) + (R->n); 9480 i.rem = 0; 9481 i.index = (char *) i.data - (char *) R; 9482 return i; 9483 } 9484 9485 9486 /***************************************************************************** 9487 ** 9488 ** xcb_glx_get_tex_enviv_reply_t * xcb_glx_get_tex_enviv_reply 9489 ** 9490 ** @param xcb_connection_t *c 9491 ** @param xcb_glx_get_tex_enviv_cookie_t cookie 9492 ** @param xcb_generic_error_t **e 9493 ** @returns xcb_glx_get_tex_enviv_reply_t * 9494 ** 9495 *****************************************************************************/ 9496 9497 xcb_glx_get_tex_enviv_reply_t * 9498 xcb_glx_get_tex_enviv_reply (xcb_connection_t *c /**< */, 9499 xcb_glx_get_tex_enviv_cookie_t cookie /**< */, 9500 xcb_generic_error_t **e /**< */) 9501 { 9502 return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9503 } 9504 9505 int 9506 xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */) 9507 { 9508 char *xcb_tmp = (char *)_buffer; 9509 const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer; 9510 unsigned int xcb_buffer_len = 0; 9511 unsigned int xcb_block_len = 0; 9512 unsigned int xcb_pad = 0; 9513 unsigned int xcb_align_to = 0; 9514 9515 9516 xcb_block_len += sizeof(xcb_glx_get_tex_gendv_reply_t); 9517 xcb_tmp += xcb_block_len; 9518 xcb_buffer_len += xcb_block_len; 9519 xcb_block_len = 0; 9520 /* data */ 9521 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 9522 xcb_tmp += xcb_block_len; 9523 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 9524 /* insert padding */ 9525 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9526 xcb_buffer_len += xcb_block_len + xcb_pad; 9527 if (0 != xcb_pad) { 9528 xcb_tmp += xcb_pad; 9529 xcb_pad = 0; 9530 } 9531 xcb_block_len = 0; 9532 9533 return xcb_buffer_len; 9534 } 9535 9536 9537 /***************************************************************************** 9538 ** 9539 ** xcb_glx_get_tex_gendv_cookie_t xcb_glx_get_tex_gendv 9540 ** 9541 ** @param xcb_connection_t *c 9542 ** @param xcb_glx_context_tag_t context_tag 9543 ** @param uint32_t coord 9544 ** @param uint32_t pname 9545 ** @returns xcb_glx_get_tex_gendv_cookie_t 9546 ** 9547 *****************************************************************************/ 9548 9549 xcb_glx_get_tex_gendv_cookie_t 9550 xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, 9551 xcb_glx_context_tag_t context_tag /**< */, 9552 uint32_t coord /**< */, 9553 uint32_t pname /**< */) 9554 { 9555 static const xcb_protocol_request_t xcb_req = { 9556 /* count */ 2, 9557 /* ext */ &xcb_glx_id, 9558 /* opcode */ XCB_GLX_GET_TEX_GENDV, 9559 /* isvoid */ 0 9560 }; 9561 9562 struct iovec xcb_parts[4]; 9563 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 9564 xcb_glx_get_tex_gendv_request_t xcb_out; 9565 9566 xcb_out.context_tag = context_tag; 9567 xcb_out.coord = coord; 9568 xcb_out.pname = pname; 9569 9570 xcb_parts[2].iov_base = (char *) &xcb_out; 9571 xcb_parts[2].iov_len = sizeof(xcb_out); 9572 xcb_parts[3].iov_base = 0; 9573 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9574 9575 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9576 return xcb_ret; 9577 } 9578 9579 9580 /***************************************************************************** 9581 ** 9582 ** xcb_glx_get_tex_gendv_cookie_t xcb_glx_get_tex_gendv_unchecked 9583 ** 9584 ** @param xcb_connection_t *c 9585 ** @param xcb_glx_context_tag_t context_tag 9586 ** @param uint32_t coord 9587 ** @param uint32_t pname 9588 ** @returns xcb_glx_get_tex_gendv_cookie_t 9589 ** 9590 *****************************************************************************/ 9591 9592 xcb_glx_get_tex_gendv_cookie_t 9593 xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c /**< */, 9594 xcb_glx_context_tag_t context_tag /**< */, 9595 uint32_t coord /**< */, 9596 uint32_t pname /**< */) 9597 { 9598 static const xcb_protocol_request_t xcb_req = { 9599 /* count */ 2, 9600 /* ext */ &xcb_glx_id, 9601 /* opcode */ XCB_GLX_GET_TEX_GENDV, 9602 /* isvoid */ 0 9603 }; 9604 9605 struct iovec xcb_parts[4]; 9606 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 9607 xcb_glx_get_tex_gendv_request_t xcb_out; 9608 9609 xcb_out.context_tag = context_tag; 9610 xcb_out.coord = coord; 9611 xcb_out.pname = pname; 9612 9613 xcb_parts[2].iov_base = (char *) &xcb_out; 9614 xcb_parts[2].iov_len = sizeof(xcb_out); 9615 xcb_parts[3].iov_base = 0; 9616 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9617 9618 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9619 return xcb_ret; 9620 } 9621 9622 9623 /***************************************************************************** 9624 ** 9625 ** xcb_glx_float64_t * xcb_glx_get_tex_gendv_data 9626 ** 9627 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9628 ** @returns xcb_glx_float64_t * 9629 ** 9630 *****************************************************************************/ 9631 9632 xcb_glx_float64_t * 9633 xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9634 { 9635 return (xcb_glx_float64_t *) (R + 1); 9636 } 9637 9638 9639 /***************************************************************************** 9640 ** 9641 ** int xcb_glx_get_tex_gendv_data_length 9642 ** 9643 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9644 ** @returns int 9645 ** 9646 *****************************************************************************/ 9647 9648 int 9649 xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9650 { 9651 return R->n; 9652 } 9653 9654 9655 /***************************************************************************** 9656 ** 9657 ** xcb_generic_iterator_t xcb_glx_get_tex_gendv_data_end 9658 ** 9659 ** @param const xcb_glx_get_tex_gendv_reply_t *R 9660 ** @returns xcb_generic_iterator_t 9661 ** 9662 *****************************************************************************/ 9663 9664 xcb_generic_iterator_t 9665 xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */) 9666 { 9667 xcb_generic_iterator_t i; 9668 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 9669 i.rem = 0; 9670 i.index = (char *) i.data - (char *) R; 9671 return i; 9672 } 9673 9674 9675 /***************************************************************************** 9676 ** 9677 ** xcb_glx_get_tex_gendv_reply_t * xcb_glx_get_tex_gendv_reply 9678 ** 9679 ** @param xcb_connection_t *c 9680 ** @param xcb_glx_get_tex_gendv_cookie_t cookie 9681 ** @param xcb_generic_error_t **e 9682 ** @returns xcb_glx_get_tex_gendv_reply_t * 9683 ** 9684 *****************************************************************************/ 9685 9686 xcb_glx_get_tex_gendv_reply_t * 9687 xcb_glx_get_tex_gendv_reply (xcb_connection_t *c /**< */, 9688 xcb_glx_get_tex_gendv_cookie_t cookie /**< */, 9689 xcb_generic_error_t **e /**< */) 9690 { 9691 return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9692 } 9693 9694 int 9695 xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */) 9696 { 9697 char *xcb_tmp = (char *)_buffer; 9698 const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer; 9699 unsigned int xcb_buffer_len = 0; 9700 unsigned int xcb_block_len = 0; 9701 unsigned int xcb_pad = 0; 9702 unsigned int xcb_align_to = 0; 9703 9704 9705 xcb_block_len += sizeof(xcb_glx_get_tex_genfv_reply_t); 9706 xcb_tmp += xcb_block_len; 9707 xcb_buffer_len += xcb_block_len; 9708 xcb_block_len = 0; 9709 /* data */ 9710 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9711 xcb_tmp += xcb_block_len; 9712 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9713 /* insert padding */ 9714 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9715 xcb_buffer_len += xcb_block_len + xcb_pad; 9716 if (0 != xcb_pad) { 9717 xcb_tmp += xcb_pad; 9718 xcb_pad = 0; 9719 } 9720 xcb_block_len = 0; 9721 9722 return xcb_buffer_len; 9723 } 9724 9725 9726 /***************************************************************************** 9727 ** 9728 ** xcb_glx_get_tex_genfv_cookie_t xcb_glx_get_tex_genfv 9729 ** 9730 ** @param xcb_connection_t *c 9731 ** @param xcb_glx_context_tag_t context_tag 9732 ** @param uint32_t coord 9733 ** @param uint32_t pname 9734 ** @returns xcb_glx_get_tex_genfv_cookie_t 9735 ** 9736 *****************************************************************************/ 9737 9738 xcb_glx_get_tex_genfv_cookie_t 9739 xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, 9740 xcb_glx_context_tag_t context_tag /**< */, 9741 uint32_t coord /**< */, 9742 uint32_t pname /**< */) 9743 { 9744 static const xcb_protocol_request_t xcb_req = { 9745 /* count */ 2, 9746 /* ext */ &xcb_glx_id, 9747 /* opcode */ XCB_GLX_GET_TEX_GENFV, 9748 /* isvoid */ 0 9749 }; 9750 9751 struct iovec xcb_parts[4]; 9752 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 9753 xcb_glx_get_tex_genfv_request_t xcb_out; 9754 9755 xcb_out.context_tag = context_tag; 9756 xcb_out.coord = coord; 9757 xcb_out.pname = pname; 9758 9759 xcb_parts[2].iov_base = (char *) &xcb_out; 9760 xcb_parts[2].iov_len = sizeof(xcb_out); 9761 xcb_parts[3].iov_base = 0; 9762 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9763 9764 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9765 return xcb_ret; 9766 } 9767 9768 9769 /***************************************************************************** 9770 ** 9771 ** xcb_glx_get_tex_genfv_cookie_t xcb_glx_get_tex_genfv_unchecked 9772 ** 9773 ** @param xcb_connection_t *c 9774 ** @param xcb_glx_context_tag_t context_tag 9775 ** @param uint32_t coord 9776 ** @param uint32_t pname 9777 ** @returns xcb_glx_get_tex_genfv_cookie_t 9778 ** 9779 *****************************************************************************/ 9780 9781 xcb_glx_get_tex_genfv_cookie_t 9782 xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c /**< */, 9783 xcb_glx_context_tag_t context_tag /**< */, 9784 uint32_t coord /**< */, 9785 uint32_t pname /**< */) 9786 { 9787 static const xcb_protocol_request_t xcb_req = { 9788 /* count */ 2, 9789 /* ext */ &xcb_glx_id, 9790 /* opcode */ XCB_GLX_GET_TEX_GENFV, 9791 /* isvoid */ 0 9792 }; 9793 9794 struct iovec xcb_parts[4]; 9795 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 9796 xcb_glx_get_tex_genfv_request_t xcb_out; 9797 9798 xcb_out.context_tag = context_tag; 9799 xcb_out.coord = coord; 9800 xcb_out.pname = pname; 9801 9802 xcb_parts[2].iov_base = (char *) &xcb_out; 9803 xcb_parts[2].iov_len = sizeof(xcb_out); 9804 xcb_parts[3].iov_base = 0; 9805 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9806 9807 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9808 return xcb_ret; 9809 } 9810 9811 9812 /***************************************************************************** 9813 ** 9814 ** xcb_glx_float32_t * xcb_glx_get_tex_genfv_data 9815 ** 9816 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9817 ** @returns xcb_glx_float32_t * 9818 ** 9819 *****************************************************************************/ 9820 9821 xcb_glx_float32_t * 9822 xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9823 { 9824 return (xcb_glx_float32_t *) (R + 1); 9825 } 9826 9827 9828 /***************************************************************************** 9829 ** 9830 ** int xcb_glx_get_tex_genfv_data_length 9831 ** 9832 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9833 ** @returns int 9834 ** 9835 *****************************************************************************/ 9836 9837 int 9838 xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9839 { 9840 return R->n; 9841 } 9842 9843 9844 /***************************************************************************** 9845 ** 9846 ** xcb_generic_iterator_t xcb_glx_get_tex_genfv_data_end 9847 ** 9848 ** @param const xcb_glx_get_tex_genfv_reply_t *R 9849 ** @returns xcb_generic_iterator_t 9850 ** 9851 *****************************************************************************/ 9852 9853 xcb_generic_iterator_t 9854 xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */) 9855 { 9856 xcb_generic_iterator_t i; 9857 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9858 i.rem = 0; 9859 i.index = (char *) i.data - (char *) R; 9860 return i; 9861 } 9862 9863 9864 /***************************************************************************** 9865 ** 9866 ** xcb_glx_get_tex_genfv_reply_t * xcb_glx_get_tex_genfv_reply 9867 ** 9868 ** @param xcb_connection_t *c 9869 ** @param xcb_glx_get_tex_genfv_cookie_t cookie 9870 ** @param xcb_generic_error_t **e 9871 ** @returns xcb_glx_get_tex_genfv_reply_t * 9872 ** 9873 *****************************************************************************/ 9874 9875 xcb_glx_get_tex_genfv_reply_t * 9876 xcb_glx_get_tex_genfv_reply (xcb_connection_t *c /**< */, 9877 xcb_glx_get_tex_genfv_cookie_t cookie /**< */, 9878 xcb_generic_error_t **e /**< */) 9879 { 9880 return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9881 } 9882 9883 int 9884 xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */) 9885 { 9886 char *xcb_tmp = (char *)_buffer; 9887 const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer; 9888 unsigned int xcb_buffer_len = 0; 9889 unsigned int xcb_block_len = 0; 9890 unsigned int xcb_pad = 0; 9891 unsigned int xcb_align_to = 0; 9892 9893 9894 xcb_block_len += sizeof(xcb_glx_get_tex_geniv_reply_t); 9895 xcb_tmp += xcb_block_len; 9896 xcb_buffer_len += xcb_block_len; 9897 xcb_block_len = 0; 9898 /* data */ 9899 xcb_block_len += _aux->n * sizeof(int32_t); 9900 xcb_tmp += xcb_block_len; 9901 xcb_align_to = ALIGNOF(int32_t); 9902 /* insert padding */ 9903 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9904 xcb_buffer_len += xcb_block_len + xcb_pad; 9905 if (0 != xcb_pad) { 9906 xcb_tmp += xcb_pad; 9907 xcb_pad = 0; 9908 } 9909 xcb_block_len = 0; 9910 9911 return xcb_buffer_len; 9912 } 9913 9914 9915 /***************************************************************************** 9916 ** 9917 ** xcb_glx_get_tex_geniv_cookie_t xcb_glx_get_tex_geniv 9918 ** 9919 ** @param xcb_connection_t *c 9920 ** @param xcb_glx_context_tag_t context_tag 9921 ** @param uint32_t coord 9922 ** @param uint32_t pname 9923 ** @returns xcb_glx_get_tex_geniv_cookie_t 9924 ** 9925 *****************************************************************************/ 9926 9927 xcb_glx_get_tex_geniv_cookie_t 9928 xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, 9929 xcb_glx_context_tag_t context_tag /**< */, 9930 uint32_t coord /**< */, 9931 uint32_t pname /**< */) 9932 { 9933 static const xcb_protocol_request_t xcb_req = { 9934 /* count */ 2, 9935 /* ext */ &xcb_glx_id, 9936 /* opcode */ XCB_GLX_GET_TEX_GENIV, 9937 /* isvoid */ 0 9938 }; 9939 9940 struct iovec xcb_parts[4]; 9941 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 9942 xcb_glx_get_tex_geniv_request_t xcb_out; 9943 9944 xcb_out.context_tag = context_tag; 9945 xcb_out.coord = coord; 9946 xcb_out.pname = pname; 9947 9948 xcb_parts[2].iov_base = (char *) &xcb_out; 9949 xcb_parts[2].iov_len = sizeof(xcb_out); 9950 xcb_parts[3].iov_base = 0; 9951 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9952 9953 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9954 return xcb_ret; 9955 } 9956 9957 9958 /***************************************************************************** 9959 ** 9960 ** xcb_glx_get_tex_geniv_cookie_t xcb_glx_get_tex_geniv_unchecked 9961 ** 9962 ** @param xcb_connection_t *c 9963 ** @param xcb_glx_context_tag_t context_tag 9964 ** @param uint32_t coord 9965 ** @param uint32_t pname 9966 ** @returns xcb_glx_get_tex_geniv_cookie_t 9967 ** 9968 *****************************************************************************/ 9969 9970 xcb_glx_get_tex_geniv_cookie_t 9971 xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c /**< */, 9972 xcb_glx_context_tag_t context_tag /**< */, 9973 uint32_t coord /**< */, 9974 uint32_t pname /**< */) 9975 { 9976 static const xcb_protocol_request_t xcb_req = { 9977 /* count */ 2, 9978 /* ext */ &xcb_glx_id, 9979 /* opcode */ XCB_GLX_GET_TEX_GENIV, 9980 /* isvoid */ 0 9981 }; 9982 9983 struct iovec xcb_parts[4]; 9984 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 9985 xcb_glx_get_tex_geniv_request_t xcb_out; 9986 9987 xcb_out.context_tag = context_tag; 9988 xcb_out.coord = coord; 9989 xcb_out.pname = pname; 9990 9991 xcb_parts[2].iov_base = (char *) &xcb_out; 9992 xcb_parts[2].iov_len = sizeof(xcb_out); 9993 xcb_parts[3].iov_base = 0; 9994 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9995 9996 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9997 return xcb_ret; 9998 } 9999 10000 10001 /***************************************************************************** 10002 ** 10003 ** int32_t * xcb_glx_get_tex_geniv_data 10004 ** 10005 ** @param const xcb_glx_get_tex_geniv_reply_t *R 10006 ** @returns int32_t * 10007 ** 10008 *****************************************************************************/ 10009 10010 int32_t * 10011 xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 10012 { 10013 return (int32_t *) (R + 1); 10014 } 10015 10016 10017 /***************************************************************************** 10018 ** 10019 ** int xcb_glx_get_tex_geniv_data_length 10020 ** 10021 ** @param const xcb_glx_get_tex_geniv_reply_t *R 10022 ** @returns int 10023 ** 10024 *****************************************************************************/ 10025 10026 int 10027 xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 10028 { 10029 return R->n; 10030 } 10031 10032 10033 /***************************************************************************** 10034 ** 10035 ** xcb_generic_iterator_t xcb_glx_get_tex_geniv_data_end 10036 ** 10037 ** @param const xcb_glx_get_tex_geniv_reply_t *R 10038 ** @returns xcb_generic_iterator_t 10039 ** 10040 *****************************************************************************/ 10041 10042 xcb_generic_iterator_t 10043 xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */) 10044 { 10045 xcb_generic_iterator_t i; 10046 i.data = ((int32_t *) (R + 1)) + (R->n); 10047 i.rem = 0; 10048 i.index = (char *) i.data - (char *) R; 10049 return i; 10050 } 10051 10052 10053 /***************************************************************************** 10054 ** 10055 ** xcb_glx_get_tex_geniv_reply_t * xcb_glx_get_tex_geniv_reply 10056 ** 10057 ** @param xcb_connection_t *c 10058 ** @param xcb_glx_get_tex_geniv_cookie_t cookie 10059 ** @param xcb_generic_error_t **e 10060 ** @returns xcb_glx_get_tex_geniv_reply_t * 10061 ** 10062 *****************************************************************************/ 10063 10064 xcb_glx_get_tex_geniv_reply_t * 10065 xcb_glx_get_tex_geniv_reply (xcb_connection_t *c /**< */, 10066 xcb_glx_get_tex_geniv_cookie_t cookie /**< */, 10067 xcb_generic_error_t **e /**< */) 10068 { 10069 return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10070 } 10071 10072 int 10073 xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */) 10074 { 10075 char *xcb_tmp = (char *)_buffer; 10076 const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer; 10077 unsigned int xcb_buffer_len = 0; 10078 unsigned int xcb_block_len = 0; 10079 unsigned int xcb_pad = 0; 10080 unsigned int xcb_align_to = 0; 10081 10082 10083 xcb_block_len += sizeof(xcb_glx_get_tex_image_reply_t); 10084 xcb_tmp += xcb_block_len; 10085 xcb_buffer_len += xcb_block_len; 10086 xcb_block_len = 0; 10087 /* data */ 10088 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 10089 xcb_tmp += xcb_block_len; 10090 xcb_align_to = ALIGNOF(uint8_t); 10091 /* insert padding */ 10092 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10093 xcb_buffer_len += xcb_block_len + xcb_pad; 10094 if (0 != xcb_pad) { 10095 xcb_tmp += xcb_pad; 10096 xcb_pad = 0; 10097 } 10098 xcb_block_len = 0; 10099 10100 return xcb_buffer_len; 10101 } 10102 10103 10104 /***************************************************************************** 10105 ** 10106 ** xcb_glx_get_tex_image_cookie_t xcb_glx_get_tex_image 10107 ** 10108 ** @param xcb_connection_t *c 10109 ** @param xcb_glx_context_tag_t context_tag 10110 ** @param uint32_t target 10111 ** @param int32_t level 10112 ** @param uint32_t format 10113 ** @param uint32_t type 10114 ** @param uint8_t swap_bytes 10115 ** @returns xcb_glx_get_tex_image_cookie_t 10116 ** 10117 *****************************************************************************/ 10118 10119 xcb_glx_get_tex_image_cookie_t 10120 xcb_glx_get_tex_image (xcb_connection_t *c /**< */, 10121 xcb_glx_context_tag_t context_tag /**< */, 10122 uint32_t target /**< */, 10123 int32_t level /**< */, 10124 uint32_t format /**< */, 10125 uint32_t type /**< */, 10126 uint8_t swap_bytes /**< */) 10127 { 10128 static const xcb_protocol_request_t xcb_req = { 10129 /* count */ 2, 10130 /* ext */ &xcb_glx_id, 10131 /* opcode */ XCB_GLX_GET_TEX_IMAGE, 10132 /* isvoid */ 0 10133 }; 10134 10135 struct iovec xcb_parts[4]; 10136 xcb_glx_get_tex_image_cookie_t xcb_ret; 10137 xcb_glx_get_tex_image_request_t xcb_out; 10138 10139 xcb_out.context_tag = context_tag; 10140 xcb_out.target = target; 10141 xcb_out.level = level; 10142 xcb_out.format = format; 10143 xcb_out.type = type; 10144 xcb_out.swap_bytes = swap_bytes; 10145 10146 xcb_parts[2].iov_base = (char *) &xcb_out; 10147 xcb_parts[2].iov_len = sizeof(xcb_out); 10148 xcb_parts[3].iov_base = 0; 10149 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10150 10151 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10152 return xcb_ret; 10153 } 10154 10155 10156 /***************************************************************************** 10157 ** 10158 ** xcb_glx_get_tex_image_cookie_t xcb_glx_get_tex_image_unchecked 10159 ** 10160 ** @param xcb_connection_t *c 10161 ** @param xcb_glx_context_tag_t context_tag 10162 ** @param uint32_t target 10163 ** @param int32_t level 10164 ** @param uint32_t format 10165 ** @param uint32_t type 10166 ** @param uint8_t swap_bytes 10167 ** @returns xcb_glx_get_tex_image_cookie_t 10168 ** 10169 *****************************************************************************/ 10170 10171 xcb_glx_get_tex_image_cookie_t 10172 xcb_glx_get_tex_image_unchecked (xcb_connection_t *c /**< */, 10173 xcb_glx_context_tag_t context_tag /**< */, 10174 uint32_t target /**< */, 10175 int32_t level /**< */, 10176 uint32_t format /**< */, 10177 uint32_t type /**< */, 10178 uint8_t swap_bytes /**< */) 10179 { 10180 static const xcb_protocol_request_t xcb_req = { 10181 /* count */ 2, 10182 /* ext */ &xcb_glx_id, 10183 /* opcode */ XCB_GLX_GET_TEX_IMAGE, 10184 /* isvoid */ 0 10185 }; 10186 10187 struct iovec xcb_parts[4]; 10188 xcb_glx_get_tex_image_cookie_t xcb_ret; 10189 xcb_glx_get_tex_image_request_t xcb_out; 10190 10191 xcb_out.context_tag = context_tag; 10192 xcb_out.target = target; 10193 xcb_out.level = level; 10194 xcb_out.format = format; 10195 xcb_out.type = type; 10196 xcb_out.swap_bytes = swap_bytes; 10197 10198 xcb_parts[2].iov_base = (char *) &xcb_out; 10199 xcb_parts[2].iov_len = sizeof(xcb_out); 10200 xcb_parts[3].iov_base = 0; 10201 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10202 10203 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10204 return xcb_ret; 10205 } 10206 10207 10208 /***************************************************************************** 10209 ** 10210 ** uint8_t * xcb_glx_get_tex_image_data 10211 ** 10212 ** @param const xcb_glx_get_tex_image_reply_t *R 10213 ** @returns uint8_t * 10214 ** 10215 *****************************************************************************/ 10216 10217 uint8_t * 10218 xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R /**< */) 10219 { 10220 return (uint8_t *) (R + 1); 10221 } 10222 10223 10224 /***************************************************************************** 10225 ** 10226 ** int xcb_glx_get_tex_image_data_length 10227 ** 10228 ** @param const xcb_glx_get_tex_image_reply_t *R 10229 ** @returns int 10230 ** 10231 *****************************************************************************/ 10232 10233 int 10234 xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R /**< */) 10235 { 10236 return (R->length * 4); 10237 } 10238 10239 10240 /***************************************************************************** 10241 ** 10242 ** xcb_generic_iterator_t xcb_glx_get_tex_image_data_end 10243 ** 10244 ** @param const xcb_glx_get_tex_image_reply_t *R 10245 ** @returns xcb_generic_iterator_t 10246 ** 10247 *****************************************************************************/ 10248 10249 xcb_generic_iterator_t 10250 xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */) 10251 { 10252 xcb_generic_iterator_t i; 10253 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 10254 i.rem = 0; 10255 i.index = (char *) i.data - (char *) R; 10256 return i; 10257 } 10258 10259 10260 /***************************************************************************** 10261 ** 10262 ** xcb_glx_get_tex_image_reply_t * xcb_glx_get_tex_image_reply 10263 ** 10264 ** @param xcb_connection_t *c 10265 ** @param xcb_glx_get_tex_image_cookie_t cookie 10266 ** @param xcb_generic_error_t **e 10267 ** @returns xcb_glx_get_tex_image_reply_t * 10268 ** 10269 *****************************************************************************/ 10270 10271 xcb_glx_get_tex_image_reply_t * 10272 xcb_glx_get_tex_image_reply (xcb_connection_t *c /**< */, 10273 xcb_glx_get_tex_image_cookie_t cookie /**< */, 10274 xcb_generic_error_t **e /**< */) 10275 { 10276 return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10277 } 10278 10279 int 10280 xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */) 10281 { 10282 char *xcb_tmp = (char *)_buffer; 10283 const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer; 10284 unsigned int xcb_buffer_len = 0; 10285 unsigned int xcb_block_len = 0; 10286 unsigned int xcb_pad = 0; 10287 unsigned int xcb_align_to = 0; 10288 10289 10290 xcb_block_len += sizeof(xcb_glx_get_tex_parameterfv_reply_t); 10291 xcb_tmp += xcb_block_len; 10292 xcb_buffer_len += xcb_block_len; 10293 xcb_block_len = 0; 10294 /* data */ 10295 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 10296 xcb_tmp += xcb_block_len; 10297 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 10298 /* insert padding */ 10299 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10300 xcb_buffer_len += xcb_block_len + xcb_pad; 10301 if (0 != xcb_pad) { 10302 xcb_tmp += xcb_pad; 10303 xcb_pad = 0; 10304 } 10305 xcb_block_len = 0; 10306 10307 return xcb_buffer_len; 10308 } 10309 10310 10311 /***************************************************************************** 10312 ** 10313 ** xcb_glx_get_tex_parameterfv_cookie_t xcb_glx_get_tex_parameterfv 10314 ** 10315 ** @param xcb_connection_t *c 10316 ** @param xcb_glx_context_tag_t context_tag 10317 ** @param uint32_t target 10318 ** @param uint32_t pname 10319 ** @returns xcb_glx_get_tex_parameterfv_cookie_t 10320 ** 10321 *****************************************************************************/ 10322 10323 xcb_glx_get_tex_parameterfv_cookie_t 10324 xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, 10325 xcb_glx_context_tag_t context_tag /**< */, 10326 uint32_t target /**< */, 10327 uint32_t pname /**< */) 10328 { 10329 static const xcb_protocol_request_t xcb_req = { 10330 /* count */ 2, 10331 /* ext */ &xcb_glx_id, 10332 /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, 10333 /* isvoid */ 0 10334 }; 10335 10336 struct iovec xcb_parts[4]; 10337 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 10338 xcb_glx_get_tex_parameterfv_request_t xcb_out; 10339 10340 xcb_out.context_tag = context_tag; 10341 xcb_out.target = target; 10342 xcb_out.pname = pname; 10343 10344 xcb_parts[2].iov_base = (char *) &xcb_out; 10345 xcb_parts[2].iov_len = sizeof(xcb_out); 10346 xcb_parts[3].iov_base = 0; 10347 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10348 10349 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10350 return xcb_ret; 10351 } 10352 10353 10354 /***************************************************************************** 10355 ** 10356 ** xcb_glx_get_tex_parameterfv_cookie_t xcb_glx_get_tex_parameterfv_unchecked 10357 ** 10358 ** @param xcb_connection_t *c 10359 ** @param xcb_glx_context_tag_t context_tag 10360 ** @param uint32_t target 10361 ** @param uint32_t pname 10362 ** @returns xcb_glx_get_tex_parameterfv_cookie_t 10363 ** 10364 *****************************************************************************/ 10365 10366 xcb_glx_get_tex_parameterfv_cookie_t 10367 xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c /**< */, 10368 xcb_glx_context_tag_t context_tag /**< */, 10369 uint32_t target /**< */, 10370 uint32_t pname /**< */) 10371 { 10372 static const xcb_protocol_request_t xcb_req = { 10373 /* count */ 2, 10374 /* ext */ &xcb_glx_id, 10375 /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, 10376 /* isvoid */ 0 10377 }; 10378 10379 struct iovec xcb_parts[4]; 10380 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 10381 xcb_glx_get_tex_parameterfv_request_t xcb_out; 10382 10383 xcb_out.context_tag = context_tag; 10384 xcb_out.target = target; 10385 xcb_out.pname = pname; 10386 10387 xcb_parts[2].iov_base = (char *) &xcb_out; 10388 xcb_parts[2].iov_len = sizeof(xcb_out); 10389 xcb_parts[3].iov_base = 0; 10390 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10391 10392 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10393 return xcb_ret; 10394 } 10395 10396 10397 /***************************************************************************** 10398 ** 10399 ** xcb_glx_float32_t * xcb_glx_get_tex_parameterfv_data 10400 ** 10401 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10402 ** @returns xcb_glx_float32_t * 10403 ** 10404 *****************************************************************************/ 10405 10406 xcb_glx_float32_t * 10407 xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10408 { 10409 return (xcb_glx_float32_t *) (R + 1); 10410 } 10411 10412 10413 /***************************************************************************** 10414 ** 10415 ** int xcb_glx_get_tex_parameterfv_data_length 10416 ** 10417 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10418 ** @returns int 10419 ** 10420 *****************************************************************************/ 10421 10422 int 10423 xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10424 { 10425 return R->n; 10426 } 10427 10428 10429 /***************************************************************************** 10430 ** 10431 ** xcb_generic_iterator_t xcb_glx_get_tex_parameterfv_data_end 10432 ** 10433 ** @param const xcb_glx_get_tex_parameterfv_reply_t *R 10434 ** @returns xcb_generic_iterator_t 10435 ** 10436 *****************************************************************************/ 10437 10438 xcb_generic_iterator_t 10439 xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) 10440 { 10441 xcb_generic_iterator_t i; 10442 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 10443 i.rem = 0; 10444 i.index = (char *) i.data - (char *) R; 10445 return i; 10446 } 10447 10448 10449 /***************************************************************************** 10450 ** 10451 ** xcb_glx_get_tex_parameterfv_reply_t * xcb_glx_get_tex_parameterfv_reply 10452 ** 10453 ** @param xcb_connection_t *c 10454 ** @param xcb_glx_get_tex_parameterfv_cookie_t cookie 10455 ** @param xcb_generic_error_t **e 10456 ** @returns xcb_glx_get_tex_parameterfv_reply_t * 10457 ** 10458 *****************************************************************************/ 10459 10460 xcb_glx_get_tex_parameterfv_reply_t * 10461 xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c /**< */, 10462 xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, 10463 xcb_generic_error_t **e /**< */) 10464 { 10465 return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10466 } 10467 10468 int 10469 xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */) 10470 { 10471 char *xcb_tmp = (char *)_buffer; 10472 const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer; 10473 unsigned int xcb_buffer_len = 0; 10474 unsigned int xcb_block_len = 0; 10475 unsigned int xcb_pad = 0; 10476 unsigned int xcb_align_to = 0; 10477 10478 10479 xcb_block_len += sizeof(xcb_glx_get_tex_parameteriv_reply_t); 10480 xcb_tmp += xcb_block_len; 10481 xcb_buffer_len += xcb_block_len; 10482 xcb_block_len = 0; 10483 /* data */ 10484 xcb_block_len += _aux->n * sizeof(int32_t); 10485 xcb_tmp += xcb_block_len; 10486 xcb_align_to = ALIGNOF(int32_t); 10487 /* insert padding */ 10488 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10489 xcb_buffer_len += xcb_block_len + xcb_pad; 10490 if (0 != xcb_pad) { 10491 xcb_tmp += xcb_pad; 10492 xcb_pad = 0; 10493 } 10494 xcb_block_len = 0; 10495 10496 return xcb_buffer_len; 10497 } 10498 10499 10500 /***************************************************************************** 10501 ** 10502 ** xcb_glx_get_tex_parameteriv_cookie_t xcb_glx_get_tex_parameteriv 10503 ** 10504 ** @param xcb_connection_t *c 10505 ** @param xcb_glx_context_tag_t context_tag 10506 ** @param uint32_t target 10507 ** @param uint32_t pname 10508 ** @returns xcb_glx_get_tex_parameteriv_cookie_t 10509 ** 10510 *****************************************************************************/ 10511 10512 xcb_glx_get_tex_parameteriv_cookie_t 10513 xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, 10514 xcb_glx_context_tag_t context_tag /**< */, 10515 uint32_t target /**< */, 10516 uint32_t pname /**< */) 10517 { 10518 static const xcb_protocol_request_t xcb_req = { 10519 /* count */ 2, 10520 /* ext */ &xcb_glx_id, 10521 /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, 10522 /* isvoid */ 0 10523 }; 10524 10525 struct iovec xcb_parts[4]; 10526 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 10527 xcb_glx_get_tex_parameteriv_request_t xcb_out; 10528 10529 xcb_out.context_tag = context_tag; 10530 xcb_out.target = target; 10531 xcb_out.pname = pname; 10532 10533 xcb_parts[2].iov_base = (char *) &xcb_out; 10534 xcb_parts[2].iov_len = sizeof(xcb_out); 10535 xcb_parts[3].iov_base = 0; 10536 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10537 10538 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10539 return xcb_ret; 10540 } 10541 10542 10543 /***************************************************************************** 10544 ** 10545 ** xcb_glx_get_tex_parameteriv_cookie_t xcb_glx_get_tex_parameteriv_unchecked 10546 ** 10547 ** @param xcb_connection_t *c 10548 ** @param xcb_glx_context_tag_t context_tag 10549 ** @param uint32_t target 10550 ** @param uint32_t pname 10551 ** @returns xcb_glx_get_tex_parameteriv_cookie_t 10552 ** 10553 *****************************************************************************/ 10554 10555 xcb_glx_get_tex_parameteriv_cookie_t 10556 xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c /**< */, 10557 xcb_glx_context_tag_t context_tag /**< */, 10558 uint32_t target /**< */, 10559 uint32_t pname /**< */) 10560 { 10561 static const xcb_protocol_request_t xcb_req = { 10562 /* count */ 2, 10563 /* ext */ &xcb_glx_id, 10564 /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, 10565 /* isvoid */ 0 10566 }; 10567 10568 struct iovec xcb_parts[4]; 10569 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 10570 xcb_glx_get_tex_parameteriv_request_t xcb_out; 10571 10572 xcb_out.context_tag = context_tag; 10573 xcb_out.target = target; 10574 xcb_out.pname = pname; 10575 10576 xcb_parts[2].iov_base = (char *) &xcb_out; 10577 xcb_parts[2].iov_len = sizeof(xcb_out); 10578 xcb_parts[3].iov_base = 0; 10579 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10580 10581 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10582 return xcb_ret; 10583 } 10584 10585 10586 /***************************************************************************** 10587 ** 10588 ** int32_t * xcb_glx_get_tex_parameteriv_data 10589 ** 10590 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10591 ** @returns int32_t * 10592 ** 10593 *****************************************************************************/ 10594 10595 int32_t * 10596 xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10597 { 10598 return (int32_t *) (R + 1); 10599 } 10600 10601 10602 /***************************************************************************** 10603 ** 10604 ** int xcb_glx_get_tex_parameteriv_data_length 10605 ** 10606 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10607 ** @returns int 10608 ** 10609 *****************************************************************************/ 10610 10611 int 10612 xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10613 { 10614 return R->n; 10615 } 10616 10617 10618 /***************************************************************************** 10619 ** 10620 ** xcb_generic_iterator_t xcb_glx_get_tex_parameteriv_data_end 10621 ** 10622 ** @param const xcb_glx_get_tex_parameteriv_reply_t *R 10623 ** @returns xcb_generic_iterator_t 10624 ** 10625 *****************************************************************************/ 10626 10627 xcb_generic_iterator_t 10628 xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) 10629 { 10630 xcb_generic_iterator_t i; 10631 i.data = ((int32_t *) (R + 1)) + (R->n); 10632 i.rem = 0; 10633 i.index = (char *) i.data - (char *) R; 10634 return i; 10635 } 10636 10637 10638 /***************************************************************************** 10639 ** 10640 ** xcb_glx_get_tex_parameteriv_reply_t * xcb_glx_get_tex_parameteriv_reply 10641 ** 10642 ** @param xcb_connection_t *c 10643 ** @param xcb_glx_get_tex_parameteriv_cookie_t cookie 10644 ** @param xcb_generic_error_t **e 10645 ** @returns xcb_glx_get_tex_parameteriv_reply_t * 10646 ** 10647 *****************************************************************************/ 10648 10649 xcb_glx_get_tex_parameteriv_reply_t * 10650 xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c /**< */, 10651 xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, 10652 xcb_generic_error_t **e /**< */) 10653 { 10654 return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10655 } 10656 10657 int 10658 xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */) 10659 { 10660 char *xcb_tmp = (char *)_buffer; 10661 const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer; 10662 unsigned int xcb_buffer_len = 0; 10663 unsigned int xcb_block_len = 0; 10664 unsigned int xcb_pad = 0; 10665 unsigned int xcb_align_to = 0; 10666 10667 10668 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameterfv_reply_t); 10669 xcb_tmp += xcb_block_len; 10670 xcb_buffer_len += xcb_block_len; 10671 xcb_block_len = 0; 10672 /* data */ 10673 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 10674 xcb_tmp += xcb_block_len; 10675 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 10676 /* insert padding */ 10677 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10678 xcb_buffer_len += xcb_block_len + xcb_pad; 10679 if (0 != xcb_pad) { 10680 xcb_tmp += xcb_pad; 10681 xcb_pad = 0; 10682 } 10683 xcb_block_len = 0; 10684 10685 return xcb_buffer_len; 10686 } 10687 10688 10689 /***************************************************************************** 10690 ** 10691 ** xcb_glx_get_tex_level_parameterfv_cookie_t xcb_glx_get_tex_level_parameterfv 10692 ** 10693 ** @param xcb_connection_t *c 10694 ** @param xcb_glx_context_tag_t context_tag 10695 ** @param uint32_t target 10696 ** @param int32_t level 10697 ** @param uint32_t pname 10698 ** @returns xcb_glx_get_tex_level_parameterfv_cookie_t 10699 ** 10700 *****************************************************************************/ 10701 10702 xcb_glx_get_tex_level_parameterfv_cookie_t 10703 xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, 10704 xcb_glx_context_tag_t context_tag /**< */, 10705 uint32_t target /**< */, 10706 int32_t level /**< */, 10707 uint32_t pname /**< */) 10708 { 10709 static const xcb_protocol_request_t xcb_req = { 10710 /* count */ 2, 10711 /* ext */ &xcb_glx_id, 10712 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 10713 /* isvoid */ 0 10714 }; 10715 10716 struct iovec xcb_parts[4]; 10717 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 10718 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 10719 10720 xcb_out.context_tag = context_tag; 10721 xcb_out.target = target; 10722 xcb_out.level = level; 10723 xcb_out.pname = pname; 10724 10725 xcb_parts[2].iov_base = (char *) &xcb_out; 10726 xcb_parts[2].iov_len = sizeof(xcb_out); 10727 xcb_parts[3].iov_base = 0; 10728 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10729 10730 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10731 return xcb_ret; 10732 } 10733 10734 10735 /***************************************************************************** 10736 ** 10737 ** xcb_glx_get_tex_level_parameterfv_cookie_t xcb_glx_get_tex_level_parameterfv_unchecked 10738 ** 10739 ** @param xcb_connection_t *c 10740 ** @param xcb_glx_context_tag_t context_tag 10741 ** @param uint32_t target 10742 ** @param int32_t level 10743 ** @param uint32_t pname 10744 ** @returns xcb_glx_get_tex_level_parameterfv_cookie_t 10745 ** 10746 *****************************************************************************/ 10747 10748 xcb_glx_get_tex_level_parameterfv_cookie_t 10749 xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c /**< */, 10750 xcb_glx_context_tag_t context_tag /**< */, 10751 uint32_t target /**< */, 10752 int32_t level /**< */, 10753 uint32_t pname /**< */) 10754 { 10755 static const xcb_protocol_request_t xcb_req = { 10756 /* count */ 2, 10757 /* ext */ &xcb_glx_id, 10758 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 10759 /* isvoid */ 0 10760 }; 10761 10762 struct iovec xcb_parts[4]; 10763 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 10764 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 10765 10766 xcb_out.context_tag = context_tag; 10767 xcb_out.target = target; 10768 xcb_out.level = level; 10769 xcb_out.pname = pname; 10770 10771 xcb_parts[2].iov_base = (char *) &xcb_out; 10772 xcb_parts[2].iov_len = sizeof(xcb_out); 10773 xcb_parts[3].iov_base = 0; 10774 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10775 10776 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10777 return xcb_ret; 10778 } 10779 10780 10781 /***************************************************************************** 10782 ** 10783 ** xcb_glx_float32_t * xcb_glx_get_tex_level_parameterfv_data 10784 ** 10785 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10786 ** @returns xcb_glx_float32_t * 10787 ** 10788 *****************************************************************************/ 10789 10790 xcb_glx_float32_t * 10791 xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10792 { 10793 return (xcb_glx_float32_t *) (R + 1); 10794 } 10795 10796 10797 /***************************************************************************** 10798 ** 10799 ** int xcb_glx_get_tex_level_parameterfv_data_length 10800 ** 10801 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10802 ** @returns int 10803 ** 10804 *****************************************************************************/ 10805 10806 int 10807 xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10808 { 10809 return R->n; 10810 } 10811 10812 10813 /***************************************************************************** 10814 ** 10815 ** xcb_generic_iterator_t xcb_glx_get_tex_level_parameterfv_data_end 10816 ** 10817 ** @param const xcb_glx_get_tex_level_parameterfv_reply_t *R 10818 ** @returns xcb_generic_iterator_t 10819 ** 10820 *****************************************************************************/ 10821 10822 xcb_generic_iterator_t 10823 xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) 10824 { 10825 xcb_generic_iterator_t i; 10826 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 10827 i.rem = 0; 10828 i.index = (char *) i.data - (char *) R; 10829 return i; 10830 } 10831 10832 10833 /***************************************************************************** 10834 ** 10835 ** xcb_glx_get_tex_level_parameterfv_reply_t * xcb_glx_get_tex_level_parameterfv_reply 10836 ** 10837 ** @param xcb_connection_t *c 10838 ** @param xcb_glx_get_tex_level_parameterfv_cookie_t cookie 10839 ** @param xcb_generic_error_t **e 10840 ** @returns xcb_glx_get_tex_level_parameterfv_reply_t * 10841 ** 10842 *****************************************************************************/ 10843 10844 xcb_glx_get_tex_level_parameterfv_reply_t * 10845 xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c /**< */, 10846 xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, 10847 xcb_generic_error_t **e /**< */) 10848 { 10849 return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10850 } 10851 10852 int 10853 xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */) 10854 { 10855 char *xcb_tmp = (char *)_buffer; 10856 const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer; 10857 unsigned int xcb_buffer_len = 0; 10858 unsigned int xcb_block_len = 0; 10859 unsigned int xcb_pad = 0; 10860 unsigned int xcb_align_to = 0; 10861 10862 10863 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameteriv_reply_t); 10864 xcb_tmp += xcb_block_len; 10865 xcb_buffer_len += xcb_block_len; 10866 xcb_block_len = 0; 10867 /* data */ 10868 xcb_block_len += _aux->n * sizeof(int32_t); 10869 xcb_tmp += xcb_block_len; 10870 xcb_align_to = ALIGNOF(int32_t); 10871 /* insert padding */ 10872 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10873 xcb_buffer_len += xcb_block_len + xcb_pad; 10874 if (0 != xcb_pad) { 10875 xcb_tmp += xcb_pad; 10876 xcb_pad = 0; 10877 } 10878 xcb_block_len = 0; 10879 10880 return xcb_buffer_len; 10881 } 10882 10883 10884 /***************************************************************************** 10885 ** 10886 ** xcb_glx_get_tex_level_parameteriv_cookie_t xcb_glx_get_tex_level_parameteriv 10887 ** 10888 ** @param xcb_connection_t *c 10889 ** @param xcb_glx_context_tag_t context_tag 10890 ** @param uint32_t target 10891 ** @param int32_t level 10892 ** @param uint32_t pname 10893 ** @returns xcb_glx_get_tex_level_parameteriv_cookie_t 10894 ** 10895 *****************************************************************************/ 10896 10897 xcb_glx_get_tex_level_parameteriv_cookie_t 10898 xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, 10899 xcb_glx_context_tag_t context_tag /**< */, 10900 uint32_t target /**< */, 10901 int32_t level /**< */, 10902 uint32_t pname /**< */) 10903 { 10904 static const xcb_protocol_request_t xcb_req = { 10905 /* count */ 2, 10906 /* ext */ &xcb_glx_id, 10907 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 10908 /* isvoid */ 0 10909 }; 10910 10911 struct iovec xcb_parts[4]; 10912 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 10913 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 10914 10915 xcb_out.context_tag = context_tag; 10916 xcb_out.target = target; 10917 xcb_out.level = level; 10918 xcb_out.pname = pname; 10919 10920 xcb_parts[2].iov_base = (char *) &xcb_out; 10921 xcb_parts[2].iov_len = sizeof(xcb_out); 10922 xcb_parts[3].iov_base = 0; 10923 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10924 10925 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10926 return xcb_ret; 10927 } 10928 10929 10930 /***************************************************************************** 10931 ** 10932 ** xcb_glx_get_tex_level_parameteriv_cookie_t xcb_glx_get_tex_level_parameteriv_unchecked 10933 ** 10934 ** @param xcb_connection_t *c 10935 ** @param xcb_glx_context_tag_t context_tag 10936 ** @param uint32_t target 10937 ** @param int32_t level 10938 ** @param uint32_t pname 10939 ** @returns xcb_glx_get_tex_level_parameteriv_cookie_t 10940 ** 10941 *****************************************************************************/ 10942 10943 xcb_glx_get_tex_level_parameteriv_cookie_t 10944 xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c /**< */, 10945 xcb_glx_context_tag_t context_tag /**< */, 10946 uint32_t target /**< */, 10947 int32_t level /**< */, 10948 uint32_t pname /**< */) 10949 { 10950 static const xcb_protocol_request_t xcb_req = { 10951 /* count */ 2, 10952 /* ext */ &xcb_glx_id, 10953 /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 10954 /* isvoid */ 0 10955 }; 10956 10957 struct iovec xcb_parts[4]; 10958 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 10959 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 10960 10961 xcb_out.context_tag = context_tag; 10962 xcb_out.target = target; 10963 xcb_out.level = level; 10964 xcb_out.pname = pname; 10965 10966 xcb_parts[2].iov_base = (char *) &xcb_out; 10967 xcb_parts[2].iov_len = sizeof(xcb_out); 10968 xcb_parts[3].iov_base = 0; 10969 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10970 10971 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10972 return xcb_ret; 10973 } 10974 10975 10976 /***************************************************************************** 10977 ** 10978 ** int32_t * xcb_glx_get_tex_level_parameteriv_data 10979 ** 10980 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 10981 ** @returns int32_t * 10982 ** 10983 *****************************************************************************/ 10984 10985 int32_t * 10986 xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 10987 { 10988 return (int32_t *) (R + 1); 10989 } 10990 10991 10992 /***************************************************************************** 10993 ** 10994 ** int xcb_glx_get_tex_level_parameteriv_data_length 10995 ** 10996 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 10997 ** @returns int 10998 ** 10999 *****************************************************************************/ 11000 11001 int 11002 xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 11003 { 11004 return R->n; 11005 } 11006 11007 11008 /***************************************************************************** 11009 ** 11010 ** xcb_generic_iterator_t xcb_glx_get_tex_level_parameteriv_data_end 11011 ** 11012 ** @param const xcb_glx_get_tex_level_parameteriv_reply_t *R 11013 ** @returns xcb_generic_iterator_t 11014 ** 11015 *****************************************************************************/ 11016 11017 xcb_generic_iterator_t 11018 xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) 11019 { 11020 xcb_generic_iterator_t i; 11021 i.data = ((int32_t *) (R + 1)) + (R->n); 11022 i.rem = 0; 11023 i.index = (char *) i.data - (char *) R; 11024 return i; 11025 } 11026 11027 11028 /***************************************************************************** 11029 ** 11030 ** xcb_glx_get_tex_level_parameteriv_reply_t * xcb_glx_get_tex_level_parameteriv_reply 11031 ** 11032 ** @param xcb_connection_t *c 11033 ** @param xcb_glx_get_tex_level_parameteriv_cookie_t cookie 11034 ** @param xcb_generic_error_t **e 11035 ** @returns xcb_glx_get_tex_level_parameteriv_reply_t * 11036 ** 11037 *****************************************************************************/ 11038 11039 xcb_glx_get_tex_level_parameteriv_reply_t * 11040 xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c /**< */, 11041 xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, 11042 xcb_generic_error_t **e /**< */) 11043 { 11044 return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11045 } 11046 11047 11048 /***************************************************************************** 11049 ** 11050 ** xcb_glx_is_list_cookie_t xcb_glx_is_list 11051 ** 11052 ** @param xcb_connection_t *c 11053 ** @param xcb_glx_context_tag_t context_tag 11054 ** @param uint32_t list 11055 ** @returns xcb_glx_is_list_cookie_t 11056 ** 11057 *****************************************************************************/ 11058 11059 xcb_glx_is_list_cookie_t 11060 xcb_glx_is_list (xcb_connection_t *c /**< */, 11061 xcb_glx_context_tag_t context_tag /**< */, 11062 uint32_t list /**< */) 11063 { 11064 static const xcb_protocol_request_t xcb_req = { 11065 /* count */ 2, 11066 /* ext */ &xcb_glx_id, 11067 /* opcode */ XCB_GLX_IS_LIST, 11068 /* isvoid */ 0 11069 }; 11070 11071 struct iovec xcb_parts[4]; 11072 xcb_glx_is_list_cookie_t xcb_ret; 11073 xcb_glx_is_list_request_t xcb_out; 11074 11075 xcb_out.context_tag = context_tag; 11076 xcb_out.list = list; 11077 11078 xcb_parts[2].iov_base = (char *) &xcb_out; 11079 xcb_parts[2].iov_len = sizeof(xcb_out); 11080 xcb_parts[3].iov_base = 0; 11081 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11082 11083 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11084 return xcb_ret; 11085 } 11086 11087 11088 /***************************************************************************** 11089 ** 11090 ** xcb_glx_is_list_cookie_t xcb_glx_is_list_unchecked 11091 ** 11092 ** @param xcb_connection_t *c 11093 ** @param xcb_glx_context_tag_t context_tag 11094 ** @param uint32_t list 11095 ** @returns xcb_glx_is_list_cookie_t 11096 ** 11097 *****************************************************************************/ 11098 11099 xcb_glx_is_list_cookie_t 11100 xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, 11101 xcb_glx_context_tag_t context_tag /**< */, 11102 uint32_t list /**< */) 11103 { 11104 static const xcb_protocol_request_t xcb_req = { 11105 /* count */ 2, 11106 /* ext */ &xcb_glx_id, 11107 /* opcode */ XCB_GLX_IS_LIST, 11108 /* isvoid */ 0 11109 }; 11110 11111 struct iovec xcb_parts[4]; 11112 xcb_glx_is_list_cookie_t xcb_ret; 11113 xcb_glx_is_list_request_t xcb_out; 11114 11115 xcb_out.context_tag = context_tag; 11116 xcb_out.list = list; 11117 11118 xcb_parts[2].iov_base = (char *) &xcb_out; 11119 xcb_parts[2].iov_len = sizeof(xcb_out); 11120 xcb_parts[3].iov_base = 0; 11121 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11122 11123 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11124 return xcb_ret; 11125 } 11126 11127 11128 /***************************************************************************** 11129 ** 11130 ** xcb_glx_is_list_reply_t * xcb_glx_is_list_reply 11131 ** 11132 ** @param xcb_connection_t *c 11133 ** @param xcb_glx_is_list_cookie_t cookie 11134 ** @param xcb_generic_error_t **e 11135 ** @returns xcb_glx_is_list_reply_t * 11136 ** 11137 *****************************************************************************/ 11138 11139 xcb_glx_is_list_reply_t * 11140 xcb_glx_is_list_reply (xcb_connection_t *c /**< */, 11141 xcb_glx_is_list_cookie_t cookie /**< */, 11142 xcb_generic_error_t **e /**< */) 11143 { 11144 return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11145 } 11146 11147 11148 /***************************************************************************** 11149 ** 11150 ** xcb_void_cookie_t xcb_glx_flush_checked 11151 ** 11152 ** @param xcb_connection_t *c 11153 ** @param xcb_glx_context_tag_t context_tag 11154 ** @returns xcb_void_cookie_t 11155 ** 11156 *****************************************************************************/ 11157 11158 xcb_void_cookie_t 11159 xcb_glx_flush_checked (xcb_connection_t *c /**< */, 11160 xcb_glx_context_tag_t context_tag /**< */) 11161 { 11162 static const xcb_protocol_request_t xcb_req = { 11163 /* count */ 2, 11164 /* ext */ &xcb_glx_id, 11165 /* opcode */ XCB_GLX_FLUSH, 11166 /* isvoid */ 1 11167 }; 11168 11169 struct iovec xcb_parts[4]; 11170 xcb_void_cookie_t xcb_ret; 11171 xcb_glx_flush_request_t xcb_out; 11172 11173 xcb_out.context_tag = context_tag; 11174 11175 xcb_parts[2].iov_base = (char *) &xcb_out; 11176 xcb_parts[2].iov_len = sizeof(xcb_out); 11177 xcb_parts[3].iov_base = 0; 11178 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11179 11180 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11181 return xcb_ret; 11182 } 11183 11184 11185 /***************************************************************************** 11186 ** 11187 ** xcb_void_cookie_t xcb_glx_flush 11188 ** 11189 ** @param xcb_connection_t *c 11190 ** @param xcb_glx_context_tag_t context_tag 11191 ** @returns xcb_void_cookie_t 11192 ** 11193 *****************************************************************************/ 11194 11195 xcb_void_cookie_t 11196 xcb_glx_flush (xcb_connection_t *c /**< */, 11197 xcb_glx_context_tag_t context_tag /**< */) 11198 { 11199 static const xcb_protocol_request_t xcb_req = { 11200 /* count */ 2, 11201 /* ext */ &xcb_glx_id, 11202 /* opcode */ XCB_GLX_FLUSH, 11203 /* isvoid */ 1 11204 }; 11205 11206 struct iovec xcb_parts[4]; 11207 xcb_void_cookie_t xcb_ret; 11208 xcb_glx_flush_request_t xcb_out; 11209 11210 xcb_out.context_tag = context_tag; 11211 11212 xcb_parts[2].iov_base = (char *) &xcb_out; 11213 xcb_parts[2].iov_len = sizeof(xcb_out); 11214 xcb_parts[3].iov_base = 0; 11215 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11216 11217 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11218 return xcb_ret; 11219 } 11220 11221 int 11222 xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */) 11223 { 11224 char *xcb_tmp = (char *)_buffer; 11225 const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer; 11226 unsigned int xcb_buffer_len = 0; 11227 unsigned int xcb_block_len = 0; 11228 unsigned int xcb_pad = 0; 11229 unsigned int xcb_align_to = 0; 11230 11231 11232 xcb_block_len += sizeof(xcb_glx_are_textures_resident_request_t); 11233 xcb_tmp += xcb_block_len; 11234 xcb_buffer_len += xcb_block_len; 11235 xcb_block_len = 0; 11236 /* textures */ 11237 xcb_block_len += _aux->n * sizeof(uint32_t); 11238 xcb_tmp += xcb_block_len; 11239 xcb_align_to = ALIGNOF(uint32_t); 11240 /* insert padding */ 11241 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11242 xcb_buffer_len += xcb_block_len + xcb_pad; 11243 if (0 != xcb_pad) { 11244 xcb_tmp += xcb_pad; 11245 xcb_pad = 0; 11246 } 11247 xcb_block_len = 0; 11248 11249 return xcb_buffer_len; 11250 } 11251 11252 11253 /***************************************************************************** 11254 ** 11255 ** xcb_glx_are_textures_resident_cookie_t xcb_glx_are_textures_resident 11256 ** 11257 ** @param xcb_connection_t *c 11258 ** @param xcb_glx_context_tag_t context_tag 11259 ** @param int32_t n 11260 ** @param const uint32_t *textures 11261 ** @returns xcb_glx_are_textures_resident_cookie_t 11262 ** 11263 *****************************************************************************/ 11264 11265 xcb_glx_are_textures_resident_cookie_t 11266 xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, 11267 xcb_glx_context_tag_t context_tag /**< */, 11268 int32_t n /**< */, 11269 const uint32_t *textures /**< */) 11270 { 11271 static const xcb_protocol_request_t xcb_req = { 11272 /* count */ 4, 11273 /* ext */ &xcb_glx_id, 11274 /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, 11275 /* isvoid */ 0 11276 }; 11277 11278 struct iovec xcb_parts[6]; 11279 xcb_glx_are_textures_resident_cookie_t xcb_ret; 11280 xcb_glx_are_textures_resident_request_t xcb_out; 11281 11282 xcb_out.context_tag = context_tag; 11283 xcb_out.n = n; 11284 11285 xcb_parts[2].iov_base = (char *) &xcb_out; 11286 xcb_parts[2].iov_len = sizeof(xcb_out); 11287 xcb_parts[3].iov_base = 0; 11288 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11289 /* uint32_t textures */ 11290 xcb_parts[4].iov_base = (char *) textures; 11291 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 11292 xcb_parts[5].iov_base = 0; 11293 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11294 11295 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11296 return xcb_ret; 11297 } 11298 11299 11300 /***************************************************************************** 11301 ** 11302 ** xcb_glx_are_textures_resident_cookie_t xcb_glx_are_textures_resident_unchecked 11303 ** 11304 ** @param xcb_connection_t *c 11305 ** @param xcb_glx_context_tag_t context_tag 11306 ** @param int32_t n 11307 ** @param const uint32_t *textures 11308 ** @returns xcb_glx_are_textures_resident_cookie_t 11309 ** 11310 *****************************************************************************/ 11311 11312 xcb_glx_are_textures_resident_cookie_t 11313 xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c /**< */, 11314 xcb_glx_context_tag_t context_tag /**< */, 11315 int32_t n /**< */, 11316 const uint32_t *textures /**< */) 11317 { 11318 static const xcb_protocol_request_t xcb_req = { 11319 /* count */ 4, 11320 /* ext */ &xcb_glx_id, 11321 /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, 11322 /* isvoid */ 0 11323 }; 11324 11325 struct iovec xcb_parts[6]; 11326 xcb_glx_are_textures_resident_cookie_t xcb_ret; 11327 xcb_glx_are_textures_resident_request_t xcb_out; 11328 11329 xcb_out.context_tag = context_tag; 11330 xcb_out.n = n; 11331 11332 xcb_parts[2].iov_base = (char *) &xcb_out; 11333 xcb_parts[2].iov_len = sizeof(xcb_out); 11334 xcb_parts[3].iov_base = 0; 11335 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11336 /* uint32_t textures */ 11337 xcb_parts[4].iov_base = (char *) textures; 11338 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 11339 xcb_parts[5].iov_base = 0; 11340 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11341 11342 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11343 return xcb_ret; 11344 } 11345 11346 11347 /***************************************************************************** 11348 ** 11349 ** uint8_t * xcb_glx_are_textures_resident_data 11350 ** 11351 ** @param const xcb_glx_are_textures_resident_reply_t *R 11352 ** @returns uint8_t * 11353 ** 11354 *****************************************************************************/ 11355 11356 uint8_t * 11357 xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11358 { 11359 return (uint8_t *) (R + 1); 11360 } 11361 11362 11363 /***************************************************************************** 11364 ** 11365 ** int xcb_glx_are_textures_resident_data_length 11366 ** 11367 ** @param const xcb_glx_are_textures_resident_reply_t *R 11368 ** @returns int 11369 ** 11370 *****************************************************************************/ 11371 11372 int 11373 xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11374 { 11375 return (R->length * 4); 11376 } 11377 11378 11379 /***************************************************************************** 11380 ** 11381 ** xcb_generic_iterator_t xcb_glx_are_textures_resident_data_end 11382 ** 11383 ** @param const xcb_glx_are_textures_resident_reply_t *R 11384 ** @returns xcb_generic_iterator_t 11385 ** 11386 *****************************************************************************/ 11387 11388 xcb_generic_iterator_t 11389 xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R /**< */) 11390 { 11391 xcb_generic_iterator_t i; 11392 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 11393 i.rem = 0; 11394 i.index = (char *) i.data - (char *) R; 11395 return i; 11396 } 11397 11398 11399 /***************************************************************************** 11400 ** 11401 ** xcb_glx_are_textures_resident_reply_t * xcb_glx_are_textures_resident_reply 11402 ** 11403 ** @param xcb_connection_t *c 11404 ** @param xcb_glx_are_textures_resident_cookie_t cookie 11405 ** @param xcb_generic_error_t **e 11406 ** @returns xcb_glx_are_textures_resident_reply_t * 11407 ** 11408 *****************************************************************************/ 11409 11410 xcb_glx_are_textures_resident_reply_t * 11411 xcb_glx_are_textures_resident_reply (xcb_connection_t *c /**< */, 11412 xcb_glx_are_textures_resident_cookie_t cookie /**< */, 11413 xcb_generic_error_t **e /**< */) 11414 { 11415 return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11416 } 11417 11418 int 11419 xcb_glx_delete_textures_sizeof (const void *_buffer /**< */) 11420 { 11421 char *xcb_tmp = (char *)_buffer; 11422 const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer; 11423 unsigned int xcb_buffer_len = 0; 11424 unsigned int xcb_block_len = 0; 11425 unsigned int xcb_pad = 0; 11426 unsigned int xcb_align_to = 0; 11427 11428 11429 xcb_block_len += sizeof(xcb_glx_delete_textures_request_t); 11430 xcb_tmp += xcb_block_len; 11431 xcb_buffer_len += xcb_block_len; 11432 xcb_block_len = 0; 11433 /* textures */ 11434 xcb_block_len += _aux->n * sizeof(uint32_t); 11435 xcb_tmp += xcb_block_len; 11436 xcb_align_to = ALIGNOF(uint32_t); 11437 /* insert padding */ 11438 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11439 xcb_buffer_len += xcb_block_len + xcb_pad; 11440 if (0 != xcb_pad) { 11441 xcb_tmp += xcb_pad; 11442 xcb_pad = 0; 11443 } 11444 xcb_block_len = 0; 11445 11446 return xcb_buffer_len; 11447 } 11448 11449 11450 /***************************************************************************** 11451 ** 11452 ** xcb_void_cookie_t xcb_glx_delete_textures_checked 11453 ** 11454 ** @param xcb_connection_t *c 11455 ** @param xcb_glx_context_tag_t context_tag 11456 ** @param int32_t n 11457 ** @param const uint32_t *textures 11458 ** @returns xcb_void_cookie_t 11459 ** 11460 *****************************************************************************/ 11461 11462 xcb_void_cookie_t 11463 xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, 11464 xcb_glx_context_tag_t context_tag /**< */, 11465 int32_t n /**< */, 11466 const uint32_t *textures /**< */) 11467 { 11468 static const xcb_protocol_request_t xcb_req = { 11469 /* count */ 4, 11470 /* ext */ &xcb_glx_id, 11471 /* opcode */ XCB_GLX_DELETE_TEXTURES, 11472 /* isvoid */ 1 11473 }; 11474 11475 struct iovec xcb_parts[6]; 11476 xcb_void_cookie_t xcb_ret; 11477 xcb_glx_delete_textures_request_t xcb_out; 11478 11479 xcb_out.context_tag = context_tag; 11480 xcb_out.n = n; 11481 11482 xcb_parts[2].iov_base = (char *) &xcb_out; 11483 xcb_parts[2].iov_len = sizeof(xcb_out); 11484 xcb_parts[3].iov_base = 0; 11485 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11486 /* uint32_t textures */ 11487 xcb_parts[4].iov_base = (char *) textures; 11488 xcb_parts[4].iov_len = n * sizeof(uint32_t); 11489 xcb_parts[5].iov_base = 0; 11490 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11491 11492 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11493 return xcb_ret; 11494 } 11495 11496 11497 /***************************************************************************** 11498 ** 11499 ** xcb_void_cookie_t xcb_glx_delete_textures 11500 ** 11501 ** @param xcb_connection_t *c 11502 ** @param xcb_glx_context_tag_t context_tag 11503 ** @param int32_t n 11504 ** @param const uint32_t *textures 11505 ** @returns xcb_void_cookie_t 11506 ** 11507 *****************************************************************************/ 11508 11509 xcb_void_cookie_t 11510 xcb_glx_delete_textures (xcb_connection_t *c /**< */, 11511 xcb_glx_context_tag_t context_tag /**< */, 11512 int32_t n /**< */, 11513 const uint32_t *textures /**< */) 11514 { 11515 static const xcb_protocol_request_t xcb_req = { 11516 /* count */ 4, 11517 /* ext */ &xcb_glx_id, 11518 /* opcode */ XCB_GLX_DELETE_TEXTURES, 11519 /* isvoid */ 1 11520 }; 11521 11522 struct iovec xcb_parts[6]; 11523 xcb_void_cookie_t xcb_ret; 11524 xcb_glx_delete_textures_request_t xcb_out; 11525 11526 xcb_out.context_tag = context_tag; 11527 xcb_out.n = n; 11528 11529 xcb_parts[2].iov_base = (char *) &xcb_out; 11530 xcb_parts[2].iov_len = sizeof(xcb_out); 11531 xcb_parts[3].iov_base = 0; 11532 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11533 /* uint32_t textures */ 11534 xcb_parts[4].iov_base = (char *) textures; 11535 xcb_parts[4].iov_len = n * sizeof(uint32_t); 11536 xcb_parts[5].iov_base = 0; 11537 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11538 11539 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11540 return xcb_ret; 11541 } 11542 11543 int 11544 xcb_glx_gen_textures_sizeof (const void *_buffer /**< */) 11545 { 11546 char *xcb_tmp = (char *)_buffer; 11547 const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer; 11548 unsigned int xcb_buffer_len = 0; 11549 unsigned int xcb_block_len = 0; 11550 unsigned int xcb_pad = 0; 11551 unsigned int xcb_align_to = 0; 11552 11553 11554 xcb_block_len += sizeof(xcb_glx_gen_textures_reply_t); 11555 xcb_tmp += xcb_block_len; 11556 xcb_buffer_len += xcb_block_len; 11557 xcb_block_len = 0; 11558 /* data */ 11559 xcb_block_len += _aux->length * sizeof(uint32_t); 11560 xcb_tmp += xcb_block_len; 11561 xcb_align_to = ALIGNOF(uint32_t); 11562 /* insert padding */ 11563 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11564 xcb_buffer_len += xcb_block_len + xcb_pad; 11565 if (0 != xcb_pad) { 11566 xcb_tmp += xcb_pad; 11567 xcb_pad = 0; 11568 } 11569 xcb_block_len = 0; 11570 11571 return xcb_buffer_len; 11572 } 11573 11574 11575 /***************************************************************************** 11576 ** 11577 ** xcb_glx_gen_textures_cookie_t xcb_glx_gen_textures 11578 ** 11579 ** @param xcb_connection_t *c 11580 ** @param xcb_glx_context_tag_t context_tag 11581 ** @param int32_t n 11582 ** @returns xcb_glx_gen_textures_cookie_t 11583 ** 11584 *****************************************************************************/ 11585 11586 xcb_glx_gen_textures_cookie_t 11587 xcb_glx_gen_textures (xcb_connection_t *c /**< */, 11588 xcb_glx_context_tag_t context_tag /**< */, 11589 int32_t n /**< */) 11590 { 11591 static const xcb_protocol_request_t xcb_req = { 11592 /* count */ 2, 11593 /* ext */ &xcb_glx_id, 11594 /* opcode */ XCB_GLX_GEN_TEXTURES, 11595 /* isvoid */ 0 11596 }; 11597 11598 struct iovec xcb_parts[4]; 11599 xcb_glx_gen_textures_cookie_t xcb_ret; 11600 xcb_glx_gen_textures_request_t xcb_out; 11601 11602 xcb_out.context_tag = context_tag; 11603 xcb_out.n = n; 11604 11605 xcb_parts[2].iov_base = (char *) &xcb_out; 11606 xcb_parts[2].iov_len = sizeof(xcb_out); 11607 xcb_parts[3].iov_base = 0; 11608 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11609 11610 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11611 return xcb_ret; 11612 } 11613 11614 11615 /***************************************************************************** 11616 ** 11617 ** xcb_glx_gen_textures_cookie_t xcb_glx_gen_textures_unchecked 11618 ** 11619 ** @param xcb_connection_t *c 11620 ** @param xcb_glx_context_tag_t context_tag 11621 ** @param int32_t n 11622 ** @returns xcb_glx_gen_textures_cookie_t 11623 ** 11624 *****************************************************************************/ 11625 11626 xcb_glx_gen_textures_cookie_t 11627 xcb_glx_gen_textures_unchecked (xcb_connection_t *c /**< */, 11628 xcb_glx_context_tag_t context_tag /**< */, 11629 int32_t n /**< */) 11630 { 11631 static const xcb_protocol_request_t xcb_req = { 11632 /* count */ 2, 11633 /* ext */ &xcb_glx_id, 11634 /* opcode */ XCB_GLX_GEN_TEXTURES, 11635 /* isvoid */ 0 11636 }; 11637 11638 struct iovec xcb_parts[4]; 11639 xcb_glx_gen_textures_cookie_t xcb_ret; 11640 xcb_glx_gen_textures_request_t xcb_out; 11641 11642 xcb_out.context_tag = context_tag; 11643 xcb_out.n = n; 11644 11645 xcb_parts[2].iov_base = (char *) &xcb_out; 11646 xcb_parts[2].iov_len = sizeof(xcb_out); 11647 xcb_parts[3].iov_base = 0; 11648 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11649 11650 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11651 return xcb_ret; 11652 } 11653 11654 11655 /***************************************************************************** 11656 ** 11657 ** uint32_t * xcb_glx_gen_textures_data 11658 ** 11659 ** @param const xcb_glx_gen_textures_reply_t *R 11660 ** @returns uint32_t * 11661 ** 11662 *****************************************************************************/ 11663 11664 uint32_t * 11665 xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R /**< */) 11666 { 11667 return (uint32_t *) (R + 1); 11668 } 11669 11670 11671 /***************************************************************************** 11672 ** 11673 ** int xcb_glx_gen_textures_data_length 11674 ** 11675 ** @param const xcb_glx_gen_textures_reply_t *R 11676 ** @returns int 11677 ** 11678 *****************************************************************************/ 11679 11680 int 11681 xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R /**< */) 11682 { 11683 return R->length; 11684 } 11685 11686 11687 /***************************************************************************** 11688 ** 11689 ** xcb_generic_iterator_t xcb_glx_gen_textures_data_end 11690 ** 11691 ** @param const xcb_glx_gen_textures_reply_t *R 11692 ** @returns xcb_generic_iterator_t 11693 ** 11694 *****************************************************************************/ 11695 11696 xcb_generic_iterator_t 11697 xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */) 11698 { 11699 xcb_generic_iterator_t i; 11700 i.data = ((uint32_t *) (R + 1)) + (R->length); 11701 i.rem = 0; 11702 i.index = (char *) i.data - (char *) R; 11703 return i; 11704 } 11705 11706 11707 /***************************************************************************** 11708 ** 11709 ** xcb_glx_gen_textures_reply_t * xcb_glx_gen_textures_reply 11710 ** 11711 ** @param xcb_connection_t *c 11712 ** @param xcb_glx_gen_textures_cookie_t cookie 11713 ** @param xcb_generic_error_t **e 11714 ** @returns xcb_glx_gen_textures_reply_t * 11715 ** 11716 *****************************************************************************/ 11717 11718 xcb_glx_gen_textures_reply_t * 11719 xcb_glx_gen_textures_reply (xcb_connection_t *c /**< */, 11720 xcb_glx_gen_textures_cookie_t cookie /**< */, 11721 xcb_generic_error_t **e /**< */) 11722 { 11723 return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11724 } 11725 11726 11727 /***************************************************************************** 11728 ** 11729 ** xcb_glx_is_texture_cookie_t xcb_glx_is_texture 11730 ** 11731 ** @param xcb_connection_t *c 11732 ** @param xcb_glx_context_tag_t context_tag 11733 ** @param uint32_t texture 11734 ** @returns xcb_glx_is_texture_cookie_t 11735 ** 11736 *****************************************************************************/ 11737 11738 xcb_glx_is_texture_cookie_t 11739 xcb_glx_is_texture (xcb_connection_t *c /**< */, 11740 xcb_glx_context_tag_t context_tag /**< */, 11741 uint32_t texture /**< */) 11742 { 11743 static const xcb_protocol_request_t xcb_req = { 11744 /* count */ 2, 11745 /* ext */ &xcb_glx_id, 11746 /* opcode */ XCB_GLX_IS_TEXTURE, 11747 /* isvoid */ 0 11748 }; 11749 11750 struct iovec xcb_parts[4]; 11751 xcb_glx_is_texture_cookie_t xcb_ret; 11752 xcb_glx_is_texture_request_t xcb_out; 11753 11754 xcb_out.context_tag = context_tag; 11755 xcb_out.texture = texture; 11756 11757 xcb_parts[2].iov_base = (char *) &xcb_out; 11758 xcb_parts[2].iov_len = sizeof(xcb_out); 11759 xcb_parts[3].iov_base = 0; 11760 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11761 11762 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11763 return xcb_ret; 11764 } 11765 11766 11767 /***************************************************************************** 11768 ** 11769 ** xcb_glx_is_texture_cookie_t xcb_glx_is_texture_unchecked 11770 ** 11771 ** @param xcb_connection_t *c 11772 ** @param xcb_glx_context_tag_t context_tag 11773 ** @param uint32_t texture 11774 ** @returns xcb_glx_is_texture_cookie_t 11775 ** 11776 *****************************************************************************/ 11777 11778 xcb_glx_is_texture_cookie_t 11779 xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, 11780 xcb_glx_context_tag_t context_tag /**< */, 11781 uint32_t texture /**< */) 11782 { 11783 static const xcb_protocol_request_t xcb_req = { 11784 /* count */ 2, 11785 /* ext */ &xcb_glx_id, 11786 /* opcode */ XCB_GLX_IS_TEXTURE, 11787 /* isvoid */ 0 11788 }; 11789 11790 struct iovec xcb_parts[4]; 11791 xcb_glx_is_texture_cookie_t xcb_ret; 11792 xcb_glx_is_texture_request_t xcb_out; 11793 11794 xcb_out.context_tag = context_tag; 11795 xcb_out.texture = texture; 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, 0, xcb_parts + 2, &xcb_req); 11803 return xcb_ret; 11804 } 11805 11806 11807 /***************************************************************************** 11808 ** 11809 ** xcb_glx_is_texture_reply_t * xcb_glx_is_texture_reply 11810 ** 11811 ** @param xcb_connection_t *c 11812 ** @param xcb_glx_is_texture_cookie_t cookie 11813 ** @param xcb_generic_error_t **e 11814 ** @returns xcb_glx_is_texture_reply_t * 11815 ** 11816 *****************************************************************************/ 11817 11818 xcb_glx_is_texture_reply_t * 11819 xcb_glx_is_texture_reply (xcb_connection_t *c /**< */, 11820 xcb_glx_is_texture_cookie_t cookie /**< */, 11821 xcb_generic_error_t **e /**< */) 11822 { 11823 return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11824 } 11825 11826 int 11827 xcb_glx_get_color_table_sizeof (const void *_buffer /**< */) 11828 { 11829 char *xcb_tmp = (char *)_buffer; 11830 const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer; 11831 unsigned int xcb_buffer_len = 0; 11832 unsigned int xcb_block_len = 0; 11833 unsigned int xcb_pad = 0; 11834 unsigned int xcb_align_to = 0; 11835 11836 11837 xcb_block_len += sizeof(xcb_glx_get_color_table_reply_t); 11838 xcb_tmp += xcb_block_len; 11839 xcb_buffer_len += xcb_block_len; 11840 xcb_block_len = 0; 11841 /* data */ 11842 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 11843 xcb_tmp += xcb_block_len; 11844 xcb_align_to = ALIGNOF(uint8_t); 11845 /* insert padding */ 11846 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11847 xcb_buffer_len += xcb_block_len + xcb_pad; 11848 if (0 != xcb_pad) { 11849 xcb_tmp += xcb_pad; 11850 xcb_pad = 0; 11851 } 11852 xcb_block_len = 0; 11853 11854 return xcb_buffer_len; 11855 } 11856 11857 11858 /***************************************************************************** 11859 ** 11860 ** xcb_glx_get_color_table_cookie_t xcb_glx_get_color_table 11861 ** 11862 ** @param xcb_connection_t *c 11863 ** @param xcb_glx_context_tag_t context_tag 11864 ** @param uint32_t target 11865 ** @param uint32_t format 11866 ** @param uint32_t type 11867 ** @param uint8_t swap_bytes 11868 ** @returns xcb_glx_get_color_table_cookie_t 11869 ** 11870 *****************************************************************************/ 11871 11872 xcb_glx_get_color_table_cookie_t 11873 xcb_glx_get_color_table (xcb_connection_t *c /**< */, 11874 xcb_glx_context_tag_t context_tag /**< */, 11875 uint32_t target /**< */, 11876 uint32_t format /**< */, 11877 uint32_t type /**< */, 11878 uint8_t swap_bytes /**< */) 11879 { 11880 static const xcb_protocol_request_t xcb_req = { 11881 /* count */ 2, 11882 /* ext */ &xcb_glx_id, 11883 /* opcode */ XCB_GLX_GET_COLOR_TABLE, 11884 /* isvoid */ 0 11885 }; 11886 11887 struct iovec xcb_parts[4]; 11888 xcb_glx_get_color_table_cookie_t xcb_ret; 11889 xcb_glx_get_color_table_request_t xcb_out; 11890 11891 xcb_out.context_tag = context_tag; 11892 xcb_out.target = target; 11893 xcb_out.format = format; 11894 xcb_out.type = type; 11895 xcb_out.swap_bytes = swap_bytes; 11896 11897 xcb_parts[2].iov_base = (char *) &xcb_out; 11898 xcb_parts[2].iov_len = sizeof(xcb_out); 11899 xcb_parts[3].iov_base = 0; 11900 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11901 11902 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11903 return xcb_ret; 11904 } 11905 11906 11907 /***************************************************************************** 11908 ** 11909 ** xcb_glx_get_color_table_cookie_t xcb_glx_get_color_table_unchecked 11910 ** 11911 ** @param xcb_connection_t *c 11912 ** @param xcb_glx_context_tag_t context_tag 11913 ** @param uint32_t target 11914 ** @param uint32_t format 11915 ** @param uint32_t type 11916 ** @param uint8_t swap_bytes 11917 ** @returns xcb_glx_get_color_table_cookie_t 11918 ** 11919 *****************************************************************************/ 11920 11921 xcb_glx_get_color_table_cookie_t 11922 xcb_glx_get_color_table_unchecked (xcb_connection_t *c /**< */, 11923 xcb_glx_context_tag_t context_tag /**< */, 11924 uint32_t target /**< */, 11925 uint32_t format /**< */, 11926 uint32_t type /**< */, 11927 uint8_t swap_bytes /**< */) 11928 { 11929 static const xcb_protocol_request_t xcb_req = { 11930 /* count */ 2, 11931 /* ext */ &xcb_glx_id, 11932 /* opcode */ XCB_GLX_GET_COLOR_TABLE, 11933 /* isvoid */ 0 11934 }; 11935 11936 struct iovec xcb_parts[4]; 11937 xcb_glx_get_color_table_cookie_t xcb_ret; 11938 xcb_glx_get_color_table_request_t xcb_out; 11939 11940 xcb_out.context_tag = context_tag; 11941 xcb_out.target = target; 11942 xcb_out.format = format; 11943 xcb_out.type = type; 11944 xcb_out.swap_bytes = swap_bytes; 11945 11946 xcb_parts[2].iov_base = (char *) &xcb_out; 11947 xcb_parts[2].iov_len = sizeof(xcb_out); 11948 xcb_parts[3].iov_base = 0; 11949 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11950 11951 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11952 return xcb_ret; 11953 } 11954 11955 11956 /***************************************************************************** 11957 ** 11958 ** uint8_t * xcb_glx_get_color_table_data 11959 ** 11960 ** @param const xcb_glx_get_color_table_reply_t *R 11961 ** @returns uint8_t * 11962 ** 11963 *****************************************************************************/ 11964 11965 uint8_t * 11966 xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R /**< */) 11967 { 11968 return (uint8_t *) (R + 1); 11969 } 11970 11971 11972 /***************************************************************************** 11973 ** 11974 ** int xcb_glx_get_color_table_data_length 11975 ** 11976 ** @param const xcb_glx_get_color_table_reply_t *R 11977 ** @returns int 11978 ** 11979 *****************************************************************************/ 11980 11981 int 11982 xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R /**< */) 11983 { 11984 return (R->length * 4); 11985 } 11986 11987 11988 /***************************************************************************** 11989 ** 11990 ** xcb_generic_iterator_t xcb_glx_get_color_table_data_end 11991 ** 11992 ** @param const xcb_glx_get_color_table_reply_t *R 11993 ** @returns xcb_generic_iterator_t 11994 ** 11995 *****************************************************************************/ 11996 11997 xcb_generic_iterator_t 11998 xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< */) 11999 { 12000 xcb_generic_iterator_t i; 12001 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 12002 i.rem = 0; 12003 i.index = (char *) i.data - (char *) R; 12004 return i; 12005 } 12006 12007 12008 /***************************************************************************** 12009 ** 12010 ** xcb_glx_get_color_table_reply_t * xcb_glx_get_color_table_reply 12011 ** 12012 ** @param xcb_connection_t *c 12013 ** @param xcb_glx_get_color_table_cookie_t cookie 12014 ** @param xcb_generic_error_t **e 12015 ** @returns xcb_glx_get_color_table_reply_t * 12016 ** 12017 *****************************************************************************/ 12018 12019 xcb_glx_get_color_table_reply_t * 12020 xcb_glx_get_color_table_reply (xcb_connection_t *c /**< */, 12021 xcb_glx_get_color_table_cookie_t cookie /**< */, 12022 xcb_generic_error_t **e /**< */) 12023 { 12024 return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12025 } 12026 12027 int 12028 xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */) 12029 { 12030 char *xcb_tmp = (char *)_buffer; 12031 const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer; 12032 unsigned int xcb_buffer_len = 0; 12033 unsigned int xcb_block_len = 0; 12034 unsigned int xcb_pad = 0; 12035 unsigned int xcb_align_to = 0; 12036 12037 12038 xcb_block_len += sizeof(xcb_glx_get_color_table_parameterfv_reply_t); 12039 xcb_tmp += xcb_block_len; 12040 xcb_buffer_len += xcb_block_len; 12041 xcb_block_len = 0; 12042 /* data */ 12043 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 12044 xcb_tmp += xcb_block_len; 12045 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 12046 /* insert padding */ 12047 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12048 xcb_buffer_len += xcb_block_len + xcb_pad; 12049 if (0 != xcb_pad) { 12050 xcb_tmp += xcb_pad; 12051 xcb_pad = 0; 12052 } 12053 xcb_block_len = 0; 12054 12055 return xcb_buffer_len; 12056 } 12057 12058 12059 /***************************************************************************** 12060 ** 12061 ** xcb_glx_get_color_table_parameterfv_cookie_t xcb_glx_get_color_table_parameterfv 12062 ** 12063 ** @param xcb_connection_t *c 12064 ** @param xcb_glx_context_tag_t context_tag 12065 ** @param uint32_t target 12066 ** @param uint32_t pname 12067 ** @returns xcb_glx_get_color_table_parameterfv_cookie_t 12068 ** 12069 *****************************************************************************/ 12070 12071 xcb_glx_get_color_table_parameterfv_cookie_t 12072 xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, 12073 xcb_glx_context_tag_t context_tag /**< */, 12074 uint32_t target /**< */, 12075 uint32_t pname /**< */) 12076 { 12077 static const xcb_protocol_request_t xcb_req = { 12078 /* count */ 2, 12079 /* ext */ &xcb_glx_id, 12080 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 12081 /* isvoid */ 0 12082 }; 12083 12084 struct iovec xcb_parts[4]; 12085 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 12086 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 12087 12088 xcb_out.context_tag = context_tag; 12089 xcb_out.target = target; 12090 xcb_out.pname = pname; 12091 12092 xcb_parts[2].iov_base = (char *) &xcb_out; 12093 xcb_parts[2].iov_len = sizeof(xcb_out); 12094 xcb_parts[3].iov_base = 0; 12095 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12096 12097 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12098 return xcb_ret; 12099 } 12100 12101 12102 /***************************************************************************** 12103 ** 12104 ** xcb_glx_get_color_table_parameterfv_cookie_t xcb_glx_get_color_table_parameterfv_unchecked 12105 ** 12106 ** @param xcb_connection_t *c 12107 ** @param xcb_glx_context_tag_t context_tag 12108 ** @param uint32_t target 12109 ** @param uint32_t pname 12110 ** @returns xcb_glx_get_color_table_parameterfv_cookie_t 12111 ** 12112 *****************************************************************************/ 12113 12114 xcb_glx_get_color_table_parameterfv_cookie_t 12115 xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c /**< */, 12116 xcb_glx_context_tag_t context_tag /**< */, 12117 uint32_t target /**< */, 12118 uint32_t pname /**< */) 12119 { 12120 static const xcb_protocol_request_t xcb_req = { 12121 /* count */ 2, 12122 /* ext */ &xcb_glx_id, 12123 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 12124 /* isvoid */ 0 12125 }; 12126 12127 struct iovec xcb_parts[4]; 12128 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 12129 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 12130 12131 xcb_out.context_tag = context_tag; 12132 xcb_out.target = target; 12133 xcb_out.pname = pname; 12134 12135 xcb_parts[2].iov_base = (char *) &xcb_out; 12136 xcb_parts[2].iov_len = sizeof(xcb_out); 12137 xcb_parts[3].iov_base = 0; 12138 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12139 12140 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12141 return xcb_ret; 12142 } 12143 12144 12145 /***************************************************************************** 12146 ** 12147 ** xcb_glx_float32_t * xcb_glx_get_color_table_parameterfv_data 12148 ** 12149 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12150 ** @returns xcb_glx_float32_t * 12151 ** 12152 *****************************************************************************/ 12153 12154 xcb_glx_float32_t * 12155 xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12156 { 12157 return (xcb_glx_float32_t *) (R + 1); 12158 } 12159 12160 12161 /***************************************************************************** 12162 ** 12163 ** int xcb_glx_get_color_table_parameterfv_data_length 12164 ** 12165 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12166 ** @returns int 12167 ** 12168 *****************************************************************************/ 12169 12170 int 12171 xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12172 { 12173 return R->n; 12174 } 12175 12176 12177 /***************************************************************************** 12178 ** 12179 ** xcb_generic_iterator_t xcb_glx_get_color_table_parameterfv_data_end 12180 ** 12181 ** @param const xcb_glx_get_color_table_parameterfv_reply_t *R 12182 ** @returns xcb_generic_iterator_t 12183 ** 12184 *****************************************************************************/ 12185 12186 xcb_generic_iterator_t 12187 xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) 12188 { 12189 xcb_generic_iterator_t i; 12190 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 12191 i.rem = 0; 12192 i.index = (char *) i.data - (char *) R; 12193 return i; 12194 } 12195 12196 12197 /***************************************************************************** 12198 ** 12199 ** xcb_glx_get_color_table_parameterfv_reply_t * xcb_glx_get_color_table_parameterfv_reply 12200 ** 12201 ** @param xcb_connection_t *c 12202 ** @param xcb_glx_get_color_table_parameterfv_cookie_t cookie 12203 ** @param xcb_generic_error_t **e 12204 ** @returns xcb_glx_get_color_table_parameterfv_reply_t * 12205 ** 12206 *****************************************************************************/ 12207 12208 xcb_glx_get_color_table_parameterfv_reply_t * 12209 xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c /**< */, 12210 xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, 12211 xcb_generic_error_t **e /**< */) 12212 { 12213 return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12214 } 12215 12216 int 12217 xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */) 12218 { 12219 char *xcb_tmp = (char *)_buffer; 12220 const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer; 12221 unsigned int xcb_buffer_len = 0; 12222 unsigned int xcb_block_len = 0; 12223 unsigned int xcb_pad = 0; 12224 unsigned int xcb_align_to = 0; 12225 12226 12227 xcb_block_len += sizeof(xcb_glx_get_color_table_parameteriv_reply_t); 12228 xcb_tmp += xcb_block_len; 12229 xcb_buffer_len += xcb_block_len; 12230 xcb_block_len = 0; 12231 /* data */ 12232 xcb_block_len += _aux->n * sizeof(int32_t); 12233 xcb_tmp += xcb_block_len; 12234 xcb_align_to = ALIGNOF(int32_t); 12235 /* insert padding */ 12236 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12237 xcb_buffer_len += xcb_block_len + xcb_pad; 12238 if (0 != xcb_pad) { 12239 xcb_tmp += xcb_pad; 12240 xcb_pad = 0; 12241 } 12242 xcb_block_len = 0; 12243 12244 return xcb_buffer_len; 12245 } 12246 12247 12248 /***************************************************************************** 12249 ** 12250 ** xcb_glx_get_color_table_parameteriv_cookie_t xcb_glx_get_color_table_parameteriv 12251 ** 12252 ** @param xcb_connection_t *c 12253 ** @param xcb_glx_context_tag_t context_tag 12254 ** @param uint32_t target 12255 ** @param uint32_t pname 12256 ** @returns xcb_glx_get_color_table_parameteriv_cookie_t 12257 ** 12258 *****************************************************************************/ 12259 12260 xcb_glx_get_color_table_parameteriv_cookie_t 12261 xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, 12262 xcb_glx_context_tag_t context_tag /**< */, 12263 uint32_t target /**< */, 12264 uint32_t pname /**< */) 12265 { 12266 static const xcb_protocol_request_t xcb_req = { 12267 /* count */ 2, 12268 /* ext */ &xcb_glx_id, 12269 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 12270 /* isvoid */ 0 12271 }; 12272 12273 struct iovec xcb_parts[4]; 12274 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 12275 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 12276 12277 xcb_out.context_tag = context_tag; 12278 xcb_out.target = target; 12279 xcb_out.pname = pname; 12280 12281 xcb_parts[2].iov_base = (char *) &xcb_out; 12282 xcb_parts[2].iov_len = sizeof(xcb_out); 12283 xcb_parts[3].iov_base = 0; 12284 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12285 12286 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12287 return xcb_ret; 12288 } 12289 12290 12291 /***************************************************************************** 12292 ** 12293 ** xcb_glx_get_color_table_parameteriv_cookie_t xcb_glx_get_color_table_parameteriv_unchecked 12294 ** 12295 ** @param xcb_connection_t *c 12296 ** @param xcb_glx_context_tag_t context_tag 12297 ** @param uint32_t target 12298 ** @param uint32_t pname 12299 ** @returns xcb_glx_get_color_table_parameteriv_cookie_t 12300 ** 12301 *****************************************************************************/ 12302 12303 xcb_glx_get_color_table_parameteriv_cookie_t 12304 xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c /**< */, 12305 xcb_glx_context_tag_t context_tag /**< */, 12306 uint32_t target /**< */, 12307 uint32_t pname /**< */) 12308 { 12309 static const xcb_protocol_request_t xcb_req = { 12310 /* count */ 2, 12311 /* ext */ &xcb_glx_id, 12312 /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 12313 /* isvoid */ 0 12314 }; 12315 12316 struct iovec xcb_parts[4]; 12317 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 12318 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 12319 12320 xcb_out.context_tag = context_tag; 12321 xcb_out.target = target; 12322 xcb_out.pname = pname; 12323 12324 xcb_parts[2].iov_base = (char *) &xcb_out; 12325 xcb_parts[2].iov_len = sizeof(xcb_out); 12326 xcb_parts[3].iov_base = 0; 12327 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12328 12329 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12330 return xcb_ret; 12331 } 12332 12333 12334 /***************************************************************************** 12335 ** 12336 ** int32_t * xcb_glx_get_color_table_parameteriv_data 12337 ** 12338 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12339 ** @returns int32_t * 12340 ** 12341 *****************************************************************************/ 12342 12343 int32_t * 12344 xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12345 { 12346 return (int32_t *) (R + 1); 12347 } 12348 12349 12350 /***************************************************************************** 12351 ** 12352 ** int xcb_glx_get_color_table_parameteriv_data_length 12353 ** 12354 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12355 ** @returns int 12356 ** 12357 *****************************************************************************/ 12358 12359 int 12360 xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12361 { 12362 return R->n; 12363 } 12364 12365 12366 /***************************************************************************** 12367 ** 12368 ** xcb_generic_iterator_t xcb_glx_get_color_table_parameteriv_data_end 12369 ** 12370 ** @param const xcb_glx_get_color_table_parameteriv_reply_t *R 12371 ** @returns xcb_generic_iterator_t 12372 ** 12373 *****************************************************************************/ 12374 12375 xcb_generic_iterator_t 12376 xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) 12377 { 12378 xcb_generic_iterator_t i; 12379 i.data = ((int32_t *) (R + 1)) + (R->n); 12380 i.rem = 0; 12381 i.index = (char *) i.data - (char *) R; 12382 return i; 12383 } 12384 12385 12386 /***************************************************************************** 12387 ** 12388 ** xcb_glx_get_color_table_parameteriv_reply_t * xcb_glx_get_color_table_parameteriv_reply 12389 ** 12390 ** @param xcb_connection_t *c 12391 ** @param xcb_glx_get_color_table_parameteriv_cookie_t cookie 12392 ** @param xcb_generic_error_t **e 12393 ** @returns xcb_glx_get_color_table_parameteriv_reply_t * 12394 ** 12395 *****************************************************************************/ 12396 12397 xcb_glx_get_color_table_parameteriv_reply_t * 12398 xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c /**< */, 12399 xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, 12400 xcb_generic_error_t **e /**< */) 12401 { 12402 return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12403 } 12404 12405 int 12406 xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */) 12407 { 12408 char *xcb_tmp = (char *)_buffer; 12409 const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer; 12410 unsigned int xcb_buffer_len = 0; 12411 unsigned int xcb_block_len = 0; 12412 unsigned int xcb_pad = 0; 12413 unsigned int xcb_align_to = 0; 12414 12415 12416 xcb_block_len += sizeof(xcb_glx_get_convolution_filter_reply_t); 12417 xcb_tmp += xcb_block_len; 12418 xcb_buffer_len += xcb_block_len; 12419 xcb_block_len = 0; 12420 /* data */ 12421 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 12422 xcb_tmp += xcb_block_len; 12423 xcb_align_to = ALIGNOF(uint8_t); 12424 /* insert padding */ 12425 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12426 xcb_buffer_len += xcb_block_len + xcb_pad; 12427 if (0 != xcb_pad) { 12428 xcb_tmp += xcb_pad; 12429 xcb_pad = 0; 12430 } 12431 xcb_block_len = 0; 12432 12433 return xcb_buffer_len; 12434 } 12435 12436 12437 /***************************************************************************** 12438 ** 12439 ** xcb_glx_get_convolution_filter_cookie_t xcb_glx_get_convolution_filter 12440 ** 12441 ** @param xcb_connection_t *c 12442 ** @param xcb_glx_context_tag_t context_tag 12443 ** @param uint32_t target 12444 ** @param uint32_t format 12445 ** @param uint32_t type 12446 ** @param uint8_t swap_bytes 12447 ** @returns xcb_glx_get_convolution_filter_cookie_t 12448 ** 12449 *****************************************************************************/ 12450 12451 xcb_glx_get_convolution_filter_cookie_t 12452 xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, 12453 xcb_glx_context_tag_t context_tag /**< */, 12454 uint32_t target /**< */, 12455 uint32_t format /**< */, 12456 uint32_t type /**< */, 12457 uint8_t swap_bytes /**< */) 12458 { 12459 static const xcb_protocol_request_t xcb_req = { 12460 /* count */ 2, 12461 /* ext */ &xcb_glx_id, 12462 /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, 12463 /* isvoid */ 0 12464 }; 12465 12466 struct iovec xcb_parts[4]; 12467 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 12468 xcb_glx_get_convolution_filter_request_t xcb_out; 12469 12470 xcb_out.context_tag = context_tag; 12471 xcb_out.target = target; 12472 xcb_out.format = format; 12473 xcb_out.type = type; 12474 xcb_out.swap_bytes = swap_bytes; 12475 12476 xcb_parts[2].iov_base = (char *) &xcb_out; 12477 xcb_parts[2].iov_len = sizeof(xcb_out); 12478 xcb_parts[3].iov_base = 0; 12479 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12480 12481 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12482 return xcb_ret; 12483 } 12484 12485 12486 /***************************************************************************** 12487 ** 12488 ** xcb_glx_get_convolution_filter_cookie_t xcb_glx_get_convolution_filter_unchecked 12489 ** 12490 ** @param xcb_connection_t *c 12491 ** @param xcb_glx_context_tag_t context_tag 12492 ** @param uint32_t target 12493 ** @param uint32_t format 12494 ** @param uint32_t type 12495 ** @param uint8_t swap_bytes 12496 ** @returns xcb_glx_get_convolution_filter_cookie_t 12497 ** 12498 *****************************************************************************/ 12499 12500 xcb_glx_get_convolution_filter_cookie_t 12501 xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c /**< */, 12502 xcb_glx_context_tag_t context_tag /**< */, 12503 uint32_t target /**< */, 12504 uint32_t format /**< */, 12505 uint32_t type /**< */, 12506 uint8_t swap_bytes /**< */) 12507 { 12508 static const xcb_protocol_request_t xcb_req = { 12509 /* count */ 2, 12510 /* ext */ &xcb_glx_id, 12511 /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, 12512 /* isvoid */ 0 12513 }; 12514 12515 struct iovec xcb_parts[4]; 12516 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 12517 xcb_glx_get_convolution_filter_request_t xcb_out; 12518 12519 xcb_out.context_tag = context_tag; 12520 xcb_out.target = target; 12521 xcb_out.format = format; 12522 xcb_out.type = type; 12523 xcb_out.swap_bytes = swap_bytes; 12524 12525 xcb_parts[2].iov_base = (char *) &xcb_out; 12526 xcb_parts[2].iov_len = sizeof(xcb_out); 12527 xcb_parts[3].iov_base = 0; 12528 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12529 12530 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12531 return xcb_ret; 12532 } 12533 12534 12535 /***************************************************************************** 12536 ** 12537 ** uint8_t * xcb_glx_get_convolution_filter_data 12538 ** 12539 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12540 ** @returns uint8_t * 12541 ** 12542 *****************************************************************************/ 12543 12544 uint8_t * 12545 xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12546 { 12547 return (uint8_t *) (R + 1); 12548 } 12549 12550 12551 /***************************************************************************** 12552 ** 12553 ** int xcb_glx_get_convolution_filter_data_length 12554 ** 12555 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12556 ** @returns int 12557 ** 12558 *****************************************************************************/ 12559 12560 int 12561 xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12562 { 12563 return (R->length * 4); 12564 } 12565 12566 12567 /***************************************************************************** 12568 ** 12569 ** xcb_generic_iterator_t xcb_glx_get_convolution_filter_data_end 12570 ** 12571 ** @param const xcb_glx_get_convolution_filter_reply_t *R 12572 ** @returns xcb_generic_iterator_t 12573 ** 12574 *****************************************************************************/ 12575 12576 xcb_generic_iterator_t 12577 xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R /**< */) 12578 { 12579 xcb_generic_iterator_t i; 12580 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 12581 i.rem = 0; 12582 i.index = (char *) i.data - (char *) R; 12583 return i; 12584 } 12585 12586 12587 /***************************************************************************** 12588 ** 12589 ** xcb_glx_get_convolution_filter_reply_t * xcb_glx_get_convolution_filter_reply 12590 ** 12591 ** @param xcb_connection_t *c 12592 ** @param xcb_glx_get_convolution_filter_cookie_t cookie 12593 ** @param xcb_generic_error_t **e 12594 ** @returns xcb_glx_get_convolution_filter_reply_t * 12595 ** 12596 *****************************************************************************/ 12597 12598 xcb_glx_get_convolution_filter_reply_t * 12599 xcb_glx_get_convolution_filter_reply (xcb_connection_t *c /**< */, 12600 xcb_glx_get_convolution_filter_cookie_t cookie /**< */, 12601 xcb_generic_error_t **e /**< */) 12602 { 12603 return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12604 } 12605 12606 int 12607 xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */) 12608 { 12609 char *xcb_tmp = (char *)_buffer; 12610 const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer; 12611 unsigned int xcb_buffer_len = 0; 12612 unsigned int xcb_block_len = 0; 12613 unsigned int xcb_pad = 0; 12614 unsigned int xcb_align_to = 0; 12615 12616 12617 xcb_block_len += sizeof(xcb_glx_get_convolution_parameterfv_reply_t); 12618 xcb_tmp += xcb_block_len; 12619 xcb_buffer_len += xcb_block_len; 12620 xcb_block_len = 0; 12621 /* data */ 12622 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 12623 xcb_tmp += xcb_block_len; 12624 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 12625 /* insert padding */ 12626 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12627 xcb_buffer_len += xcb_block_len + xcb_pad; 12628 if (0 != xcb_pad) { 12629 xcb_tmp += xcb_pad; 12630 xcb_pad = 0; 12631 } 12632 xcb_block_len = 0; 12633 12634 return xcb_buffer_len; 12635 } 12636 12637 12638 /***************************************************************************** 12639 ** 12640 ** xcb_glx_get_convolution_parameterfv_cookie_t xcb_glx_get_convolution_parameterfv 12641 ** 12642 ** @param xcb_connection_t *c 12643 ** @param xcb_glx_context_tag_t context_tag 12644 ** @param uint32_t target 12645 ** @param uint32_t pname 12646 ** @returns xcb_glx_get_convolution_parameterfv_cookie_t 12647 ** 12648 *****************************************************************************/ 12649 12650 xcb_glx_get_convolution_parameterfv_cookie_t 12651 xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, 12652 xcb_glx_context_tag_t context_tag /**< */, 12653 uint32_t target /**< */, 12654 uint32_t pname /**< */) 12655 { 12656 static const xcb_protocol_request_t xcb_req = { 12657 /* count */ 2, 12658 /* ext */ &xcb_glx_id, 12659 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 12660 /* isvoid */ 0 12661 }; 12662 12663 struct iovec xcb_parts[4]; 12664 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 12665 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 12666 12667 xcb_out.context_tag = context_tag; 12668 xcb_out.target = target; 12669 xcb_out.pname = pname; 12670 12671 xcb_parts[2].iov_base = (char *) &xcb_out; 12672 xcb_parts[2].iov_len = sizeof(xcb_out); 12673 xcb_parts[3].iov_base = 0; 12674 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12675 12676 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12677 return xcb_ret; 12678 } 12679 12680 12681 /***************************************************************************** 12682 ** 12683 ** xcb_glx_get_convolution_parameterfv_cookie_t xcb_glx_get_convolution_parameterfv_unchecked 12684 ** 12685 ** @param xcb_connection_t *c 12686 ** @param xcb_glx_context_tag_t context_tag 12687 ** @param uint32_t target 12688 ** @param uint32_t pname 12689 ** @returns xcb_glx_get_convolution_parameterfv_cookie_t 12690 ** 12691 *****************************************************************************/ 12692 12693 xcb_glx_get_convolution_parameterfv_cookie_t 12694 xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c /**< */, 12695 xcb_glx_context_tag_t context_tag /**< */, 12696 uint32_t target /**< */, 12697 uint32_t pname /**< */) 12698 { 12699 static const xcb_protocol_request_t xcb_req = { 12700 /* count */ 2, 12701 /* ext */ &xcb_glx_id, 12702 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 12703 /* isvoid */ 0 12704 }; 12705 12706 struct iovec xcb_parts[4]; 12707 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 12708 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 12709 12710 xcb_out.context_tag = context_tag; 12711 xcb_out.target = target; 12712 xcb_out.pname = pname; 12713 12714 xcb_parts[2].iov_base = (char *) &xcb_out; 12715 xcb_parts[2].iov_len = sizeof(xcb_out); 12716 xcb_parts[3].iov_base = 0; 12717 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12718 12719 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12720 return xcb_ret; 12721 } 12722 12723 12724 /***************************************************************************** 12725 ** 12726 ** xcb_glx_float32_t * xcb_glx_get_convolution_parameterfv_data 12727 ** 12728 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12729 ** @returns xcb_glx_float32_t * 12730 ** 12731 *****************************************************************************/ 12732 12733 xcb_glx_float32_t * 12734 xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12735 { 12736 return (xcb_glx_float32_t *) (R + 1); 12737 } 12738 12739 12740 /***************************************************************************** 12741 ** 12742 ** int xcb_glx_get_convolution_parameterfv_data_length 12743 ** 12744 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12745 ** @returns int 12746 ** 12747 *****************************************************************************/ 12748 12749 int 12750 xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12751 { 12752 return R->n; 12753 } 12754 12755 12756 /***************************************************************************** 12757 ** 12758 ** xcb_generic_iterator_t xcb_glx_get_convolution_parameterfv_data_end 12759 ** 12760 ** @param const xcb_glx_get_convolution_parameterfv_reply_t *R 12761 ** @returns xcb_generic_iterator_t 12762 ** 12763 *****************************************************************************/ 12764 12765 xcb_generic_iterator_t 12766 xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) 12767 { 12768 xcb_generic_iterator_t i; 12769 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 12770 i.rem = 0; 12771 i.index = (char *) i.data - (char *) R; 12772 return i; 12773 } 12774 12775 12776 /***************************************************************************** 12777 ** 12778 ** xcb_glx_get_convolution_parameterfv_reply_t * xcb_glx_get_convolution_parameterfv_reply 12779 ** 12780 ** @param xcb_connection_t *c 12781 ** @param xcb_glx_get_convolution_parameterfv_cookie_t cookie 12782 ** @param xcb_generic_error_t **e 12783 ** @returns xcb_glx_get_convolution_parameterfv_reply_t * 12784 ** 12785 *****************************************************************************/ 12786 12787 xcb_glx_get_convolution_parameterfv_reply_t * 12788 xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c /**< */, 12789 xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, 12790 xcb_generic_error_t **e /**< */) 12791 { 12792 return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12793 } 12794 12795 int 12796 xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */) 12797 { 12798 char *xcb_tmp = (char *)_buffer; 12799 const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer; 12800 unsigned int xcb_buffer_len = 0; 12801 unsigned int xcb_block_len = 0; 12802 unsigned int xcb_pad = 0; 12803 unsigned int xcb_align_to = 0; 12804 12805 12806 xcb_block_len += sizeof(xcb_glx_get_convolution_parameteriv_reply_t); 12807 xcb_tmp += xcb_block_len; 12808 xcb_buffer_len += xcb_block_len; 12809 xcb_block_len = 0; 12810 /* data */ 12811 xcb_block_len += _aux->n * sizeof(int32_t); 12812 xcb_tmp += xcb_block_len; 12813 xcb_align_to = ALIGNOF(int32_t); 12814 /* insert padding */ 12815 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12816 xcb_buffer_len += xcb_block_len + xcb_pad; 12817 if (0 != xcb_pad) { 12818 xcb_tmp += xcb_pad; 12819 xcb_pad = 0; 12820 } 12821 xcb_block_len = 0; 12822 12823 return xcb_buffer_len; 12824 } 12825 12826 12827 /***************************************************************************** 12828 ** 12829 ** xcb_glx_get_convolution_parameteriv_cookie_t xcb_glx_get_convolution_parameteriv 12830 ** 12831 ** @param xcb_connection_t *c 12832 ** @param xcb_glx_context_tag_t context_tag 12833 ** @param uint32_t target 12834 ** @param uint32_t pname 12835 ** @returns xcb_glx_get_convolution_parameteriv_cookie_t 12836 ** 12837 *****************************************************************************/ 12838 12839 xcb_glx_get_convolution_parameteriv_cookie_t 12840 xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, 12841 xcb_glx_context_tag_t context_tag /**< */, 12842 uint32_t target /**< */, 12843 uint32_t pname /**< */) 12844 { 12845 static const xcb_protocol_request_t xcb_req = { 12846 /* count */ 2, 12847 /* ext */ &xcb_glx_id, 12848 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 12849 /* isvoid */ 0 12850 }; 12851 12852 struct iovec xcb_parts[4]; 12853 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 12854 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 12855 12856 xcb_out.context_tag = context_tag; 12857 xcb_out.target = target; 12858 xcb_out.pname = pname; 12859 12860 xcb_parts[2].iov_base = (char *) &xcb_out; 12861 xcb_parts[2].iov_len = sizeof(xcb_out); 12862 xcb_parts[3].iov_base = 0; 12863 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12864 12865 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12866 return xcb_ret; 12867 } 12868 12869 12870 /***************************************************************************** 12871 ** 12872 ** xcb_glx_get_convolution_parameteriv_cookie_t xcb_glx_get_convolution_parameteriv_unchecked 12873 ** 12874 ** @param xcb_connection_t *c 12875 ** @param xcb_glx_context_tag_t context_tag 12876 ** @param uint32_t target 12877 ** @param uint32_t pname 12878 ** @returns xcb_glx_get_convolution_parameteriv_cookie_t 12879 ** 12880 *****************************************************************************/ 12881 12882 xcb_glx_get_convolution_parameteriv_cookie_t 12883 xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c /**< */, 12884 xcb_glx_context_tag_t context_tag /**< */, 12885 uint32_t target /**< */, 12886 uint32_t pname /**< */) 12887 { 12888 static const xcb_protocol_request_t xcb_req = { 12889 /* count */ 2, 12890 /* ext */ &xcb_glx_id, 12891 /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 12892 /* isvoid */ 0 12893 }; 12894 12895 struct iovec xcb_parts[4]; 12896 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 12897 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 12898 12899 xcb_out.context_tag = context_tag; 12900 xcb_out.target = target; 12901 xcb_out.pname = pname; 12902 12903 xcb_parts[2].iov_base = (char *) &xcb_out; 12904 xcb_parts[2].iov_len = sizeof(xcb_out); 12905 xcb_parts[3].iov_base = 0; 12906 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12907 12908 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12909 return xcb_ret; 12910 } 12911 12912 12913 /***************************************************************************** 12914 ** 12915 ** int32_t * xcb_glx_get_convolution_parameteriv_data 12916 ** 12917 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12918 ** @returns int32_t * 12919 ** 12920 *****************************************************************************/ 12921 12922 int32_t * 12923 xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12924 { 12925 return (int32_t *) (R + 1); 12926 } 12927 12928 12929 /***************************************************************************** 12930 ** 12931 ** int xcb_glx_get_convolution_parameteriv_data_length 12932 ** 12933 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12934 ** @returns int 12935 ** 12936 *****************************************************************************/ 12937 12938 int 12939 xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12940 { 12941 return R->n; 12942 } 12943 12944 12945 /***************************************************************************** 12946 ** 12947 ** xcb_generic_iterator_t xcb_glx_get_convolution_parameteriv_data_end 12948 ** 12949 ** @param const xcb_glx_get_convolution_parameteriv_reply_t *R 12950 ** @returns xcb_generic_iterator_t 12951 ** 12952 *****************************************************************************/ 12953 12954 xcb_generic_iterator_t 12955 xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) 12956 { 12957 xcb_generic_iterator_t i; 12958 i.data = ((int32_t *) (R + 1)) + (R->n); 12959 i.rem = 0; 12960 i.index = (char *) i.data - (char *) R; 12961 return i; 12962 } 12963 12964 12965 /***************************************************************************** 12966 ** 12967 ** xcb_glx_get_convolution_parameteriv_reply_t * xcb_glx_get_convolution_parameteriv_reply 12968 ** 12969 ** @param xcb_connection_t *c 12970 ** @param xcb_glx_get_convolution_parameteriv_cookie_t cookie 12971 ** @param xcb_generic_error_t **e 12972 ** @returns xcb_glx_get_convolution_parameteriv_reply_t * 12973 ** 12974 *****************************************************************************/ 12975 12976 xcb_glx_get_convolution_parameteriv_reply_t * 12977 xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c /**< */, 12978 xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, 12979 xcb_generic_error_t **e /**< */) 12980 { 12981 return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12982 } 12983 12984 int 12985 xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */) 12986 { 12987 char *xcb_tmp = (char *)_buffer; 12988 const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer; 12989 unsigned int xcb_buffer_len = 0; 12990 unsigned int xcb_block_len = 0; 12991 unsigned int xcb_pad = 0; 12992 unsigned int xcb_align_to = 0; 12993 12994 12995 xcb_block_len += sizeof(xcb_glx_get_separable_filter_reply_t); 12996 xcb_tmp += xcb_block_len; 12997 xcb_buffer_len += xcb_block_len; 12998 xcb_block_len = 0; 12999 /* rows_and_cols */ 13000 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 13001 xcb_tmp += xcb_block_len; 13002 xcb_align_to = ALIGNOF(uint8_t); 13003 /* insert padding */ 13004 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13005 xcb_buffer_len += xcb_block_len + xcb_pad; 13006 if (0 != xcb_pad) { 13007 xcb_tmp += xcb_pad; 13008 xcb_pad = 0; 13009 } 13010 xcb_block_len = 0; 13011 13012 return xcb_buffer_len; 13013 } 13014 13015 13016 /***************************************************************************** 13017 ** 13018 ** xcb_glx_get_separable_filter_cookie_t xcb_glx_get_separable_filter 13019 ** 13020 ** @param xcb_connection_t *c 13021 ** @param xcb_glx_context_tag_t context_tag 13022 ** @param uint32_t target 13023 ** @param uint32_t format 13024 ** @param uint32_t type 13025 ** @param uint8_t swap_bytes 13026 ** @returns xcb_glx_get_separable_filter_cookie_t 13027 ** 13028 *****************************************************************************/ 13029 13030 xcb_glx_get_separable_filter_cookie_t 13031 xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, 13032 xcb_glx_context_tag_t context_tag /**< */, 13033 uint32_t target /**< */, 13034 uint32_t format /**< */, 13035 uint32_t type /**< */, 13036 uint8_t swap_bytes /**< */) 13037 { 13038 static const xcb_protocol_request_t xcb_req = { 13039 /* count */ 2, 13040 /* ext */ &xcb_glx_id, 13041 /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, 13042 /* isvoid */ 0 13043 }; 13044 13045 struct iovec xcb_parts[4]; 13046 xcb_glx_get_separable_filter_cookie_t xcb_ret; 13047 xcb_glx_get_separable_filter_request_t xcb_out; 13048 13049 xcb_out.context_tag = context_tag; 13050 xcb_out.target = target; 13051 xcb_out.format = format; 13052 xcb_out.type = type; 13053 xcb_out.swap_bytes = swap_bytes; 13054 13055 xcb_parts[2].iov_base = (char *) &xcb_out; 13056 xcb_parts[2].iov_len = sizeof(xcb_out); 13057 xcb_parts[3].iov_base = 0; 13058 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13059 13060 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13061 return xcb_ret; 13062 } 13063 13064 13065 /***************************************************************************** 13066 ** 13067 ** xcb_glx_get_separable_filter_cookie_t xcb_glx_get_separable_filter_unchecked 13068 ** 13069 ** @param xcb_connection_t *c 13070 ** @param xcb_glx_context_tag_t context_tag 13071 ** @param uint32_t target 13072 ** @param uint32_t format 13073 ** @param uint32_t type 13074 ** @param uint8_t swap_bytes 13075 ** @returns xcb_glx_get_separable_filter_cookie_t 13076 ** 13077 *****************************************************************************/ 13078 13079 xcb_glx_get_separable_filter_cookie_t 13080 xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c /**< */, 13081 xcb_glx_context_tag_t context_tag /**< */, 13082 uint32_t target /**< */, 13083 uint32_t format /**< */, 13084 uint32_t type /**< */, 13085 uint8_t swap_bytes /**< */) 13086 { 13087 static const xcb_protocol_request_t xcb_req = { 13088 /* count */ 2, 13089 /* ext */ &xcb_glx_id, 13090 /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, 13091 /* isvoid */ 0 13092 }; 13093 13094 struct iovec xcb_parts[4]; 13095 xcb_glx_get_separable_filter_cookie_t xcb_ret; 13096 xcb_glx_get_separable_filter_request_t xcb_out; 13097 13098 xcb_out.context_tag = context_tag; 13099 xcb_out.target = target; 13100 xcb_out.format = format; 13101 xcb_out.type = type; 13102 xcb_out.swap_bytes = swap_bytes; 13103 13104 xcb_parts[2].iov_base = (char *) &xcb_out; 13105 xcb_parts[2].iov_len = sizeof(xcb_out); 13106 xcb_parts[3].iov_base = 0; 13107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13108 13109 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13110 return xcb_ret; 13111 } 13112 13113 13114 /***************************************************************************** 13115 ** 13116 ** uint8_t * xcb_glx_get_separable_filter_rows_and_cols 13117 ** 13118 ** @param const xcb_glx_get_separable_filter_reply_t *R 13119 ** @returns uint8_t * 13120 ** 13121 *****************************************************************************/ 13122 13123 uint8_t * 13124 xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13125 { 13126 return (uint8_t *) (R + 1); 13127 } 13128 13129 13130 /***************************************************************************** 13131 ** 13132 ** int xcb_glx_get_separable_filter_rows_and_cols_length 13133 ** 13134 ** @param const xcb_glx_get_separable_filter_reply_t *R 13135 ** @returns int 13136 ** 13137 *****************************************************************************/ 13138 13139 int 13140 xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13141 { 13142 return (R->length * 4); 13143 } 13144 13145 13146 /***************************************************************************** 13147 ** 13148 ** xcb_generic_iterator_t xcb_glx_get_separable_filter_rows_and_cols_end 13149 ** 13150 ** @param const xcb_glx_get_separable_filter_reply_t *R 13151 ** @returns xcb_generic_iterator_t 13152 ** 13153 *****************************************************************************/ 13154 13155 xcb_generic_iterator_t 13156 xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R /**< */) 13157 { 13158 xcb_generic_iterator_t i; 13159 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13160 i.rem = 0; 13161 i.index = (char *) i.data - (char *) R; 13162 return i; 13163 } 13164 13165 13166 /***************************************************************************** 13167 ** 13168 ** xcb_glx_get_separable_filter_reply_t * xcb_glx_get_separable_filter_reply 13169 ** 13170 ** @param xcb_connection_t *c 13171 ** @param xcb_glx_get_separable_filter_cookie_t cookie 13172 ** @param xcb_generic_error_t **e 13173 ** @returns xcb_glx_get_separable_filter_reply_t * 13174 ** 13175 *****************************************************************************/ 13176 13177 xcb_glx_get_separable_filter_reply_t * 13178 xcb_glx_get_separable_filter_reply (xcb_connection_t *c /**< */, 13179 xcb_glx_get_separable_filter_cookie_t cookie /**< */, 13180 xcb_generic_error_t **e /**< */) 13181 { 13182 return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13183 } 13184 13185 int 13186 xcb_glx_get_histogram_sizeof (const void *_buffer /**< */) 13187 { 13188 char *xcb_tmp = (char *)_buffer; 13189 const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer; 13190 unsigned int xcb_buffer_len = 0; 13191 unsigned int xcb_block_len = 0; 13192 unsigned int xcb_pad = 0; 13193 unsigned int xcb_align_to = 0; 13194 13195 13196 xcb_block_len += sizeof(xcb_glx_get_histogram_reply_t); 13197 xcb_tmp += xcb_block_len; 13198 xcb_buffer_len += xcb_block_len; 13199 xcb_block_len = 0; 13200 /* data */ 13201 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 13202 xcb_tmp += xcb_block_len; 13203 xcb_align_to = ALIGNOF(uint8_t); 13204 /* insert padding */ 13205 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13206 xcb_buffer_len += xcb_block_len + xcb_pad; 13207 if (0 != xcb_pad) { 13208 xcb_tmp += xcb_pad; 13209 xcb_pad = 0; 13210 } 13211 xcb_block_len = 0; 13212 13213 return xcb_buffer_len; 13214 } 13215 13216 13217 /***************************************************************************** 13218 ** 13219 ** xcb_glx_get_histogram_cookie_t xcb_glx_get_histogram 13220 ** 13221 ** @param xcb_connection_t *c 13222 ** @param xcb_glx_context_tag_t context_tag 13223 ** @param uint32_t target 13224 ** @param uint32_t format 13225 ** @param uint32_t type 13226 ** @param uint8_t swap_bytes 13227 ** @param uint8_t reset 13228 ** @returns xcb_glx_get_histogram_cookie_t 13229 ** 13230 *****************************************************************************/ 13231 13232 xcb_glx_get_histogram_cookie_t 13233 xcb_glx_get_histogram (xcb_connection_t *c /**< */, 13234 xcb_glx_context_tag_t context_tag /**< */, 13235 uint32_t target /**< */, 13236 uint32_t format /**< */, 13237 uint32_t type /**< */, 13238 uint8_t swap_bytes /**< */, 13239 uint8_t reset /**< */) 13240 { 13241 static const xcb_protocol_request_t xcb_req = { 13242 /* count */ 2, 13243 /* ext */ &xcb_glx_id, 13244 /* opcode */ XCB_GLX_GET_HISTOGRAM, 13245 /* isvoid */ 0 13246 }; 13247 13248 struct iovec xcb_parts[4]; 13249 xcb_glx_get_histogram_cookie_t xcb_ret; 13250 xcb_glx_get_histogram_request_t xcb_out; 13251 13252 xcb_out.context_tag = context_tag; 13253 xcb_out.target = target; 13254 xcb_out.format = format; 13255 xcb_out.type = type; 13256 xcb_out.swap_bytes = swap_bytes; 13257 xcb_out.reset = reset; 13258 13259 xcb_parts[2].iov_base = (char *) &xcb_out; 13260 xcb_parts[2].iov_len = sizeof(xcb_out); 13261 xcb_parts[3].iov_base = 0; 13262 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13263 13264 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13265 return xcb_ret; 13266 } 13267 13268 13269 /***************************************************************************** 13270 ** 13271 ** xcb_glx_get_histogram_cookie_t xcb_glx_get_histogram_unchecked 13272 ** 13273 ** @param xcb_connection_t *c 13274 ** @param xcb_glx_context_tag_t context_tag 13275 ** @param uint32_t target 13276 ** @param uint32_t format 13277 ** @param uint32_t type 13278 ** @param uint8_t swap_bytes 13279 ** @param uint8_t reset 13280 ** @returns xcb_glx_get_histogram_cookie_t 13281 ** 13282 *****************************************************************************/ 13283 13284 xcb_glx_get_histogram_cookie_t 13285 xcb_glx_get_histogram_unchecked (xcb_connection_t *c /**< */, 13286 xcb_glx_context_tag_t context_tag /**< */, 13287 uint32_t target /**< */, 13288 uint32_t format /**< */, 13289 uint32_t type /**< */, 13290 uint8_t swap_bytes /**< */, 13291 uint8_t reset /**< */) 13292 { 13293 static const xcb_protocol_request_t xcb_req = { 13294 /* count */ 2, 13295 /* ext */ &xcb_glx_id, 13296 /* opcode */ XCB_GLX_GET_HISTOGRAM, 13297 /* isvoid */ 0 13298 }; 13299 13300 struct iovec xcb_parts[4]; 13301 xcb_glx_get_histogram_cookie_t xcb_ret; 13302 xcb_glx_get_histogram_request_t xcb_out; 13303 13304 xcb_out.context_tag = context_tag; 13305 xcb_out.target = target; 13306 xcb_out.format = format; 13307 xcb_out.type = type; 13308 xcb_out.swap_bytes = swap_bytes; 13309 xcb_out.reset = reset; 13310 13311 xcb_parts[2].iov_base = (char *) &xcb_out; 13312 xcb_parts[2].iov_len = sizeof(xcb_out); 13313 xcb_parts[3].iov_base = 0; 13314 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13315 13316 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13317 return xcb_ret; 13318 } 13319 13320 13321 /***************************************************************************** 13322 ** 13323 ** uint8_t * xcb_glx_get_histogram_data 13324 ** 13325 ** @param const xcb_glx_get_histogram_reply_t *R 13326 ** @returns uint8_t * 13327 ** 13328 *****************************************************************************/ 13329 13330 uint8_t * 13331 xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R /**< */) 13332 { 13333 return (uint8_t *) (R + 1); 13334 } 13335 13336 13337 /***************************************************************************** 13338 ** 13339 ** int xcb_glx_get_histogram_data_length 13340 ** 13341 ** @param const xcb_glx_get_histogram_reply_t *R 13342 ** @returns int 13343 ** 13344 *****************************************************************************/ 13345 13346 int 13347 xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R /**< */) 13348 { 13349 return (R->length * 4); 13350 } 13351 13352 13353 /***************************************************************************** 13354 ** 13355 ** xcb_generic_iterator_t xcb_glx_get_histogram_data_end 13356 ** 13357 ** @param const xcb_glx_get_histogram_reply_t *R 13358 ** @returns xcb_generic_iterator_t 13359 ** 13360 *****************************************************************************/ 13361 13362 xcb_generic_iterator_t 13363 xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */) 13364 { 13365 xcb_generic_iterator_t i; 13366 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13367 i.rem = 0; 13368 i.index = (char *) i.data - (char *) R; 13369 return i; 13370 } 13371 13372 13373 /***************************************************************************** 13374 ** 13375 ** xcb_glx_get_histogram_reply_t * xcb_glx_get_histogram_reply 13376 ** 13377 ** @param xcb_connection_t *c 13378 ** @param xcb_glx_get_histogram_cookie_t cookie 13379 ** @param xcb_generic_error_t **e 13380 ** @returns xcb_glx_get_histogram_reply_t * 13381 ** 13382 *****************************************************************************/ 13383 13384 xcb_glx_get_histogram_reply_t * 13385 xcb_glx_get_histogram_reply (xcb_connection_t *c /**< */, 13386 xcb_glx_get_histogram_cookie_t cookie /**< */, 13387 xcb_generic_error_t **e /**< */) 13388 { 13389 return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13390 } 13391 13392 int 13393 xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */) 13394 { 13395 char *xcb_tmp = (char *)_buffer; 13396 const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer; 13397 unsigned int xcb_buffer_len = 0; 13398 unsigned int xcb_block_len = 0; 13399 unsigned int xcb_pad = 0; 13400 unsigned int xcb_align_to = 0; 13401 13402 13403 xcb_block_len += sizeof(xcb_glx_get_histogram_parameterfv_reply_t); 13404 xcb_tmp += xcb_block_len; 13405 xcb_buffer_len += xcb_block_len; 13406 xcb_block_len = 0; 13407 /* data */ 13408 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 13409 xcb_tmp += xcb_block_len; 13410 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 13411 /* insert padding */ 13412 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13413 xcb_buffer_len += xcb_block_len + xcb_pad; 13414 if (0 != xcb_pad) { 13415 xcb_tmp += xcb_pad; 13416 xcb_pad = 0; 13417 } 13418 xcb_block_len = 0; 13419 13420 return xcb_buffer_len; 13421 } 13422 13423 13424 /***************************************************************************** 13425 ** 13426 ** xcb_glx_get_histogram_parameterfv_cookie_t xcb_glx_get_histogram_parameterfv 13427 ** 13428 ** @param xcb_connection_t *c 13429 ** @param xcb_glx_context_tag_t context_tag 13430 ** @param uint32_t target 13431 ** @param uint32_t pname 13432 ** @returns xcb_glx_get_histogram_parameterfv_cookie_t 13433 ** 13434 *****************************************************************************/ 13435 13436 xcb_glx_get_histogram_parameterfv_cookie_t 13437 xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, 13438 xcb_glx_context_tag_t context_tag /**< */, 13439 uint32_t target /**< */, 13440 uint32_t pname /**< */) 13441 { 13442 static const xcb_protocol_request_t xcb_req = { 13443 /* count */ 2, 13444 /* ext */ &xcb_glx_id, 13445 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 13446 /* isvoid */ 0 13447 }; 13448 13449 struct iovec xcb_parts[4]; 13450 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 13451 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 13452 13453 xcb_out.context_tag = context_tag; 13454 xcb_out.target = target; 13455 xcb_out.pname = pname; 13456 13457 xcb_parts[2].iov_base = (char *) &xcb_out; 13458 xcb_parts[2].iov_len = sizeof(xcb_out); 13459 xcb_parts[3].iov_base = 0; 13460 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13461 13462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13463 return xcb_ret; 13464 } 13465 13466 13467 /***************************************************************************** 13468 ** 13469 ** xcb_glx_get_histogram_parameterfv_cookie_t xcb_glx_get_histogram_parameterfv_unchecked 13470 ** 13471 ** @param xcb_connection_t *c 13472 ** @param xcb_glx_context_tag_t context_tag 13473 ** @param uint32_t target 13474 ** @param uint32_t pname 13475 ** @returns xcb_glx_get_histogram_parameterfv_cookie_t 13476 ** 13477 *****************************************************************************/ 13478 13479 xcb_glx_get_histogram_parameterfv_cookie_t 13480 xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c /**< */, 13481 xcb_glx_context_tag_t context_tag /**< */, 13482 uint32_t target /**< */, 13483 uint32_t pname /**< */) 13484 { 13485 static const xcb_protocol_request_t xcb_req = { 13486 /* count */ 2, 13487 /* ext */ &xcb_glx_id, 13488 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 13489 /* isvoid */ 0 13490 }; 13491 13492 struct iovec xcb_parts[4]; 13493 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 13494 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 13495 13496 xcb_out.context_tag = context_tag; 13497 xcb_out.target = target; 13498 xcb_out.pname = pname; 13499 13500 xcb_parts[2].iov_base = (char *) &xcb_out; 13501 xcb_parts[2].iov_len = sizeof(xcb_out); 13502 xcb_parts[3].iov_base = 0; 13503 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13504 13505 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13506 return xcb_ret; 13507 } 13508 13509 13510 /***************************************************************************** 13511 ** 13512 ** xcb_glx_float32_t * xcb_glx_get_histogram_parameterfv_data 13513 ** 13514 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13515 ** @returns xcb_glx_float32_t * 13516 ** 13517 *****************************************************************************/ 13518 13519 xcb_glx_float32_t * 13520 xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13521 { 13522 return (xcb_glx_float32_t *) (R + 1); 13523 } 13524 13525 13526 /***************************************************************************** 13527 ** 13528 ** int xcb_glx_get_histogram_parameterfv_data_length 13529 ** 13530 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13531 ** @returns int 13532 ** 13533 *****************************************************************************/ 13534 13535 int 13536 xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13537 { 13538 return R->n; 13539 } 13540 13541 13542 /***************************************************************************** 13543 ** 13544 ** xcb_generic_iterator_t xcb_glx_get_histogram_parameterfv_data_end 13545 ** 13546 ** @param const xcb_glx_get_histogram_parameterfv_reply_t *R 13547 ** @returns xcb_generic_iterator_t 13548 ** 13549 *****************************************************************************/ 13550 13551 xcb_generic_iterator_t 13552 xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) 13553 { 13554 xcb_generic_iterator_t i; 13555 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 13556 i.rem = 0; 13557 i.index = (char *) i.data - (char *) R; 13558 return i; 13559 } 13560 13561 13562 /***************************************************************************** 13563 ** 13564 ** xcb_glx_get_histogram_parameterfv_reply_t * xcb_glx_get_histogram_parameterfv_reply 13565 ** 13566 ** @param xcb_connection_t *c 13567 ** @param xcb_glx_get_histogram_parameterfv_cookie_t cookie 13568 ** @param xcb_generic_error_t **e 13569 ** @returns xcb_glx_get_histogram_parameterfv_reply_t * 13570 ** 13571 *****************************************************************************/ 13572 13573 xcb_glx_get_histogram_parameterfv_reply_t * 13574 xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c /**< */, 13575 xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, 13576 xcb_generic_error_t **e /**< */) 13577 { 13578 return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13579 } 13580 13581 int 13582 xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */) 13583 { 13584 char *xcb_tmp = (char *)_buffer; 13585 const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer; 13586 unsigned int xcb_buffer_len = 0; 13587 unsigned int xcb_block_len = 0; 13588 unsigned int xcb_pad = 0; 13589 unsigned int xcb_align_to = 0; 13590 13591 13592 xcb_block_len += sizeof(xcb_glx_get_histogram_parameteriv_reply_t); 13593 xcb_tmp += xcb_block_len; 13594 xcb_buffer_len += xcb_block_len; 13595 xcb_block_len = 0; 13596 /* data */ 13597 xcb_block_len += _aux->n * sizeof(int32_t); 13598 xcb_tmp += xcb_block_len; 13599 xcb_align_to = ALIGNOF(int32_t); 13600 /* insert padding */ 13601 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13602 xcb_buffer_len += xcb_block_len + xcb_pad; 13603 if (0 != xcb_pad) { 13604 xcb_tmp += xcb_pad; 13605 xcb_pad = 0; 13606 } 13607 xcb_block_len = 0; 13608 13609 return xcb_buffer_len; 13610 } 13611 13612 13613 /***************************************************************************** 13614 ** 13615 ** xcb_glx_get_histogram_parameteriv_cookie_t xcb_glx_get_histogram_parameteriv 13616 ** 13617 ** @param xcb_connection_t *c 13618 ** @param xcb_glx_context_tag_t context_tag 13619 ** @param uint32_t target 13620 ** @param uint32_t pname 13621 ** @returns xcb_glx_get_histogram_parameteriv_cookie_t 13622 ** 13623 *****************************************************************************/ 13624 13625 xcb_glx_get_histogram_parameteriv_cookie_t 13626 xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, 13627 xcb_glx_context_tag_t context_tag /**< */, 13628 uint32_t target /**< */, 13629 uint32_t pname /**< */) 13630 { 13631 static const xcb_protocol_request_t xcb_req = { 13632 /* count */ 2, 13633 /* ext */ &xcb_glx_id, 13634 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 13635 /* isvoid */ 0 13636 }; 13637 13638 struct iovec xcb_parts[4]; 13639 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 13640 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 13641 13642 xcb_out.context_tag = context_tag; 13643 xcb_out.target = target; 13644 xcb_out.pname = pname; 13645 13646 xcb_parts[2].iov_base = (char *) &xcb_out; 13647 xcb_parts[2].iov_len = sizeof(xcb_out); 13648 xcb_parts[3].iov_base = 0; 13649 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13650 13651 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13652 return xcb_ret; 13653 } 13654 13655 13656 /***************************************************************************** 13657 ** 13658 ** xcb_glx_get_histogram_parameteriv_cookie_t xcb_glx_get_histogram_parameteriv_unchecked 13659 ** 13660 ** @param xcb_connection_t *c 13661 ** @param xcb_glx_context_tag_t context_tag 13662 ** @param uint32_t target 13663 ** @param uint32_t pname 13664 ** @returns xcb_glx_get_histogram_parameteriv_cookie_t 13665 ** 13666 *****************************************************************************/ 13667 13668 xcb_glx_get_histogram_parameteriv_cookie_t 13669 xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c /**< */, 13670 xcb_glx_context_tag_t context_tag /**< */, 13671 uint32_t target /**< */, 13672 uint32_t pname /**< */) 13673 { 13674 static const xcb_protocol_request_t xcb_req = { 13675 /* count */ 2, 13676 /* ext */ &xcb_glx_id, 13677 /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 13678 /* isvoid */ 0 13679 }; 13680 13681 struct iovec xcb_parts[4]; 13682 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 13683 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 13684 13685 xcb_out.context_tag = context_tag; 13686 xcb_out.target = target; 13687 xcb_out.pname = pname; 13688 13689 xcb_parts[2].iov_base = (char *) &xcb_out; 13690 xcb_parts[2].iov_len = sizeof(xcb_out); 13691 xcb_parts[3].iov_base = 0; 13692 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13693 13694 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13695 return xcb_ret; 13696 } 13697 13698 13699 /***************************************************************************** 13700 ** 13701 ** int32_t * xcb_glx_get_histogram_parameteriv_data 13702 ** 13703 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13704 ** @returns int32_t * 13705 ** 13706 *****************************************************************************/ 13707 13708 int32_t * 13709 xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13710 { 13711 return (int32_t *) (R + 1); 13712 } 13713 13714 13715 /***************************************************************************** 13716 ** 13717 ** int xcb_glx_get_histogram_parameteriv_data_length 13718 ** 13719 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13720 ** @returns int 13721 ** 13722 *****************************************************************************/ 13723 13724 int 13725 xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13726 { 13727 return R->n; 13728 } 13729 13730 13731 /***************************************************************************** 13732 ** 13733 ** xcb_generic_iterator_t xcb_glx_get_histogram_parameteriv_data_end 13734 ** 13735 ** @param const xcb_glx_get_histogram_parameteriv_reply_t *R 13736 ** @returns xcb_generic_iterator_t 13737 ** 13738 *****************************************************************************/ 13739 13740 xcb_generic_iterator_t 13741 xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) 13742 { 13743 xcb_generic_iterator_t i; 13744 i.data = ((int32_t *) (R + 1)) + (R->n); 13745 i.rem = 0; 13746 i.index = (char *) i.data - (char *) R; 13747 return i; 13748 } 13749 13750 13751 /***************************************************************************** 13752 ** 13753 ** xcb_glx_get_histogram_parameteriv_reply_t * xcb_glx_get_histogram_parameteriv_reply 13754 ** 13755 ** @param xcb_connection_t *c 13756 ** @param xcb_glx_get_histogram_parameteriv_cookie_t cookie 13757 ** @param xcb_generic_error_t **e 13758 ** @returns xcb_glx_get_histogram_parameteriv_reply_t * 13759 ** 13760 *****************************************************************************/ 13761 13762 xcb_glx_get_histogram_parameteriv_reply_t * 13763 xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c /**< */, 13764 xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, 13765 xcb_generic_error_t **e /**< */) 13766 { 13767 return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13768 } 13769 13770 int 13771 xcb_glx_get_minmax_sizeof (const void *_buffer /**< */) 13772 { 13773 char *xcb_tmp = (char *)_buffer; 13774 const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer; 13775 unsigned int xcb_buffer_len = 0; 13776 unsigned int xcb_block_len = 0; 13777 unsigned int xcb_pad = 0; 13778 unsigned int xcb_align_to = 0; 13779 13780 13781 xcb_block_len += sizeof(xcb_glx_get_minmax_reply_t); 13782 xcb_tmp += xcb_block_len; 13783 xcb_buffer_len += xcb_block_len; 13784 xcb_block_len = 0; 13785 /* data */ 13786 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 13787 xcb_tmp += xcb_block_len; 13788 xcb_align_to = ALIGNOF(uint8_t); 13789 /* insert padding */ 13790 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13791 xcb_buffer_len += xcb_block_len + xcb_pad; 13792 if (0 != xcb_pad) { 13793 xcb_tmp += xcb_pad; 13794 xcb_pad = 0; 13795 } 13796 xcb_block_len = 0; 13797 13798 return xcb_buffer_len; 13799 } 13800 13801 13802 /***************************************************************************** 13803 ** 13804 ** xcb_glx_get_minmax_cookie_t xcb_glx_get_minmax 13805 ** 13806 ** @param xcb_connection_t *c 13807 ** @param xcb_glx_context_tag_t context_tag 13808 ** @param uint32_t target 13809 ** @param uint32_t format 13810 ** @param uint32_t type 13811 ** @param uint8_t swap_bytes 13812 ** @param uint8_t reset 13813 ** @returns xcb_glx_get_minmax_cookie_t 13814 ** 13815 *****************************************************************************/ 13816 13817 xcb_glx_get_minmax_cookie_t 13818 xcb_glx_get_minmax (xcb_connection_t *c /**< */, 13819 xcb_glx_context_tag_t context_tag /**< */, 13820 uint32_t target /**< */, 13821 uint32_t format /**< */, 13822 uint32_t type /**< */, 13823 uint8_t swap_bytes /**< */, 13824 uint8_t reset /**< */) 13825 { 13826 static const xcb_protocol_request_t xcb_req = { 13827 /* count */ 2, 13828 /* ext */ &xcb_glx_id, 13829 /* opcode */ XCB_GLX_GET_MINMAX, 13830 /* isvoid */ 0 13831 }; 13832 13833 struct iovec xcb_parts[4]; 13834 xcb_glx_get_minmax_cookie_t xcb_ret; 13835 xcb_glx_get_minmax_request_t xcb_out; 13836 13837 xcb_out.context_tag = context_tag; 13838 xcb_out.target = target; 13839 xcb_out.format = format; 13840 xcb_out.type = type; 13841 xcb_out.swap_bytes = swap_bytes; 13842 xcb_out.reset = reset; 13843 13844 xcb_parts[2].iov_base = (char *) &xcb_out; 13845 xcb_parts[2].iov_len = sizeof(xcb_out); 13846 xcb_parts[3].iov_base = 0; 13847 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13848 13849 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13850 return xcb_ret; 13851 } 13852 13853 13854 /***************************************************************************** 13855 ** 13856 ** xcb_glx_get_minmax_cookie_t xcb_glx_get_minmax_unchecked 13857 ** 13858 ** @param xcb_connection_t *c 13859 ** @param xcb_glx_context_tag_t context_tag 13860 ** @param uint32_t target 13861 ** @param uint32_t format 13862 ** @param uint32_t type 13863 ** @param uint8_t swap_bytes 13864 ** @param uint8_t reset 13865 ** @returns xcb_glx_get_minmax_cookie_t 13866 ** 13867 *****************************************************************************/ 13868 13869 xcb_glx_get_minmax_cookie_t 13870 xcb_glx_get_minmax_unchecked (xcb_connection_t *c /**< */, 13871 xcb_glx_context_tag_t context_tag /**< */, 13872 uint32_t target /**< */, 13873 uint32_t format /**< */, 13874 uint32_t type /**< */, 13875 uint8_t swap_bytes /**< */, 13876 uint8_t reset /**< */) 13877 { 13878 static const xcb_protocol_request_t xcb_req = { 13879 /* count */ 2, 13880 /* ext */ &xcb_glx_id, 13881 /* opcode */ XCB_GLX_GET_MINMAX, 13882 /* isvoid */ 0 13883 }; 13884 13885 struct iovec xcb_parts[4]; 13886 xcb_glx_get_minmax_cookie_t xcb_ret; 13887 xcb_glx_get_minmax_request_t xcb_out; 13888 13889 xcb_out.context_tag = context_tag; 13890 xcb_out.target = target; 13891 xcb_out.format = format; 13892 xcb_out.type = type; 13893 xcb_out.swap_bytes = swap_bytes; 13894 xcb_out.reset = reset; 13895 13896 xcb_parts[2].iov_base = (char *) &xcb_out; 13897 xcb_parts[2].iov_len = sizeof(xcb_out); 13898 xcb_parts[3].iov_base = 0; 13899 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13900 13901 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13902 return xcb_ret; 13903 } 13904 13905 13906 /***************************************************************************** 13907 ** 13908 ** uint8_t * xcb_glx_get_minmax_data 13909 ** 13910 ** @param const xcb_glx_get_minmax_reply_t *R 13911 ** @returns uint8_t * 13912 ** 13913 *****************************************************************************/ 13914 13915 uint8_t * 13916 xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R /**< */) 13917 { 13918 return (uint8_t *) (R + 1); 13919 } 13920 13921 13922 /***************************************************************************** 13923 ** 13924 ** int xcb_glx_get_minmax_data_length 13925 ** 13926 ** @param const xcb_glx_get_minmax_reply_t *R 13927 ** @returns int 13928 ** 13929 *****************************************************************************/ 13930 13931 int 13932 xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R /**< */) 13933 { 13934 return (R->length * 4); 13935 } 13936 13937 13938 /***************************************************************************** 13939 ** 13940 ** xcb_generic_iterator_t xcb_glx_get_minmax_data_end 13941 ** 13942 ** @param const xcb_glx_get_minmax_reply_t *R 13943 ** @returns xcb_generic_iterator_t 13944 ** 13945 *****************************************************************************/ 13946 13947 xcb_generic_iterator_t 13948 xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */) 13949 { 13950 xcb_generic_iterator_t i; 13951 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 13952 i.rem = 0; 13953 i.index = (char *) i.data - (char *) R; 13954 return i; 13955 } 13956 13957 13958 /***************************************************************************** 13959 ** 13960 ** xcb_glx_get_minmax_reply_t * xcb_glx_get_minmax_reply 13961 ** 13962 ** @param xcb_connection_t *c 13963 ** @param xcb_glx_get_minmax_cookie_t cookie 13964 ** @param xcb_generic_error_t **e 13965 ** @returns xcb_glx_get_minmax_reply_t * 13966 ** 13967 *****************************************************************************/ 13968 13969 xcb_glx_get_minmax_reply_t * 13970 xcb_glx_get_minmax_reply (xcb_connection_t *c /**< */, 13971 xcb_glx_get_minmax_cookie_t cookie /**< */, 13972 xcb_generic_error_t **e /**< */) 13973 { 13974 return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13975 } 13976 13977 int 13978 xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */) 13979 { 13980 char *xcb_tmp = (char *)_buffer; 13981 const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer; 13982 unsigned int xcb_buffer_len = 0; 13983 unsigned int xcb_block_len = 0; 13984 unsigned int xcb_pad = 0; 13985 unsigned int xcb_align_to = 0; 13986 13987 13988 xcb_block_len += sizeof(xcb_glx_get_minmax_parameterfv_reply_t); 13989 xcb_tmp += xcb_block_len; 13990 xcb_buffer_len += xcb_block_len; 13991 xcb_block_len = 0; 13992 /* data */ 13993 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 13994 xcb_tmp += xcb_block_len; 13995 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 13996 /* insert padding */ 13997 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13998 xcb_buffer_len += xcb_block_len + xcb_pad; 13999 if (0 != xcb_pad) { 14000 xcb_tmp += xcb_pad; 14001 xcb_pad = 0; 14002 } 14003 xcb_block_len = 0; 14004 14005 return xcb_buffer_len; 14006 } 14007 14008 14009 /***************************************************************************** 14010 ** 14011 ** xcb_glx_get_minmax_parameterfv_cookie_t xcb_glx_get_minmax_parameterfv 14012 ** 14013 ** @param xcb_connection_t *c 14014 ** @param xcb_glx_context_tag_t context_tag 14015 ** @param uint32_t target 14016 ** @param uint32_t pname 14017 ** @returns xcb_glx_get_minmax_parameterfv_cookie_t 14018 ** 14019 *****************************************************************************/ 14020 14021 xcb_glx_get_minmax_parameterfv_cookie_t 14022 xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, 14023 xcb_glx_context_tag_t context_tag /**< */, 14024 uint32_t target /**< */, 14025 uint32_t pname /**< */) 14026 { 14027 static const xcb_protocol_request_t xcb_req = { 14028 /* count */ 2, 14029 /* ext */ &xcb_glx_id, 14030 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, 14031 /* isvoid */ 0 14032 }; 14033 14034 struct iovec xcb_parts[4]; 14035 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 14036 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 14037 14038 xcb_out.context_tag = context_tag; 14039 xcb_out.target = target; 14040 xcb_out.pname = pname; 14041 14042 xcb_parts[2].iov_base = (char *) &xcb_out; 14043 xcb_parts[2].iov_len = sizeof(xcb_out); 14044 xcb_parts[3].iov_base = 0; 14045 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14046 14047 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14048 return xcb_ret; 14049 } 14050 14051 14052 /***************************************************************************** 14053 ** 14054 ** xcb_glx_get_minmax_parameterfv_cookie_t xcb_glx_get_minmax_parameterfv_unchecked 14055 ** 14056 ** @param xcb_connection_t *c 14057 ** @param xcb_glx_context_tag_t context_tag 14058 ** @param uint32_t target 14059 ** @param uint32_t pname 14060 ** @returns xcb_glx_get_minmax_parameterfv_cookie_t 14061 ** 14062 *****************************************************************************/ 14063 14064 xcb_glx_get_minmax_parameterfv_cookie_t 14065 xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c /**< */, 14066 xcb_glx_context_tag_t context_tag /**< */, 14067 uint32_t target /**< */, 14068 uint32_t pname /**< */) 14069 { 14070 static const xcb_protocol_request_t xcb_req = { 14071 /* count */ 2, 14072 /* ext */ &xcb_glx_id, 14073 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, 14074 /* isvoid */ 0 14075 }; 14076 14077 struct iovec xcb_parts[4]; 14078 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 14079 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 14080 14081 xcb_out.context_tag = context_tag; 14082 xcb_out.target = target; 14083 xcb_out.pname = pname; 14084 14085 xcb_parts[2].iov_base = (char *) &xcb_out; 14086 xcb_parts[2].iov_len = sizeof(xcb_out); 14087 xcb_parts[3].iov_base = 0; 14088 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14089 14090 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14091 return xcb_ret; 14092 } 14093 14094 14095 /***************************************************************************** 14096 ** 14097 ** xcb_glx_float32_t * xcb_glx_get_minmax_parameterfv_data 14098 ** 14099 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 14100 ** @returns xcb_glx_float32_t * 14101 ** 14102 *****************************************************************************/ 14103 14104 xcb_glx_float32_t * 14105 xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 14106 { 14107 return (xcb_glx_float32_t *) (R + 1); 14108 } 14109 14110 14111 /***************************************************************************** 14112 ** 14113 ** int xcb_glx_get_minmax_parameterfv_data_length 14114 ** 14115 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 14116 ** @returns int 14117 ** 14118 *****************************************************************************/ 14119 14120 int 14121 xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 14122 { 14123 return R->n; 14124 } 14125 14126 14127 /***************************************************************************** 14128 ** 14129 ** xcb_generic_iterator_t xcb_glx_get_minmax_parameterfv_data_end 14130 ** 14131 ** @param const xcb_glx_get_minmax_parameterfv_reply_t *R 14132 ** @returns xcb_generic_iterator_t 14133 ** 14134 *****************************************************************************/ 14135 14136 xcb_generic_iterator_t 14137 xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) 14138 { 14139 xcb_generic_iterator_t i; 14140 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 14141 i.rem = 0; 14142 i.index = (char *) i.data - (char *) R; 14143 return i; 14144 } 14145 14146 14147 /***************************************************************************** 14148 ** 14149 ** xcb_glx_get_minmax_parameterfv_reply_t * xcb_glx_get_minmax_parameterfv_reply 14150 ** 14151 ** @param xcb_connection_t *c 14152 ** @param xcb_glx_get_minmax_parameterfv_cookie_t cookie 14153 ** @param xcb_generic_error_t **e 14154 ** @returns xcb_glx_get_minmax_parameterfv_reply_t * 14155 ** 14156 *****************************************************************************/ 14157 14158 xcb_glx_get_minmax_parameterfv_reply_t * 14159 xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c /**< */, 14160 xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, 14161 xcb_generic_error_t **e /**< */) 14162 { 14163 return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14164 } 14165 14166 int 14167 xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */) 14168 { 14169 char *xcb_tmp = (char *)_buffer; 14170 const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer; 14171 unsigned int xcb_buffer_len = 0; 14172 unsigned int xcb_block_len = 0; 14173 unsigned int xcb_pad = 0; 14174 unsigned int xcb_align_to = 0; 14175 14176 14177 xcb_block_len += sizeof(xcb_glx_get_minmax_parameteriv_reply_t); 14178 xcb_tmp += xcb_block_len; 14179 xcb_buffer_len += xcb_block_len; 14180 xcb_block_len = 0; 14181 /* data */ 14182 xcb_block_len += _aux->n * sizeof(int32_t); 14183 xcb_tmp += xcb_block_len; 14184 xcb_align_to = ALIGNOF(int32_t); 14185 /* insert padding */ 14186 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14187 xcb_buffer_len += xcb_block_len + xcb_pad; 14188 if (0 != xcb_pad) { 14189 xcb_tmp += xcb_pad; 14190 xcb_pad = 0; 14191 } 14192 xcb_block_len = 0; 14193 14194 return xcb_buffer_len; 14195 } 14196 14197 14198 /***************************************************************************** 14199 ** 14200 ** xcb_glx_get_minmax_parameteriv_cookie_t xcb_glx_get_minmax_parameteriv 14201 ** 14202 ** @param xcb_connection_t *c 14203 ** @param xcb_glx_context_tag_t context_tag 14204 ** @param uint32_t target 14205 ** @param uint32_t pname 14206 ** @returns xcb_glx_get_minmax_parameteriv_cookie_t 14207 ** 14208 *****************************************************************************/ 14209 14210 xcb_glx_get_minmax_parameteriv_cookie_t 14211 xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, 14212 xcb_glx_context_tag_t context_tag /**< */, 14213 uint32_t target /**< */, 14214 uint32_t pname /**< */) 14215 { 14216 static const xcb_protocol_request_t xcb_req = { 14217 /* count */ 2, 14218 /* ext */ &xcb_glx_id, 14219 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, 14220 /* isvoid */ 0 14221 }; 14222 14223 struct iovec xcb_parts[4]; 14224 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 14225 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 14226 14227 xcb_out.context_tag = context_tag; 14228 xcb_out.target = target; 14229 xcb_out.pname = pname; 14230 14231 xcb_parts[2].iov_base = (char *) &xcb_out; 14232 xcb_parts[2].iov_len = sizeof(xcb_out); 14233 xcb_parts[3].iov_base = 0; 14234 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14235 14236 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14237 return xcb_ret; 14238 } 14239 14240 14241 /***************************************************************************** 14242 ** 14243 ** xcb_glx_get_minmax_parameteriv_cookie_t xcb_glx_get_minmax_parameteriv_unchecked 14244 ** 14245 ** @param xcb_connection_t *c 14246 ** @param xcb_glx_context_tag_t context_tag 14247 ** @param uint32_t target 14248 ** @param uint32_t pname 14249 ** @returns xcb_glx_get_minmax_parameteriv_cookie_t 14250 ** 14251 *****************************************************************************/ 14252 14253 xcb_glx_get_minmax_parameteriv_cookie_t 14254 xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c /**< */, 14255 xcb_glx_context_tag_t context_tag /**< */, 14256 uint32_t target /**< */, 14257 uint32_t pname /**< */) 14258 { 14259 static const xcb_protocol_request_t xcb_req = { 14260 /* count */ 2, 14261 /* ext */ &xcb_glx_id, 14262 /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, 14263 /* isvoid */ 0 14264 }; 14265 14266 struct iovec xcb_parts[4]; 14267 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 14268 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 14269 14270 xcb_out.context_tag = context_tag; 14271 xcb_out.target = target; 14272 xcb_out.pname = pname; 14273 14274 xcb_parts[2].iov_base = (char *) &xcb_out; 14275 xcb_parts[2].iov_len = sizeof(xcb_out); 14276 xcb_parts[3].iov_base = 0; 14277 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14278 14279 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14280 return xcb_ret; 14281 } 14282 14283 14284 /***************************************************************************** 14285 ** 14286 ** int32_t * xcb_glx_get_minmax_parameteriv_data 14287 ** 14288 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14289 ** @returns int32_t * 14290 ** 14291 *****************************************************************************/ 14292 14293 int32_t * 14294 xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14295 { 14296 return (int32_t *) (R + 1); 14297 } 14298 14299 14300 /***************************************************************************** 14301 ** 14302 ** int xcb_glx_get_minmax_parameteriv_data_length 14303 ** 14304 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14305 ** @returns int 14306 ** 14307 *****************************************************************************/ 14308 14309 int 14310 xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14311 { 14312 return R->n; 14313 } 14314 14315 14316 /***************************************************************************** 14317 ** 14318 ** xcb_generic_iterator_t xcb_glx_get_minmax_parameteriv_data_end 14319 ** 14320 ** @param const xcb_glx_get_minmax_parameteriv_reply_t *R 14321 ** @returns xcb_generic_iterator_t 14322 ** 14323 *****************************************************************************/ 14324 14325 xcb_generic_iterator_t 14326 xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) 14327 { 14328 xcb_generic_iterator_t i; 14329 i.data = ((int32_t *) (R + 1)) + (R->n); 14330 i.rem = 0; 14331 i.index = (char *) i.data - (char *) R; 14332 return i; 14333 } 14334 14335 14336 /***************************************************************************** 14337 ** 14338 ** xcb_glx_get_minmax_parameteriv_reply_t * xcb_glx_get_minmax_parameteriv_reply 14339 ** 14340 ** @param xcb_connection_t *c 14341 ** @param xcb_glx_get_minmax_parameteriv_cookie_t cookie 14342 ** @param xcb_generic_error_t **e 14343 ** @returns xcb_glx_get_minmax_parameteriv_reply_t * 14344 ** 14345 *****************************************************************************/ 14346 14347 xcb_glx_get_minmax_parameteriv_reply_t * 14348 xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c /**< */, 14349 xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, 14350 xcb_generic_error_t **e /**< */) 14351 { 14352 return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14353 } 14354 14355 int 14356 xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */) 14357 { 14358 char *xcb_tmp = (char *)_buffer; 14359 const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer; 14360 unsigned int xcb_buffer_len = 0; 14361 unsigned int xcb_block_len = 0; 14362 unsigned int xcb_pad = 0; 14363 unsigned int xcb_align_to = 0; 14364 14365 14366 xcb_block_len += sizeof(xcb_glx_get_compressed_tex_image_arb_reply_t); 14367 xcb_tmp += xcb_block_len; 14368 xcb_buffer_len += xcb_block_len; 14369 xcb_block_len = 0; 14370 /* data */ 14371 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 14372 xcb_tmp += xcb_block_len; 14373 xcb_align_to = ALIGNOF(uint8_t); 14374 /* insert padding */ 14375 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14376 xcb_buffer_len += xcb_block_len + xcb_pad; 14377 if (0 != xcb_pad) { 14378 xcb_tmp += xcb_pad; 14379 xcb_pad = 0; 14380 } 14381 xcb_block_len = 0; 14382 14383 return xcb_buffer_len; 14384 } 14385 14386 14387 /***************************************************************************** 14388 ** 14389 ** xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_glx_get_compressed_tex_image_arb 14390 ** 14391 ** @param xcb_connection_t *c 14392 ** @param xcb_glx_context_tag_t context_tag 14393 ** @param uint32_t target 14394 ** @param int32_t level 14395 ** @returns xcb_glx_get_compressed_tex_image_arb_cookie_t 14396 ** 14397 *****************************************************************************/ 14398 14399 xcb_glx_get_compressed_tex_image_arb_cookie_t 14400 xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, 14401 xcb_glx_context_tag_t context_tag /**< */, 14402 uint32_t target /**< */, 14403 int32_t level /**< */) 14404 { 14405 static const xcb_protocol_request_t xcb_req = { 14406 /* count */ 2, 14407 /* ext */ &xcb_glx_id, 14408 /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 14409 /* isvoid */ 0 14410 }; 14411 14412 struct iovec xcb_parts[4]; 14413 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 14414 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 14415 14416 xcb_out.context_tag = context_tag; 14417 xcb_out.target = target; 14418 xcb_out.level = level; 14419 14420 xcb_parts[2].iov_base = (char *) &xcb_out; 14421 xcb_parts[2].iov_len = sizeof(xcb_out); 14422 xcb_parts[3].iov_base = 0; 14423 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14424 14425 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14426 return xcb_ret; 14427 } 14428 14429 14430 /***************************************************************************** 14431 ** 14432 ** xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_glx_get_compressed_tex_image_arb_unchecked 14433 ** 14434 ** @param xcb_connection_t *c 14435 ** @param xcb_glx_context_tag_t context_tag 14436 ** @param uint32_t target 14437 ** @param int32_t level 14438 ** @returns xcb_glx_get_compressed_tex_image_arb_cookie_t 14439 ** 14440 *****************************************************************************/ 14441 14442 xcb_glx_get_compressed_tex_image_arb_cookie_t 14443 xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c /**< */, 14444 xcb_glx_context_tag_t context_tag /**< */, 14445 uint32_t target /**< */, 14446 int32_t level /**< */) 14447 { 14448 static const xcb_protocol_request_t xcb_req = { 14449 /* count */ 2, 14450 /* ext */ &xcb_glx_id, 14451 /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 14452 /* isvoid */ 0 14453 }; 14454 14455 struct iovec xcb_parts[4]; 14456 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 14457 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 14458 14459 xcb_out.context_tag = context_tag; 14460 xcb_out.target = target; 14461 xcb_out.level = level; 14462 14463 xcb_parts[2].iov_base = (char *) &xcb_out; 14464 xcb_parts[2].iov_len = sizeof(xcb_out); 14465 xcb_parts[3].iov_base = 0; 14466 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14467 14468 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14469 return xcb_ret; 14470 } 14471 14472 14473 /***************************************************************************** 14474 ** 14475 ** uint8_t * xcb_glx_get_compressed_tex_image_arb_data 14476 ** 14477 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14478 ** @returns uint8_t * 14479 ** 14480 *****************************************************************************/ 14481 14482 uint8_t * 14483 xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14484 { 14485 return (uint8_t *) (R + 1); 14486 } 14487 14488 14489 /***************************************************************************** 14490 ** 14491 ** int xcb_glx_get_compressed_tex_image_arb_data_length 14492 ** 14493 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14494 ** @returns int 14495 ** 14496 *****************************************************************************/ 14497 14498 int 14499 xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14500 { 14501 return (R->length * 4); 14502 } 14503 14504 14505 /***************************************************************************** 14506 ** 14507 ** xcb_generic_iterator_t xcb_glx_get_compressed_tex_image_arb_data_end 14508 ** 14509 ** @param const xcb_glx_get_compressed_tex_image_arb_reply_t *R 14510 ** @returns xcb_generic_iterator_t 14511 ** 14512 *****************************************************************************/ 14513 14514 xcb_generic_iterator_t 14515 xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) 14516 { 14517 xcb_generic_iterator_t i; 14518 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 14519 i.rem = 0; 14520 i.index = (char *) i.data - (char *) R; 14521 return i; 14522 } 14523 14524 14525 /***************************************************************************** 14526 ** 14527 ** xcb_glx_get_compressed_tex_image_arb_reply_t * xcb_glx_get_compressed_tex_image_arb_reply 14528 ** 14529 ** @param xcb_connection_t *c 14530 ** @param xcb_glx_get_compressed_tex_image_arb_cookie_t cookie 14531 ** @param xcb_generic_error_t **e 14532 ** @returns xcb_glx_get_compressed_tex_image_arb_reply_t * 14533 ** 14534 *****************************************************************************/ 14535 14536 xcb_glx_get_compressed_tex_image_arb_reply_t * 14537 xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c /**< */, 14538 xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, 14539 xcb_generic_error_t **e /**< */) 14540 { 14541 return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14542 } 14543 14544 int 14545 xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */) 14546 { 14547 char *xcb_tmp = (char *)_buffer; 14548 const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer; 14549 unsigned int xcb_buffer_len = 0; 14550 unsigned int xcb_block_len = 0; 14551 unsigned int xcb_pad = 0; 14552 unsigned int xcb_align_to = 0; 14553 14554 14555 xcb_block_len += sizeof(xcb_glx_delete_queries_arb_request_t); 14556 xcb_tmp += xcb_block_len; 14557 xcb_buffer_len += xcb_block_len; 14558 xcb_block_len = 0; 14559 /* ids */ 14560 xcb_block_len += _aux->n * sizeof(uint32_t); 14561 xcb_tmp += xcb_block_len; 14562 xcb_align_to = ALIGNOF(uint32_t); 14563 /* insert padding */ 14564 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14565 xcb_buffer_len += xcb_block_len + xcb_pad; 14566 if (0 != xcb_pad) { 14567 xcb_tmp += xcb_pad; 14568 xcb_pad = 0; 14569 } 14570 xcb_block_len = 0; 14571 14572 return xcb_buffer_len; 14573 } 14574 14575 14576 /***************************************************************************** 14577 ** 14578 ** xcb_void_cookie_t xcb_glx_delete_queries_arb_checked 14579 ** 14580 ** @param xcb_connection_t *c 14581 ** @param xcb_glx_context_tag_t context_tag 14582 ** @param int32_t n 14583 ** @param const uint32_t *ids 14584 ** @returns xcb_void_cookie_t 14585 ** 14586 *****************************************************************************/ 14587 14588 xcb_void_cookie_t 14589 xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, 14590 xcb_glx_context_tag_t context_tag /**< */, 14591 int32_t n /**< */, 14592 const uint32_t *ids /**< */) 14593 { 14594 static const xcb_protocol_request_t xcb_req = { 14595 /* count */ 4, 14596 /* ext */ &xcb_glx_id, 14597 /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, 14598 /* isvoid */ 1 14599 }; 14600 14601 struct iovec xcb_parts[6]; 14602 xcb_void_cookie_t xcb_ret; 14603 xcb_glx_delete_queries_arb_request_t xcb_out; 14604 14605 xcb_out.context_tag = context_tag; 14606 xcb_out.n = n; 14607 14608 xcb_parts[2].iov_base = (char *) &xcb_out; 14609 xcb_parts[2].iov_len = sizeof(xcb_out); 14610 xcb_parts[3].iov_base = 0; 14611 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14612 /* uint32_t ids */ 14613 xcb_parts[4].iov_base = (char *) ids; 14614 xcb_parts[4].iov_len = n * sizeof(uint32_t); 14615 xcb_parts[5].iov_base = 0; 14616 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14617 14618 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14619 return xcb_ret; 14620 } 14621 14622 14623 /***************************************************************************** 14624 ** 14625 ** xcb_void_cookie_t xcb_glx_delete_queries_arb 14626 ** 14627 ** @param xcb_connection_t *c 14628 ** @param xcb_glx_context_tag_t context_tag 14629 ** @param int32_t n 14630 ** @param const uint32_t *ids 14631 ** @returns xcb_void_cookie_t 14632 ** 14633 *****************************************************************************/ 14634 14635 xcb_void_cookie_t 14636 xcb_glx_delete_queries_arb (xcb_connection_t *c /**< */, 14637 xcb_glx_context_tag_t context_tag /**< */, 14638 int32_t n /**< */, 14639 const uint32_t *ids /**< */) 14640 { 14641 static const xcb_protocol_request_t xcb_req = { 14642 /* count */ 4, 14643 /* ext */ &xcb_glx_id, 14644 /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, 14645 /* isvoid */ 1 14646 }; 14647 14648 struct iovec xcb_parts[6]; 14649 xcb_void_cookie_t xcb_ret; 14650 xcb_glx_delete_queries_arb_request_t xcb_out; 14651 14652 xcb_out.context_tag = context_tag; 14653 xcb_out.n = n; 14654 14655 xcb_parts[2].iov_base = (char *) &xcb_out; 14656 xcb_parts[2].iov_len = sizeof(xcb_out); 14657 xcb_parts[3].iov_base = 0; 14658 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14659 /* uint32_t ids */ 14660 xcb_parts[4].iov_base = (char *) ids; 14661 xcb_parts[4].iov_len = n * sizeof(uint32_t); 14662 xcb_parts[5].iov_base = 0; 14663 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14664 14665 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14666 return xcb_ret; 14667 } 14668 14669 int 14670 xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */) 14671 { 14672 char *xcb_tmp = (char *)_buffer; 14673 const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer; 14674 unsigned int xcb_buffer_len = 0; 14675 unsigned int xcb_block_len = 0; 14676 unsigned int xcb_pad = 0; 14677 unsigned int xcb_align_to = 0; 14678 14679 14680 xcb_block_len += sizeof(xcb_glx_gen_queries_arb_reply_t); 14681 xcb_tmp += xcb_block_len; 14682 xcb_buffer_len += xcb_block_len; 14683 xcb_block_len = 0; 14684 /* data */ 14685 xcb_block_len += _aux->length * sizeof(uint32_t); 14686 xcb_tmp += xcb_block_len; 14687 xcb_align_to = ALIGNOF(uint32_t); 14688 /* insert padding */ 14689 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14690 xcb_buffer_len += xcb_block_len + xcb_pad; 14691 if (0 != xcb_pad) { 14692 xcb_tmp += xcb_pad; 14693 xcb_pad = 0; 14694 } 14695 xcb_block_len = 0; 14696 14697 return xcb_buffer_len; 14698 } 14699 14700 14701 /***************************************************************************** 14702 ** 14703 ** xcb_glx_gen_queries_arb_cookie_t xcb_glx_gen_queries_arb 14704 ** 14705 ** @param xcb_connection_t *c 14706 ** @param xcb_glx_context_tag_t context_tag 14707 ** @param int32_t n 14708 ** @returns xcb_glx_gen_queries_arb_cookie_t 14709 ** 14710 *****************************************************************************/ 14711 14712 xcb_glx_gen_queries_arb_cookie_t 14713 xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, 14714 xcb_glx_context_tag_t context_tag /**< */, 14715 int32_t n /**< */) 14716 { 14717 static const xcb_protocol_request_t xcb_req = { 14718 /* count */ 2, 14719 /* ext */ &xcb_glx_id, 14720 /* opcode */ XCB_GLX_GEN_QUERIES_ARB, 14721 /* isvoid */ 0 14722 }; 14723 14724 struct iovec xcb_parts[4]; 14725 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 14726 xcb_glx_gen_queries_arb_request_t xcb_out; 14727 14728 xcb_out.context_tag = context_tag; 14729 xcb_out.n = n; 14730 14731 xcb_parts[2].iov_base = (char *) &xcb_out; 14732 xcb_parts[2].iov_len = sizeof(xcb_out); 14733 xcb_parts[3].iov_base = 0; 14734 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14735 14736 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14737 return xcb_ret; 14738 } 14739 14740 14741 /***************************************************************************** 14742 ** 14743 ** xcb_glx_gen_queries_arb_cookie_t xcb_glx_gen_queries_arb_unchecked 14744 ** 14745 ** @param xcb_connection_t *c 14746 ** @param xcb_glx_context_tag_t context_tag 14747 ** @param int32_t n 14748 ** @returns xcb_glx_gen_queries_arb_cookie_t 14749 ** 14750 *****************************************************************************/ 14751 14752 xcb_glx_gen_queries_arb_cookie_t 14753 xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c /**< */, 14754 xcb_glx_context_tag_t context_tag /**< */, 14755 int32_t n /**< */) 14756 { 14757 static const xcb_protocol_request_t xcb_req = { 14758 /* count */ 2, 14759 /* ext */ &xcb_glx_id, 14760 /* opcode */ XCB_GLX_GEN_QUERIES_ARB, 14761 /* isvoid */ 0 14762 }; 14763 14764 struct iovec xcb_parts[4]; 14765 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 14766 xcb_glx_gen_queries_arb_request_t xcb_out; 14767 14768 xcb_out.context_tag = context_tag; 14769 xcb_out.n = n; 14770 14771 xcb_parts[2].iov_base = (char *) &xcb_out; 14772 xcb_parts[2].iov_len = sizeof(xcb_out); 14773 xcb_parts[3].iov_base = 0; 14774 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14775 14776 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14777 return xcb_ret; 14778 } 14779 14780 14781 /***************************************************************************** 14782 ** 14783 ** uint32_t * xcb_glx_gen_queries_arb_data 14784 ** 14785 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14786 ** @returns uint32_t * 14787 ** 14788 *****************************************************************************/ 14789 14790 uint32_t * 14791 xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14792 { 14793 return (uint32_t *) (R + 1); 14794 } 14795 14796 14797 /***************************************************************************** 14798 ** 14799 ** int xcb_glx_gen_queries_arb_data_length 14800 ** 14801 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14802 ** @returns int 14803 ** 14804 *****************************************************************************/ 14805 14806 int 14807 xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14808 { 14809 return R->length; 14810 } 14811 14812 14813 /***************************************************************************** 14814 ** 14815 ** xcb_generic_iterator_t xcb_glx_gen_queries_arb_data_end 14816 ** 14817 ** @param const xcb_glx_gen_queries_arb_reply_t *R 14818 ** @returns xcb_generic_iterator_t 14819 ** 14820 *****************************************************************************/ 14821 14822 xcb_generic_iterator_t 14823 xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< */) 14824 { 14825 xcb_generic_iterator_t i; 14826 i.data = ((uint32_t *) (R + 1)) + (R->length); 14827 i.rem = 0; 14828 i.index = (char *) i.data - (char *) R; 14829 return i; 14830 } 14831 14832 14833 /***************************************************************************** 14834 ** 14835 ** xcb_glx_gen_queries_arb_reply_t * xcb_glx_gen_queries_arb_reply 14836 ** 14837 ** @param xcb_connection_t *c 14838 ** @param xcb_glx_gen_queries_arb_cookie_t cookie 14839 ** @param xcb_generic_error_t **e 14840 ** @returns xcb_glx_gen_queries_arb_reply_t * 14841 ** 14842 *****************************************************************************/ 14843 14844 xcb_glx_gen_queries_arb_reply_t * 14845 xcb_glx_gen_queries_arb_reply (xcb_connection_t *c /**< */, 14846 xcb_glx_gen_queries_arb_cookie_t cookie /**< */, 14847 xcb_generic_error_t **e /**< */) 14848 { 14849 return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14850 } 14851 14852 14853 /***************************************************************************** 14854 ** 14855 ** xcb_glx_is_query_arb_cookie_t xcb_glx_is_query_arb 14856 ** 14857 ** @param xcb_connection_t *c 14858 ** @param xcb_glx_context_tag_t context_tag 14859 ** @param uint32_t id 14860 ** @returns xcb_glx_is_query_arb_cookie_t 14861 ** 14862 *****************************************************************************/ 14863 14864 xcb_glx_is_query_arb_cookie_t 14865 xcb_glx_is_query_arb (xcb_connection_t *c /**< */, 14866 xcb_glx_context_tag_t context_tag /**< */, 14867 uint32_t id /**< */) 14868 { 14869 static const xcb_protocol_request_t xcb_req = { 14870 /* count */ 2, 14871 /* ext */ &xcb_glx_id, 14872 /* opcode */ XCB_GLX_IS_QUERY_ARB, 14873 /* isvoid */ 0 14874 }; 14875 14876 struct iovec xcb_parts[4]; 14877 xcb_glx_is_query_arb_cookie_t xcb_ret; 14878 xcb_glx_is_query_arb_request_t xcb_out; 14879 14880 xcb_out.context_tag = context_tag; 14881 xcb_out.id = id; 14882 14883 xcb_parts[2].iov_base = (char *) &xcb_out; 14884 xcb_parts[2].iov_len = sizeof(xcb_out); 14885 xcb_parts[3].iov_base = 0; 14886 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14887 14888 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14889 return xcb_ret; 14890 } 14891 14892 14893 /***************************************************************************** 14894 ** 14895 ** xcb_glx_is_query_arb_cookie_t xcb_glx_is_query_arb_unchecked 14896 ** 14897 ** @param xcb_connection_t *c 14898 ** @param xcb_glx_context_tag_t context_tag 14899 ** @param uint32_t id 14900 ** @returns xcb_glx_is_query_arb_cookie_t 14901 ** 14902 *****************************************************************************/ 14903 14904 xcb_glx_is_query_arb_cookie_t 14905 xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, 14906 xcb_glx_context_tag_t context_tag /**< */, 14907 uint32_t id /**< */) 14908 { 14909 static const xcb_protocol_request_t xcb_req = { 14910 /* count */ 2, 14911 /* ext */ &xcb_glx_id, 14912 /* opcode */ XCB_GLX_IS_QUERY_ARB, 14913 /* isvoid */ 0 14914 }; 14915 14916 struct iovec xcb_parts[4]; 14917 xcb_glx_is_query_arb_cookie_t xcb_ret; 14918 xcb_glx_is_query_arb_request_t xcb_out; 14919 14920 xcb_out.context_tag = context_tag; 14921 xcb_out.id = id; 14922 14923 xcb_parts[2].iov_base = (char *) &xcb_out; 14924 xcb_parts[2].iov_len = sizeof(xcb_out); 14925 xcb_parts[3].iov_base = 0; 14926 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14927 14928 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14929 return xcb_ret; 14930 } 14931 14932 14933 /***************************************************************************** 14934 ** 14935 ** xcb_glx_is_query_arb_reply_t * xcb_glx_is_query_arb_reply 14936 ** 14937 ** @param xcb_connection_t *c 14938 ** @param xcb_glx_is_query_arb_cookie_t cookie 14939 ** @param xcb_generic_error_t **e 14940 ** @returns xcb_glx_is_query_arb_reply_t * 14941 ** 14942 *****************************************************************************/ 14943 14944 xcb_glx_is_query_arb_reply_t * 14945 xcb_glx_is_query_arb_reply (xcb_connection_t *c /**< */, 14946 xcb_glx_is_query_arb_cookie_t cookie /**< */, 14947 xcb_generic_error_t **e /**< */) 14948 { 14949 return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14950 } 14951 14952 int 14953 xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */) 14954 { 14955 char *xcb_tmp = (char *)_buffer; 14956 const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer; 14957 unsigned int xcb_buffer_len = 0; 14958 unsigned int xcb_block_len = 0; 14959 unsigned int xcb_pad = 0; 14960 unsigned int xcb_align_to = 0; 14961 14962 14963 xcb_block_len += sizeof(xcb_glx_get_queryiv_arb_reply_t); 14964 xcb_tmp += xcb_block_len; 14965 xcb_buffer_len += xcb_block_len; 14966 xcb_block_len = 0; 14967 /* data */ 14968 xcb_block_len += _aux->n * sizeof(int32_t); 14969 xcb_tmp += xcb_block_len; 14970 xcb_align_to = ALIGNOF(int32_t); 14971 /* insert padding */ 14972 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14973 xcb_buffer_len += xcb_block_len + xcb_pad; 14974 if (0 != xcb_pad) { 14975 xcb_tmp += xcb_pad; 14976 xcb_pad = 0; 14977 } 14978 xcb_block_len = 0; 14979 14980 return xcb_buffer_len; 14981 } 14982 14983 14984 /***************************************************************************** 14985 ** 14986 ** xcb_glx_get_queryiv_arb_cookie_t xcb_glx_get_queryiv_arb 14987 ** 14988 ** @param xcb_connection_t *c 14989 ** @param xcb_glx_context_tag_t context_tag 14990 ** @param uint32_t target 14991 ** @param uint32_t pname 14992 ** @returns xcb_glx_get_queryiv_arb_cookie_t 14993 ** 14994 *****************************************************************************/ 14995 14996 xcb_glx_get_queryiv_arb_cookie_t 14997 xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, 14998 xcb_glx_context_tag_t context_tag /**< */, 14999 uint32_t target /**< */, 15000 uint32_t pname /**< */) 15001 { 15002 static const xcb_protocol_request_t xcb_req = { 15003 /* count */ 2, 15004 /* ext */ &xcb_glx_id, 15005 /* opcode */ XCB_GLX_GET_QUERYIV_ARB, 15006 /* isvoid */ 0 15007 }; 15008 15009 struct iovec xcb_parts[4]; 15010 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 15011 xcb_glx_get_queryiv_arb_request_t xcb_out; 15012 15013 xcb_out.context_tag = context_tag; 15014 xcb_out.target = target; 15015 xcb_out.pname = pname; 15016 15017 xcb_parts[2].iov_base = (char *) &xcb_out; 15018 xcb_parts[2].iov_len = sizeof(xcb_out); 15019 xcb_parts[3].iov_base = 0; 15020 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15021 15022 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15023 return xcb_ret; 15024 } 15025 15026 15027 /***************************************************************************** 15028 ** 15029 ** xcb_glx_get_queryiv_arb_cookie_t xcb_glx_get_queryiv_arb_unchecked 15030 ** 15031 ** @param xcb_connection_t *c 15032 ** @param xcb_glx_context_tag_t context_tag 15033 ** @param uint32_t target 15034 ** @param uint32_t pname 15035 ** @returns xcb_glx_get_queryiv_arb_cookie_t 15036 ** 15037 *****************************************************************************/ 15038 15039 xcb_glx_get_queryiv_arb_cookie_t 15040 xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c /**< */, 15041 xcb_glx_context_tag_t context_tag /**< */, 15042 uint32_t target /**< */, 15043 uint32_t pname /**< */) 15044 { 15045 static const xcb_protocol_request_t xcb_req = { 15046 /* count */ 2, 15047 /* ext */ &xcb_glx_id, 15048 /* opcode */ XCB_GLX_GET_QUERYIV_ARB, 15049 /* isvoid */ 0 15050 }; 15051 15052 struct iovec xcb_parts[4]; 15053 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 15054 xcb_glx_get_queryiv_arb_request_t xcb_out; 15055 15056 xcb_out.context_tag = context_tag; 15057 xcb_out.target = target; 15058 xcb_out.pname = pname; 15059 15060 xcb_parts[2].iov_base = (char *) &xcb_out; 15061 xcb_parts[2].iov_len = sizeof(xcb_out); 15062 xcb_parts[3].iov_base = 0; 15063 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15064 15065 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15066 return xcb_ret; 15067 } 15068 15069 15070 /***************************************************************************** 15071 ** 15072 ** int32_t * xcb_glx_get_queryiv_arb_data 15073 ** 15074 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 15075 ** @returns int32_t * 15076 ** 15077 *****************************************************************************/ 15078 15079 int32_t * 15080 xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 15081 { 15082 return (int32_t *) (R + 1); 15083 } 15084 15085 15086 /***************************************************************************** 15087 ** 15088 ** int xcb_glx_get_queryiv_arb_data_length 15089 ** 15090 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 15091 ** @returns int 15092 ** 15093 *****************************************************************************/ 15094 15095 int 15096 xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 15097 { 15098 return R->n; 15099 } 15100 15101 15102 /***************************************************************************** 15103 ** 15104 ** xcb_generic_iterator_t xcb_glx_get_queryiv_arb_data_end 15105 ** 15106 ** @param const xcb_glx_get_queryiv_arb_reply_t *R 15107 ** @returns xcb_generic_iterator_t 15108 ** 15109 *****************************************************************************/ 15110 15111 xcb_generic_iterator_t 15112 xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) 15113 { 15114 xcb_generic_iterator_t i; 15115 i.data = ((int32_t *) (R + 1)) + (R->n); 15116 i.rem = 0; 15117 i.index = (char *) i.data - (char *) R; 15118 return i; 15119 } 15120 15121 15122 /***************************************************************************** 15123 ** 15124 ** xcb_glx_get_queryiv_arb_reply_t * xcb_glx_get_queryiv_arb_reply 15125 ** 15126 ** @param xcb_connection_t *c 15127 ** @param xcb_glx_get_queryiv_arb_cookie_t cookie 15128 ** @param xcb_generic_error_t **e 15129 ** @returns xcb_glx_get_queryiv_arb_reply_t * 15130 ** 15131 *****************************************************************************/ 15132 15133 xcb_glx_get_queryiv_arb_reply_t * 15134 xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c /**< */, 15135 xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, 15136 xcb_generic_error_t **e /**< */) 15137 { 15138 return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15139 } 15140 15141 int 15142 xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */) 15143 { 15144 char *xcb_tmp = (char *)_buffer; 15145 const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer; 15146 unsigned int xcb_buffer_len = 0; 15147 unsigned int xcb_block_len = 0; 15148 unsigned int xcb_pad = 0; 15149 unsigned int xcb_align_to = 0; 15150 15151 15152 xcb_block_len += sizeof(xcb_glx_get_query_objectiv_arb_reply_t); 15153 xcb_tmp += xcb_block_len; 15154 xcb_buffer_len += xcb_block_len; 15155 xcb_block_len = 0; 15156 /* data */ 15157 xcb_block_len += _aux->n * sizeof(int32_t); 15158 xcb_tmp += xcb_block_len; 15159 xcb_align_to = ALIGNOF(int32_t); 15160 /* insert padding */ 15161 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15162 xcb_buffer_len += xcb_block_len + xcb_pad; 15163 if (0 != xcb_pad) { 15164 xcb_tmp += xcb_pad; 15165 xcb_pad = 0; 15166 } 15167 xcb_block_len = 0; 15168 15169 return xcb_buffer_len; 15170 } 15171 15172 15173 /***************************************************************************** 15174 ** 15175 ** xcb_glx_get_query_objectiv_arb_cookie_t xcb_glx_get_query_objectiv_arb 15176 ** 15177 ** @param xcb_connection_t *c 15178 ** @param xcb_glx_context_tag_t context_tag 15179 ** @param uint32_t id 15180 ** @param uint32_t pname 15181 ** @returns xcb_glx_get_query_objectiv_arb_cookie_t 15182 ** 15183 *****************************************************************************/ 15184 15185 xcb_glx_get_query_objectiv_arb_cookie_t 15186 xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, 15187 xcb_glx_context_tag_t context_tag /**< */, 15188 uint32_t id /**< */, 15189 uint32_t pname /**< */) 15190 { 15191 static const xcb_protocol_request_t xcb_req = { 15192 /* count */ 2, 15193 /* ext */ &xcb_glx_id, 15194 /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, 15195 /* isvoid */ 0 15196 }; 15197 15198 struct iovec xcb_parts[4]; 15199 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 15200 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 15201 15202 xcb_out.context_tag = context_tag; 15203 xcb_out.id = id; 15204 xcb_out.pname = pname; 15205 15206 xcb_parts[2].iov_base = (char *) &xcb_out; 15207 xcb_parts[2].iov_len = sizeof(xcb_out); 15208 xcb_parts[3].iov_base = 0; 15209 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15210 15211 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15212 return xcb_ret; 15213 } 15214 15215 15216 /***************************************************************************** 15217 ** 15218 ** xcb_glx_get_query_objectiv_arb_cookie_t xcb_glx_get_query_objectiv_arb_unchecked 15219 ** 15220 ** @param xcb_connection_t *c 15221 ** @param xcb_glx_context_tag_t context_tag 15222 ** @param uint32_t id 15223 ** @param uint32_t pname 15224 ** @returns xcb_glx_get_query_objectiv_arb_cookie_t 15225 ** 15226 *****************************************************************************/ 15227 15228 xcb_glx_get_query_objectiv_arb_cookie_t 15229 xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c /**< */, 15230 xcb_glx_context_tag_t context_tag /**< */, 15231 uint32_t id /**< */, 15232 uint32_t pname /**< */) 15233 { 15234 static const xcb_protocol_request_t xcb_req = { 15235 /* count */ 2, 15236 /* ext */ &xcb_glx_id, 15237 /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, 15238 /* isvoid */ 0 15239 }; 15240 15241 struct iovec xcb_parts[4]; 15242 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 15243 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 15244 15245 xcb_out.context_tag = context_tag; 15246 xcb_out.id = id; 15247 xcb_out.pname = pname; 15248 15249 xcb_parts[2].iov_base = (char *) &xcb_out; 15250 xcb_parts[2].iov_len = sizeof(xcb_out); 15251 xcb_parts[3].iov_base = 0; 15252 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15253 15254 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15255 return xcb_ret; 15256 } 15257 15258 15259 /***************************************************************************** 15260 ** 15261 ** int32_t * xcb_glx_get_query_objectiv_arb_data 15262 ** 15263 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15264 ** @returns int32_t * 15265 ** 15266 *****************************************************************************/ 15267 15268 int32_t * 15269 xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15270 { 15271 return (int32_t *) (R + 1); 15272 } 15273 15274 15275 /***************************************************************************** 15276 ** 15277 ** int xcb_glx_get_query_objectiv_arb_data_length 15278 ** 15279 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15280 ** @returns int 15281 ** 15282 *****************************************************************************/ 15283 15284 int 15285 xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15286 { 15287 return R->n; 15288 } 15289 15290 15291 /***************************************************************************** 15292 ** 15293 ** xcb_generic_iterator_t xcb_glx_get_query_objectiv_arb_data_end 15294 ** 15295 ** @param const xcb_glx_get_query_objectiv_arb_reply_t *R 15296 ** @returns xcb_generic_iterator_t 15297 ** 15298 *****************************************************************************/ 15299 15300 xcb_generic_iterator_t 15301 xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) 15302 { 15303 xcb_generic_iterator_t i; 15304 i.data = ((int32_t *) (R + 1)) + (R->n); 15305 i.rem = 0; 15306 i.index = (char *) i.data - (char *) R; 15307 return i; 15308 } 15309 15310 15311 /***************************************************************************** 15312 ** 15313 ** xcb_glx_get_query_objectiv_arb_reply_t * xcb_glx_get_query_objectiv_arb_reply 15314 ** 15315 ** @param xcb_connection_t *c 15316 ** @param xcb_glx_get_query_objectiv_arb_cookie_t cookie 15317 ** @param xcb_generic_error_t **e 15318 ** @returns xcb_glx_get_query_objectiv_arb_reply_t * 15319 ** 15320 *****************************************************************************/ 15321 15322 xcb_glx_get_query_objectiv_arb_reply_t * 15323 xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c /**< */, 15324 xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, 15325 xcb_generic_error_t **e /**< */) 15326 { 15327 return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15328 } 15329 15330 int 15331 xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */) 15332 { 15333 char *xcb_tmp = (char *)_buffer; 15334 const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer; 15335 unsigned int xcb_buffer_len = 0; 15336 unsigned int xcb_block_len = 0; 15337 unsigned int xcb_pad = 0; 15338 unsigned int xcb_align_to = 0; 15339 15340 15341 xcb_block_len += sizeof(xcb_glx_get_query_objectuiv_arb_reply_t); 15342 xcb_tmp += xcb_block_len; 15343 xcb_buffer_len += xcb_block_len; 15344 xcb_block_len = 0; 15345 /* data */ 15346 xcb_block_len += _aux->n * sizeof(uint32_t); 15347 xcb_tmp += xcb_block_len; 15348 xcb_align_to = ALIGNOF(uint32_t); 15349 /* insert padding */ 15350 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15351 xcb_buffer_len += xcb_block_len + xcb_pad; 15352 if (0 != xcb_pad) { 15353 xcb_tmp += xcb_pad; 15354 xcb_pad = 0; 15355 } 15356 xcb_block_len = 0; 15357 15358 return xcb_buffer_len; 15359 } 15360 15361 15362 /***************************************************************************** 15363 ** 15364 ** xcb_glx_get_query_objectuiv_arb_cookie_t xcb_glx_get_query_objectuiv_arb 15365 ** 15366 ** @param xcb_connection_t *c 15367 ** @param xcb_glx_context_tag_t context_tag 15368 ** @param uint32_t id 15369 ** @param uint32_t pname 15370 ** @returns xcb_glx_get_query_objectuiv_arb_cookie_t 15371 ** 15372 *****************************************************************************/ 15373 15374 xcb_glx_get_query_objectuiv_arb_cookie_t 15375 xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, 15376 xcb_glx_context_tag_t context_tag /**< */, 15377 uint32_t id /**< */, 15378 uint32_t pname /**< */) 15379 { 15380 static const xcb_protocol_request_t xcb_req = { 15381 /* count */ 2, 15382 /* ext */ &xcb_glx_id, 15383 /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 15384 /* isvoid */ 0 15385 }; 15386 15387 struct iovec xcb_parts[4]; 15388 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 15389 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 15390 15391 xcb_out.context_tag = context_tag; 15392 xcb_out.id = id; 15393 xcb_out.pname = pname; 15394 15395 xcb_parts[2].iov_base = (char *) &xcb_out; 15396 xcb_parts[2].iov_len = sizeof(xcb_out); 15397 xcb_parts[3].iov_base = 0; 15398 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15399 15400 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15401 return xcb_ret; 15402 } 15403 15404 15405 /***************************************************************************** 15406 ** 15407 ** xcb_glx_get_query_objectuiv_arb_cookie_t xcb_glx_get_query_objectuiv_arb_unchecked 15408 ** 15409 ** @param xcb_connection_t *c 15410 ** @param xcb_glx_context_tag_t context_tag 15411 ** @param uint32_t id 15412 ** @param uint32_t pname 15413 ** @returns xcb_glx_get_query_objectuiv_arb_cookie_t 15414 ** 15415 *****************************************************************************/ 15416 15417 xcb_glx_get_query_objectuiv_arb_cookie_t 15418 xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c /**< */, 15419 xcb_glx_context_tag_t context_tag /**< */, 15420 uint32_t id /**< */, 15421 uint32_t pname /**< */) 15422 { 15423 static const xcb_protocol_request_t xcb_req = { 15424 /* count */ 2, 15425 /* ext */ &xcb_glx_id, 15426 /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 15427 /* isvoid */ 0 15428 }; 15429 15430 struct iovec xcb_parts[4]; 15431 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 15432 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 15433 15434 xcb_out.context_tag = context_tag; 15435 xcb_out.id = id; 15436 xcb_out.pname = pname; 15437 15438 xcb_parts[2].iov_base = (char *) &xcb_out; 15439 xcb_parts[2].iov_len = sizeof(xcb_out); 15440 xcb_parts[3].iov_base = 0; 15441 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15442 15443 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15444 return xcb_ret; 15445 } 15446 15447 15448 /***************************************************************************** 15449 ** 15450 ** uint32_t * xcb_glx_get_query_objectuiv_arb_data 15451 ** 15452 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15453 ** @returns uint32_t * 15454 ** 15455 *****************************************************************************/ 15456 15457 uint32_t * 15458 xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15459 { 15460 return (uint32_t *) (R + 1); 15461 } 15462 15463 15464 /***************************************************************************** 15465 ** 15466 ** int xcb_glx_get_query_objectuiv_arb_data_length 15467 ** 15468 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15469 ** @returns int 15470 ** 15471 *****************************************************************************/ 15472 15473 int 15474 xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15475 { 15476 return R->n; 15477 } 15478 15479 15480 /***************************************************************************** 15481 ** 15482 ** xcb_generic_iterator_t xcb_glx_get_query_objectuiv_arb_data_end 15483 ** 15484 ** @param const xcb_glx_get_query_objectuiv_arb_reply_t *R 15485 ** @returns xcb_generic_iterator_t 15486 ** 15487 *****************************************************************************/ 15488 15489 xcb_generic_iterator_t 15490 xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) 15491 { 15492 xcb_generic_iterator_t i; 15493 i.data = ((uint32_t *) (R + 1)) + (R->n); 15494 i.rem = 0; 15495 i.index = (char *) i.data - (char *) R; 15496 return i; 15497 } 15498 15499 15500 /***************************************************************************** 15501 ** 15502 ** xcb_glx_get_query_objectuiv_arb_reply_t * xcb_glx_get_query_objectuiv_arb_reply 15503 ** 15504 ** @param xcb_connection_t *c 15505 ** @param xcb_glx_get_query_objectuiv_arb_cookie_t cookie 15506 ** @param xcb_generic_error_t **e 15507 ** @returns xcb_glx_get_query_objectuiv_arb_reply_t * 15508 ** 15509 *****************************************************************************/ 15510 15511 xcb_glx_get_query_objectuiv_arb_reply_t * 15512 xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c /**< */, 15513 xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, 15514 xcb_generic_error_t **e /**< */) 15515 { 15516 return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15517 } 15518 15519