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 19xcb_extension_t xcb_glx_id = { "GLX", 0 }; 20 21void 22xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i) 23{ 24 --i->rem; 25 ++i->data; 26 i->index += sizeof(xcb_glx_pixmap_t); 27} 28 29xcb_generic_iterator_t 30xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i) 31{ 32 xcb_generic_iterator_t ret; 33 ret.data = i.data + i.rem; 34 ret.index = i.index + ((char *) ret.data - (char *) i.data); 35 ret.rem = 0; 36 return ret; 37} 38 39void 40xcb_glx_context_next (xcb_glx_context_iterator_t *i) 41{ 42 --i->rem; 43 ++i->data; 44 i->index += sizeof(xcb_glx_context_t); 45} 46 47xcb_generic_iterator_t 48xcb_glx_context_end (xcb_glx_context_iterator_t i) 49{ 50 xcb_generic_iterator_t ret; 51 ret.data = i.data + i.rem; 52 ret.index = i.index + ((char *) ret.data - (char *) i.data); 53 ret.rem = 0; 54 return ret; 55} 56 57void 58xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i) 59{ 60 --i->rem; 61 ++i->data; 62 i->index += sizeof(xcb_glx_pbuffer_t); 63} 64 65xcb_generic_iterator_t 66xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i) 67{ 68 xcb_generic_iterator_t ret; 69 ret.data = i.data + i.rem; 70 ret.index = i.index + ((char *) ret.data - (char *) i.data); 71 ret.rem = 0; 72 return ret; 73} 74 75void 76xcb_glx_window_next (xcb_glx_window_iterator_t *i) 77{ 78 --i->rem; 79 ++i->data; 80 i->index += sizeof(xcb_glx_window_t); 81} 82 83xcb_generic_iterator_t 84xcb_glx_window_end (xcb_glx_window_iterator_t i) 85{ 86 xcb_generic_iterator_t ret; 87 ret.data = i.data + i.rem; 88 ret.index = i.index + ((char *) ret.data - (char *) i.data); 89 ret.rem = 0; 90 return ret; 91} 92 93void 94xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i) 95{ 96 --i->rem; 97 ++i->data; 98 i->index += sizeof(xcb_glx_fbconfig_t); 99} 100 101xcb_generic_iterator_t 102xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i) 103{ 104 xcb_generic_iterator_t ret; 105 ret.data = i.data + i.rem; 106 ret.index = i.index + ((char *) ret.data - (char *) i.data); 107 ret.rem = 0; 108 return ret; 109} 110 111void 112xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i) 113{ 114 --i->rem; 115 ++i->data; 116 i->index += sizeof(xcb_glx_drawable_t); 117} 118 119xcb_generic_iterator_t 120xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i) 121{ 122 xcb_generic_iterator_t ret; 123 ret.data = i.data + i.rem; 124 ret.index = i.index + ((char *) ret.data - (char *) i.data); 125 ret.rem = 0; 126 return ret; 127} 128 129void 130xcb_glx_float32_next (xcb_glx_float32_iterator_t *i) 131{ 132 --i->rem; 133 ++i->data; 134 i->index += sizeof(xcb_glx_float32_t); 135} 136 137xcb_generic_iterator_t 138xcb_glx_float32_end (xcb_glx_float32_iterator_t i) 139{ 140 xcb_generic_iterator_t ret; 141 ret.data = i.data + i.rem; 142 ret.index = i.index + ((char *) ret.data - (char *) i.data); 143 ret.rem = 0; 144 return ret; 145} 146 147void 148xcb_glx_float64_next (xcb_glx_float64_iterator_t *i) 149{ 150 --i->rem; 151 ++i->data; 152 i->index += sizeof(xcb_glx_float64_t); 153} 154 155xcb_generic_iterator_t 156xcb_glx_float64_end (xcb_glx_float64_iterator_t i) 157{ 158 xcb_generic_iterator_t ret; 159 ret.data = i.data + i.rem; 160 ret.index = i.index + ((char *) ret.data - (char *) i.data); 161 ret.rem = 0; 162 return ret; 163} 164 165void 166xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i) 167{ 168 --i->rem; 169 ++i->data; 170 i->index += sizeof(xcb_glx_bool32_t); 171} 172 173xcb_generic_iterator_t 174xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i) 175{ 176 xcb_generic_iterator_t ret; 177 ret.data = i.data + i.rem; 178 ret.index = i.index + ((char *) ret.data - (char *) i.data); 179 ret.rem = 0; 180 return ret; 181} 182 183void 184xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i) 185{ 186 --i->rem; 187 ++i->data; 188 i->index += sizeof(xcb_glx_context_tag_t); 189} 190 191xcb_generic_iterator_t 192xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i) 193{ 194 xcb_generic_iterator_t ret; 195 ret.data = i.data + i.rem; 196 ret.index = i.index + ((char *) ret.data - (char *) i.data); 197 ret.rem = 0; 198 return ret; 199} 200 201int 202xcb_glx_render_sizeof (const void *_buffer, 203 uint32_t data_len) 204{ 205 char *xcb_tmp = (char *)_buffer; 206 unsigned int xcb_buffer_len = 0; 207 unsigned int xcb_block_len = 0; 208 unsigned int xcb_pad = 0; 209 unsigned int xcb_align_to = 0; 210 211 212 xcb_block_len += sizeof(xcb_glx_render_request_t); 213 xcb_tmp += xcb_block_len; 214 xcb_buffer_len += xcb_block_len; 215 xcb_block_len = 0; 216 /* data */ 217 xcb_block_len += data_len * sizeof(uint8_t); 218 xcb_tmp += xcb_block_len; 219 xcb_align_to = ALIGNOF(uint8_t); 220 /* insert padding */ 221 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 222 xcb_buffer_len += xcb_block_len + xcb_pad; 223 if (0 != xcb_pad) { 224 xcb_tmp += xcb_pad; 225 xcb_pad = 0; 226 } 227 xcb_block_len = 0; 228 229 return xcb_buffer_len; 230} 231 232xcb_void_cookie_t 233xcb_glx_render_checked (xcb_connection_t *c, 234 xcb_glx_context_tag_t context_tag, 235 uint32_t data_len, 236 const uint8_t *data) 237{ 238 static const xcb_protocol_request_t xcb_req = { 239 .count = 4, 240 .ext = &xcb_glx_id, 241 .opcode = XCB_GLX_RENDER, 242 .isvoid = 1 243 }; 244 245 struct iovec xcb_parts[6]; 246 xcb_void_cookie_t xcb_ret; 247 xcb_glx_render_request_t xcb_out; 248 249 xcb_out.context_tag = context_tag; 250 251 xcb_parts[2].iov_base = (char *) &xcb_out; 252 xcb_parts[2].iov_len = sizeof(xcb_out); 253 xcb_parts[3].iov_base = 0; 254 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 255 /* uint8_t data */ 256 xcb_parts[4].iov_base = (char *) data; 257 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 258 xcb_parts[5].iov_base = 0; 259 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 260 261 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 262 return xcb_ret; 263} 264 265xcb_void_cookie_t 266xcb_glx_render (xcb_connection_t *c, 267 xcb_glx_context_tag_t context_tag, 268 uint32_t data_len, 269 const uint8_t *data) 270{ 271 static const xcb_protocol_request_t xcb_req = { 272 .count = 4, 273 .ext = &xcb_glx_id, 274 .opcode = XCB_GLX_RENDER, 275 .isvoid = 1 276 }; 277 278 struct iovec xcb_parts[6]; 279 xcb_void_cookie_t xcb_ret; 280 xcb_glx_render_request_t xcb_out; 281 282 xcb_out.context_tag = context_tag; 283 284 xcb_parts[2].iov_base = (char *) &xcb_out; 285 xcb_parts[2].iov_len = sizeof(xcb_out); 286 xcb_parts[3].iov_base = 0; 287 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 288 /* uint8_t data */ 289 xcb_parts[4].iov_base = (char *) data; 290 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 291 xcb_parts[5].iov_base = 0; 292 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 293 294 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 295 return xcb_ret; 296} 297 298uint8_t * 299xcb_glx_render_data (const xcb_glx_render_request_t *R) 300{ 301 return (uint8_t *) (R + 1); 302} 303 304int 305xcb_glx_render_data_length (const xcb_glx_render_request_t *R) 306{ 307 return (((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t)); 308} 309 310xcb_generic_iterator_t 311xcb_glx_render_data_end (const xcb_glx_render_request_t *R) 312{ 313 xcb_generic_iterator_t i; 314 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t))); 315 i.rem = 0; 316 i.index = (char *) i.data - (char *) R; 317 return i; 318} 319 320int 321xcb_glx_render_large_sizeof (const void *_buffer) 322{ 323 char *xcb_tmp = (char *)_buffer; 324 const xcb_glx_render_large_request_t *_aux = (xcb_glx_render_large_request_t *)_buffer; 325 unsigned int xcb_buffer_len = 0; 326 unsigned int xcb_block_len = 0; 327 unsigned int xcb_pad = 0; 328 unsigned int xcb_align_to = 0; 329 330 331 xcb_block_len += sizeof(xcb_glx_render_large_request_t); 332 xcb_tmp += xcb_block_len; 333 xcb_buffer_len += xcb_block_len; 334 xcb_block_len = 0; 335 /* data */ 336 xcb_block_len += _aux->data_len * sizeof(uint8_t); 337 xcb_tmp += xcb_block_len; 338 xcb_align_to = ALIGNOF(uint8_t); 339 /* insert padding */ 340 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 341 xcb_buffer_len += xcb_block_len + xcb_pad; 342 if (0 != xcb_pad) { 343 xcb_tmp += xcb_pad; 344 xcb_pad = 0; 345 } 346 xcb_block_len = 0; 347 348 return xcb_buffer_len; 349} 350 351xcb_void_cookie_t 352xcb_glx_render_large_checked (xcb_connection_t *c, 353 xcb_glx_context_tag_t context_tag, 354 uint16_t request_num, 355 uint16_t request_total, 356 uint32_t data_len, 357 const uint8_t *data) 358{ 359 static const xcb_protocol_request_t xcb_req = { 360 .count = 4, 361 .ext = &xcb_glx_id, 362 .opcode = XCB_GLX_RENDER_LARGE, 363 .isvoid = 1 364 }; 365 366 struct iovec xcb_parts[6]; 367 xcb_void_cookie_t xcb_ret; 368 xcb_glx_render_large_request_t xcb_out; 369 370 xcb_out.context_tag = context_tag; 371 xcb_out.request_num = request_num; 372 xcb_out.request_total = request_total; 373 xcb_out.data_len = data_len; 374 375 xcb_parts[2].iov_base = (char *) &xcb_out; 376 xcb_parts[2].iov_len = sizeof(xcb_out); 377 xcb_parts[3].iov_base = 0; 378 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 379 /* uint8_t data */ 380 xcb_parts[4].iov_base = (char *) data; 381 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 382 xcb_parts[5].iov_base = 0; 383 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 384 385 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 386 return xcb_ret; 387} 388 389xcb_void_cookie_t 390xcb_glx_render_large (xcb_connection_t *c, 391 xcb_glx_context_tag_t context_tag, 392 uint16_t request_num, 393 uint16_t request_total, 394 uint32_t data_len, 395 const uint8_t *data) 396{ 397 static const xcb_protocol_request_t xcb_req = { 398 .count = 4, 399 .ext = &xcb_glx_id, 400 .opcode = XCB_GLX_RENDER_LARGE, 401 .isvoid = 1 402 }; 403 404 struct iovec xcb_parts[6]; 405 xcb_void_cookie_t xcb_ret; 406 xcb_glx_render_large_request_t xcb_out; 407 408 xcb_out.context_tag = context_tag; 409 xcb_out.request_num = request_num; 410 xcb_out.request_total = request_total; 411 xcb_out.data_len = data_len; 412 413 xcb_parts[2].iov_base = (char *) &xcb_out; 414 xcb_parts[2].iov_len = sizeof(xcb_out); 415 xcb_parts[3].iov_base = 0; 416 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 417 /* uint8_t data */ 418 xcb_parts[4].iov_base = (char *) data; 419 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 420 xcb_parts[5].iov_base = 0; 421 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 422 423 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 424 return xcb_ret; 425} 426 427uint8_t * 428xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R) 429{ 430 return (uint8_t *) (R + 1); 431} 432 433int 434xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R) 435{ 436 return R->data_len; 437} 438 439xcb_generic_iterator_t 440xcb_glx_render_large_data_end (const xcb_glx_render_large_request_t *R) 441{ 442 xcb_generic_iterator_t i; 443 i.data = ((uint8_t *) (R + 1)) + (R->data_len); 444 i.rem = 0; 445 i.index = (char *) i.data - (char *) R; 446 return i; 447} 448 449xcb_void_cookie_t 450xcb_glx_create_context_checked (xcb_connection_t *c, 451 xcb_glx_context_t context, 452 xcb_visualid_t visual, 453 uint32_t screen, 454 xcb_glx_context_t share_list, 455 uint8_t is_direct) 456{ 457 static const xcb_protocol_request_t xcb_req = { 458 .count = 2, 459 .ext = &xcb_glx_id, 460 .opcode = XCB_GLX_CREATE_CONTEXT, 461 .isvoid = 1 462 }; 463 464 struct iovec xcb_parts[4]; 465 xcb_void_cookie_t xcb_ret; 466 xcb_glx_create_context_request_t xcb_out; 467 468 xcb_out.context = context; 469 xcb_out.visual = visual; 470 xcb_out.screen = screen; 471 xcb_out.share_list = share_list; 472 xcb_out.is_direct = is_direct; 473 memset(xcb_out.pad0, 0, 3); 474 475 xcb_parts[2].iov_base = (char *) &xcb_out; 476 xcb_parts[2].iov_len = sizeof(xcb_out); 477 xcb_parts[3].iov_base = 0; 478 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 479 480 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 481 return xcb_ret; 482} 483 484xcb_void_cookie_t 485xcb_glx_create_context (xcb_connection_t *c, 486 xcb_glx_context_t context, 487 xcb_visualid_t visual, 488 uint32_t screen, 489 xcb_glx_context_t share_list, 490 uint8_t is_direct) 491{ 492 static const xcb_protocol_request_t xcb_req = { 493 .count = 2, 494 .ext = &xcb_glx_id, 495 .opcode = XCB_GLX_CREATE_CONTEXT, 496 .isvoid = 1 497 }; 498 499 struct iovec xcb_parts[4]; 500 xcb_void_cookie_t xcb_ret; 501 xcb_glx_create_context_request_t xcb_out; 502 503 xcb_out.context = context; 504 xcb_out.visual = visual; 505 xcb_out.screen = screen; 506 xcb_out.share_list = share_list; 507 xcb_out.is_direct = is_direct; 508 memset(xcb_out.pad0, 0, 3); 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 515 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 516 return xcb_ret; 517} 518 519xcb_void_cookie_t 520xcb_glx_destroy_context_checked (xcb_connection_t *c, 521 xcb_glx_context_t context) 522{ 523 static const xcb_protocol_request_t xcb_req = { 524 .count = 2, 525 .ext = &xcb_glx_id, 526 .opcode = XCB_GLX_DESTROY_CONTEXT, 527 .isvoid = 1 528 }; 529 530 struct iovec xcb_parts[4]; 531 xcb_void_cookie_t xcb_ret; 532 xcb_glx_destroy_context_request_t xcb_out; 533 534 xcb_out.context = context; 535 536 xcb_parts[2].iov_base = (char *) &xcb_out; 537 xcb_parts[2].iov_len = sizeof(xcb_out); 538 xcb_parts[3].iov_base = 0; 539 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 540 541 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 542 return xcb_ret; 543} 544 545xcb_void_cookie_t 546xcb_glx_destroy_context (xcb_connection_t *c, 547 xcb_glx_context_t context) 548{ 549 static const xcb_protocol_request_t xcb_req = { 550 .count = 2, 551 .ext = &xcb_glx_id, 552 .opcode = XCB_GLX_DESTROY_CONTEXT, 553 .isvoid = 1 554 }; 555 556 struct iovec xcb_parts[4]; 557 xcb_void_cookie_t xcb_ret; 558 xcb_glx_destroy_context_request_t xcb_out; 559 560 xcb_out.context = context; 561 562 xcb_parts[2].iov_base = (char *) &xcb_out; 563 xcb_parts[2].iov_len = sizeof(xcb_out); 564 xcb_parts[3].iov_base = 0; 565 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 566 567 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 568 return xcb_ret; 569} 570 571xcb_glx_make_current_cookie_t 572xcb_glx_make_current (xcb_connection_t *c, 573 xcb_glx_drawable_t drawable, 574 xcb_glx_context_t context, 575 xcb_glx_context_tag_t old_context_tag) 576{ 577 static const xcb_protocol_request_t xcb_req = { 578 .count = 2, 579 .ext = &xcb_glx_id, 580 .opcode = XCB_GLX_MAKE_CURRENT, 581 .isvoid = 0 582 }; 583 584 struct iovec xcb_parts[4]; 585 xcb_glx_make_current_cookie_t xcb_ret; 586 xcb_glx_make_current_request_t xcb_out; 587 588 xcb_out.drawable = drawable; 589 xcb_out.context = context; 590 xcb_out.old_context_tag = old_context_tag; 591 592 xcb_parts[2].iov_base = (char *) &xcb_out; 593 xcb_parts[2].iov_len = sizeof(xcb_out); 594 xcb_parts[3].iov_base = 0; 595 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 596 597 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 598 return xcb_ret; 599} 600 601xcb_glx_make_current_cookie_t 602xcb_glx_make_current_unchecked (xcb_connection_t *c, 603 xcb_glx_drawable_t drawable, 604 xcb_glx_context_t context, 605 xcb_glx_context_tag_t old_context_tag) 606{ 607 static const xcb_protocol_request_t xcb_req = { 608 .count = 2, 609 .ext = &xcb_glx_id, 610 .opcode = XCB_GLX_MAKE_CURRENT, 611 .isvoid = 0 612 }; 613 614 struct iovec xcb_parts[4]; 615 xcb_glx_make_current_cookie_t xcb_ret; 616 xcb_glx_make_current_request_t xcb_out; 617 618 xcb_out.drawable = drawable; 619 xcb_out.context = context; 620 xcb_out.old_context_tag = old_context_tag; 621 622 xcb_parts[2].iov_base = (char *) &xcb_out; 623 xcb_parts[2].iov_len = sizeof(xcb_out); 624 xcb_parts[3].iov_base = 0; 625 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 626 627 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 628 return xcb_ret; 629} 630 631xcb_glx_make_current_reply_t * 632xcb_glx_make_current_reply (xcb_connection_t *c, 633 xcb_glx_make_current_cookie_t cookie /**< */, 634 xcb_generic_error_t **e) 635{ 636 return (xcb_glx_make_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 637} 638 639xcb_glx_is_direct_cookie_t 640xcb_glx_is_direct (xcb_connection_t *c, 641 xcb_glx_context_t context) 642{ 643 static const xcb_protocol_request_t xcb_req = { 644 .count = 2, 645 .ext = &xcb_glx_id, 646 .opcode = XCB_GLX_IS_DIRECT, 647 .isvoid = 0 648 }; 649 650 struct iovec xcb_parts[4]; 651 xcb_glx_is_direct_cookie_t xcb_ret; 652 xcb_glx_is_direct_request_t xcb_out; 653 654 xcb_out.context = context; 655 656 xcb_parts[2].iov_base = (char *) &xcb_out; 657 xcb_parts[2].iov_len = sizeof(xcb_out); 658 xcb_parts[3].iov_base = 0; 659 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 660 661 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 662 return xcb_ret; 663} 664 665xcb_glx_is_direct_cookie_t 666xcb_glx_is_direct_unchecked (xcb_connection_t *c, 667 xcb_glx_context_t context) 668{ 669 static const xcb_protocol_request_t xcb_req = { 670 .count = 2, 671 .ext = &xcb_glx_id, 672 .opcode = XCB_GLX_IS_DIRECT, 673 .isvoid = 0 674 }; 675 676 struct iovec xcb_parts[4]; 677 xcb_glx_is_direct_cookie_t xcb_ret; 678 xcb_glx_is_direct_request_t xcb_out; 679 680 xcb_out.context = context; 681 682 xcb_parts[2].iov_base = (char *) &xcb_out; 683 xcb_parts[2].iov_len = sizeof(xcb_out); 684 xcb_parts[3].iov_base = 0; 685 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 686 687 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 688 return xcb_ret; 689} 690 691xcb_glx_is_direct_reply_t * 692xcb_glx_is_direct_reply (xcb_connection_t *c, 693 xcb_glx_is_direct_cookie_t cookie /**< */, 694 xcb_generic_error_t **e) 695{ 696 return (xcb_glx_is_direct_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 697} 698 699xcb_glx_query_version_cookie_t 700xcb_glx_query_version (xcb_connection_t *c, 701 uint32_t major_version, 702 uint32_t minor_version) 703{ 704 static const xcb_protocol_request_t xcb_req = { 705 .count = 2, 706 .ext = &xcb_glx_id, 707 .opcode = XCB_GLX_QUERY_VERSION, 708 .isvoid = 0 709 }; 710 711 struct iovec xcb_parts[4]; 712 xcb_glx_query_version_cookie_t xcb_ret; 713 xcb_glx_query_version_request_t xcb_out; 714 715 xcb_out.major_version = major_version; 716 xcb_out.minor_version = minor_version; 717 718 xcb_parts[2].iov_base = (char *) &xcb_out; 719 xcb_parts[2].iov_len = sizeof(xcb_out); 720 xcb_parts[3].iov_base = 0; 721 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 722 723 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 724 return xcb_ret; 725} 726 727xcb_glx_query_version_cookie_t 728xcb_glx_query_version_unchecked (xcb_connection_t *c, 729 uint32_t major_version, 730 uint32_t minor_version) 731{ 732 static const xcb_protocol_request_t xcb_req = { 733 .count = 2, 734 .ext = &xcb_glx_id, 735 .opcode = XCB_GLX_QUERY_VERSION, 736 .isvoid = 0 737 }; 738 739 struct iovec xcb_parts[4]; 740 xcb_glx_query_version_cookie_t xcb_ret; 741 xcb_glx_query_version_request_t xcb_out; 742 743 xcb_out.major_version = major_version; 744 xcb_out.minor_version = minor_version; 745 746 xcb_parts[2].iov_base = (char *) &xcb_out; 747 xcb_parts[2].iov_len = sizeof(xcb_out); 748 xcb_parts[3].iov_base = 0; 749 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 750 751 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 752 return xcb_ret; 753} 754 755xcb_glx_query_version_reply_t * 756xcb_glx_query_version_reply (xcb_connection_t *c, 757 xcb_glx_query_version_cookie_t cookie /**< */, 758 xcb_generic_error_t **e) 759{ 760 return (xcb_glx_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 761} 762 763xcb_void_cookie_t 764xcb_glx_wait_gl_checked (xcb_connection_t *c, 765 xcb_glx_context_tag_t context_tag) 766{ 767 static const xcb_protocol_request_t xcb_req = { 768 .count = 2, 769 .ext = &xcb_glx_id, 770 .opcode = XCB_GLX_WAIT_GL, 771 .isvoid = 1 772 }; 773 774 struct iovec xcb_parts[4]; 775 xcb_void_cookie_t xcb_ret; 776 xcb_glx_wait_gl_request_t xcb_out; 777 778 xcb_out.context_tag = context_tag; 779 780 xcb_parts[2].iov_base = (char *) &xcb_out; 781 xcb_parts[2].iov_len = sizeof(xcb_out); 782 xcb_parts[3].iov_base = 0; 783 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 784 785 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 786 return xcb_ret; 787} 788 789xcb_void_cookie_t 790xcb_glx_wait_gl (xcb_connection_t *c, 791 xcb_glx_context_tag_t context_tag) 792{ 793 static const xcb_protocol_request_t xcb_req = { 794 .count = 2, 795 .ext = &xcb_glx_id, 796 .opcode = XCB_GLX_WAIT_GL, 797 .isvoid = 1 798 }; 799 800 struct iovec xcb_parts[4]; 801 xcb_void_cookie_t xcb_ret; 802 xcb_glx_wait_gl_request_t xcb_out; 803 804 xcb_out.context_tag = context_tag; 805 806 xcb_parts[2].iov_base = (char *) &xcb_out; 807 xcb_parts[2].iov_len = sizeof(xcb_out); 808 xcb_parts[3].iov_base = 0; 809 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 810 811 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 812 return xcb_ret; 813} 814 815xcb_void_cookie_t 816xcb_glx_wait_x_checked (xcb_connection_t *c, 817 xcb_glx_context_tag_t context_tag) 818{ 819 static const xcb_protocol_request_t xcb_req = { 820 .count = 2, 821 .ext = &xcb_glx_id, 822 .opcode = XCB_GLX_WAIT_X, 823 .isvoid = 1 824 }; 825 826 struct iovec xcb_parts[4]; 827 xcb_void_cookie_t xcb_ret; 828 xcb_glx_wait_x_request_t xcb_out; 829 830 xcb_out.context_tag = context_tag; 831 832 xcb_parts[2].iov_base = (char *) &xcb_out; 833 xcb_parts[2].iov_len = sizeof(xcb_out); 834 xcb_parts[3].iov_base = 0; 835 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 836 837 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 838 return xcb_ret; 839} 840 841xcb_void_cookie_t 842xcb_glx_wait_x (xcb_connection_t *c, 843 xcb_glx_context_tag_t context_tag) 844{ 845 static const xcb_protocol_request_t xcb_req = { 846 .count = 2, 847 .ext = &xcb_glx_id, 848 .opcode = XCB_GLX_WAIT_X, 849 .isvoid = 1 850 }; 851 852 struct iovec xcb_parts[4]; 853 xcb_void_cookie_t xcb_ret; 854 xcb_glx_wait_x_request_t xcb_out; 855 856 xcb_out.context_tag = context_tag; 857 858 xcb_parts[2].iov_base = (char *) &xcb_out; 859 xcb_parts[2].iov_len = sizeof(xcb_out); 860 xcb_parts[3].iov_base = 0; 861 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 862 863 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 864 return xcb_ret; 865} 866 867xcb_void_cookie_t 868xcb_glx_copy_context_checked (xcb_connection_t *c, 869 xcb_glx_context_t src, 870 xcb_glx_context_t dest, 871 uint32_t mask, 872 xcb_glx_context_tag_t src_context_tag) 873{ 874 static const xcb_protocol_request_t xcb_req = { 875 .count = 2, 876 .ext = &xcb_glx_id, 877 .opcode = XCB_GLX_COPY_CONTEXT, 878 .isvoid = 1 879 }; 880 881 struct iovec xcb_parts[4]; 882 xcb_void_cookie_t xcb_ret; 883 xcb_glx_copy_context_request_t xcb_out; 884 885 xcb_out.src = src; 886 xcb_out.dest = dest; 887 xcb_out.mask = mask; 888 xcb_out.src_context_tag = src_context_tag; 889 890 xcb_parts[2].iov_base = (char *) &xcb_out; 891 xcb_parts[2].iov_len = sizeof(xcb_out); 892 xcb_parts[3].iov_base = 0; 893 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 894 895 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 896 return xcb_ret; 897} 898 899xcb_void_cookie_t 900xcb_glx_copy_context (xcb_connection_t *c, 901 xcb_glx_context_t src, 902 xcb_glx_context_t dest, 903 uint32_t mask, 904 xcb_glx_context_tag_t src_context_tag) 905{ 906 static const xcb_protocol_request_t xcb_req = { 907 .count = 2, 908 .ext = &xcb_glx_id, 909 .opcode = XCB_GLX_COPY_CONTEXT, 910 .isvoid = 1 911 }; 912 913 struct iovec xcb_parts[4]; 914 xcb_void_cookie_t xcb_ret; 915 xcb_glx_copy_context_request_t xcb_out; 916 917 xcb_out.src = src; 918 xcb_out.dest = dest; 919 xcb_out.mask = mask; 920 xcb_out.src_context_tag = src_context_tag; 921 922 xcb_parts[2].iov_base = (char *) &xcb_out; 923 xcb_parts[2].iov_len = sizeof(xcb_out); 924 xcb_parts[3].iov_base = 0; 925 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 926 927 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 928 return xcb_ret; 929} 930 931xcb_void_cookie_t 932xcb_glx_swap_buffers_checked (xcb_connection_t *c, 933 xcb_glx_context_tag_t context_tag, 934 xcb_glx_drawable_t drawable) 935{ 936 static const xcb_protocol_request_t xcb_req = { 937 .count = 2, 938 .ext = &xcb_glx_id, 939 .opcode = XCB_GLX_SWAP_BUFFERS, 940 .isvoid = 1 941 }; 942 943 struct iovec xcb_parts[4]; 944 xcb_void_cookie_t xcb_ret; 945 xcb_glx_swap_buffers_request_t xcb_out; 946 947 xcb_out.context_tag = context_tag; 948 xcb_out.drawable = drawable; 949 950 xcb_parts[2].iov_base = (char *) &xcb_out; 951 xcb_parts[2].iov_len = sizeof(xcb_out); 952 xcb_parts[3].iov_base = 0; 953 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 954 955 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 956 return xcb_ret; 957} 958 959xcb_void_cookie_t 960xcb_glx_swap_buffers (xcb_connection_t *c, 961 xcb_glx_context_tag_t context_tag, 962 xcb_glx_drawable_t drawable) 963{ 964 static const xcb_protocol_request_t xcb_req = { 965 .count = 2, 966 .ext = &xcb_glx_id, 967 .opcode = XCB_GLX_SWAP_BUFFERS, 968 .isvoid = 1 969 }; 970 971 struct iovec xcb_parts[4]; 972 xcb_void_cookie_t xcb_ret; 973 xcb_glx_swap_buffers_request_t xcb_out; 974 975 xcb_out.context_tag = context_tag; 976 xcb_out.drawable = drawable; 977 978 xcb_parts[2].iov_base = (char *) &xcb_out; 979 xcb_parts[2].iov_len = sizeof(xcb_out); 980 xcb_parts[3].iov_base = 0; 981 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 982 983 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 984 return xcb_ret; 985} 986 987xcb_void_cookie_t 988xcb_glx_use_x_font_checked (xcb_connection_t *c, 989 xcb_glx_context_tag_t context_tag, 990 xcb_font_t font, 991 uint32_t first, 992 uint32_t count, 993 uint32_t list_base) 994{ 995 static const xcb_protocol_request_t xcb_req = { 996 .count = 2, 997 .ext = &xcb_glx_id, 998 .opcode = XCB_GLX_USE_X_FONT, 999 .isvoid = 1 1000 }; 1001 1002 struct iovec xcb_parts[4]; 1003 xcb_void_cookie_t xcb_ret; 1004 xcb_glx_use_x_font_request_t xcb_out; 1005 1006 xcb_out.context_tag = context_tag; 1007 xcb_out.font = font; 1008 xcb_out.first = first; 1009 xcb_out.count = count; 1010 xcb_out.list_base = list_base; 1011 1012 xcb_parts[2].iov_base = (char *) &xcb_out; 1013 xcb_parts[2].iov_len = sizeof(xcb_out); 1014 xcb_parts[3].iov_base = 0; 1015 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1016 1017 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1018 return xcb_ret; 1019} 1020 1021xcb_void_cookie_t 1022xcb_glx_use_x_font (xcb_connection_t *c, 1023 xcb_glx_context_tag_t context_tag, 1024 xcb_font_t font, 1025 uint32_t first, 1026 uint32_t count, 1027 uint32_t list_base) 1028{ 1029 static const xcb_protocol_request_t xcb_req = { 1030 .count = 2, 1031 .ext = &xcb_glx_id, 1032 .opcode = XCB_GLX_USE_X_FONT, 1033 .isvoid = 1 1034 }; 1035 1036 struct iovec xcb_parts[4]; 1037 xcb_void_cookie_t xcb_ret; 1038 xcb_glx_use_x_font_request_t xcb_out; 1039 1040 xcb_out.context_tag = context_tag; 1041 xcb_out.font = font; 1042 xcb_out.first = first; 1043 xcb_out.count = count; 1044 xcb_out.list_base = list_base; 1045 1046 xcb_parts[2].iov_base = (char *) &xcb_out; 1047 xcb_parts[2].iov_len = sizeof(xcb_out); 1048 xcb_parts[3].iov_base = 0; 1049 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1050 1051 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1052 return xcb_ret; 1053} 1054 1055xcb_void_cookie_t 1056xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c, 1057 uint32_t screen, 1058 xcb_visualid_t visual, 1059 xcb_pixmap_t pixmap, 1060 xcb_glx_pixmap_t glx_pixmap) 1061{ 1062 static const xcb_protocol_request_t xcb_req = { 1063 .count = 2, 1064 .ext = &xcb_glx_id, 1065 .opcode = XCB_GLX_CREATE_GLX_PIXMAP, 1066 .isvoid = 1 1067 }; 1068 1069 struct iovec xcb_parts[4]; 1070 xcb_void_cookie_t xcb_ret; 1071 xcb_glx_create_glx_pixmap_request_t xcb_out; 1072 1073 xcb_out.screen = screen; 1074 xcb_out.visual = visual; 1075 xcb_out.pixmap = pixmap; 1076 xcb_out.glx_pixmap = glx_pixmap; 1077 1078 xcb_parts[2].iov_base = (char *) &xcb_out; 1079 xcb_parts[2].iov_len = sizeof(xcb_out); 1080 xcb_parts[3].iov_base = 0; 1081 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1082 1083 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1084 return xcb_ret; 1085} 1086 1087xcb_void_cookie_t 1088xcb_glx_create_glx_pixmap (xcb_connection_t *c, 1089 uint32_t screen, 1090 xcb_visualid_t visual, 1091 xcb_pixmap_t pixmap, 1092 xcb_glx_pixmap_t glx_pixmap) 1093{ 1094 static const xcb_protocol_request_t xcb_req = { 1095 .count = 2, 1096 .ext = &xcb_glx_id, 1097 .opcode = XCB_GLX_CREATE_GLX_PIXMAP, 1098 .isvoid = 1 1099 }; 1100 1101 struct iovec xcb_parts[4]; 1102 xcb_void_cookie_t xcb_ret; 1103 xcb_glx_create_glx_pixmap_request_t xcb_out; 1104 1105 xcb_out.screen = screen; 1106 xcb_out.visual = visual; 1107 xcb_out.pixmap = pixmap; 1108 xcb_out.glx_pixmap = glx_pixmap; 1109 1110 xcb_parts[2].iov_base = (char *) &xcb_out; 1111 xcb_parts[2].iov_len = sizeof(xcb_out); 1112 xcb_parts[3].iov_base = 0; 1113 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1114 1115 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1116 return xcb_ret; 1117} 1118 1119int 1120xcb_glx_get_visual_configs_sizeof (const void *_buffer) 1121{ 1122 char *xcb_tmp = (char *)_buffer; 1123 const xcb_glx_get_visual_configs_reply_t *_aux = (xcb_glx_get_visual_configs_reply_t *)_buffer; 1124 unsigned int xcb_buffer_len = 0; 1125 unsigned int xcb_block_len = 0; 1126 unsigned int xcb_pad = 0; 1127 unsigned int xcb_align_to = 0; 1128 1129 1130 xcb_block_len += sizeof(xcb_glx_get_visual_configs_reply_t); 1131 xcb_tmp += xcb_block_len; 1132 xcb_buffer_len += xcb_block_len; 1133 xcb_block_len = 0; 1134 /* property_list */ 1135 xcb_block_len += _aux->length * sizeof(uint32_t); 1136 xcb_tmp += xcb_block_len; 1137 xcb_align_to = ALIGNOF(uint32_t); 1138 /* insert padding */ 1139 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1140 xcb_buffer_len += xcb_block_len + xcb_pad; 1141 if (0 != xcb_pad) { 1142 xcb_tmp += xcb_pad; 1143 xcb_pad = 0; 1144 } 1145 xcb_block_len = 0; 1146 1147 return xcb_buffer_len; 1148} 1149 1150xcb_glx_get_visual_configs_cookie_t 1151xcb_glx_get_visual_configs (xcb_connection_t *c, 1152 uint32_t screen) 1153{ 1154 static const xcb_protocol_request_t xcb_req = { 1155 .count = 2, 1156 .ext = &xcb_glx_id, 1157 .opcode = XCB_GLX_GET_VISUAL_CONFIGS, 1158 .isvoid = 0 1159 }; 1160 1161 struct iovec xcb_parts[4]; 1162 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1163 xcb_glx_get_visual_configs_request_t xcb_out; 1164 1165 xcb_out.screen = screen; 1166 1167 xcb_parts[2].iov_base = (char *) &xcb_out; 1168 xcb_parts[2].iov_len = sizeof(xcb_out); 1169 xcb_parts[3].iov_base = 0; 1170 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1171 1172 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1173 return xcb_ret; 1174} 1175 1176xcb_glx_get_visual_configs_cookie_t 1177xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c, 1178 uint32_t screen) 1179{ 1180 static const xcb_protocol_request_t xcb_req = { 1181 .count = 2, 1182 .ext = &xcb_glx_id, 1183 .opcode = XCB_GLX_GET_VISUAL_CONFIGS, 1184 .isvoid = 0 1185 }; 1186 1187 struct iovec xcb_parts[4]; 1188 xcb_glx_get_visual_configs_cookie_t xcb_ret; 1189 xcb_glx_get_visual_configs_request_t xcb_out; 1190 1191 xcb_out.screen = screen; 1192 1193 xcb_parts[2].iov_base = (char *) &xcb_out; 1194 xcb_parts[2].iov_len = sizeof(xcb_out); 1195 xcb_parts[3].iov_base = 0; 1196 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1197 1198 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1199 return xcb_ret; 1200} 1201 1202uint32_t * 1203xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R) 1204{ 1205 return (uint32_t *) (R + 1); 1206} 1207 1208int 1209xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R) 1210{ 1211 return R->length; 1212} 1213 1214xcb_generic_iterator_t 1215xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R) 1216{ 1217 xcb_generic_iterator_t i; 1218 i.data = ((uint32_t *) (R + 1)) + (R->length); 1219 i.rem = 0; 1220 i.index = (char *) i.data - (char *) R; 1221 return i; 1222} 1223 1224xcb_glx_get_visual_configs_reply_t * 1225xcb_glx_get_visual_configs_reply (xcb_connection_t *c, 1226 xcb_glx_get_visual_configs_cookie_t cookie /**< */, 1227 xcb_generic_error_t **e) 1228{ 1229 return (xcb_glx_get_visual_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1230} 1231 1232xcb_void_cookie_t 1233xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c, 1234 xcb_glx_pixmap_t glx_pixmap) 1235{ 1236 static const xcb_protocol_request_t xcb_req = { 1237 .count = 2, 1238 .ext = &xcb_glx_id, 1239 .opcode = XCB_GLX_DESTROY_GLX_PIXMAP, 1240 .isvoid = 1 1241 }; 1242 1243 struct iovec xcb_parts[4]; 1244 xcb_void_cookie_t xcb_ret; 1245 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1246 1247 xcb_out.glx_pixmap = glx_pixmap; 1248 1249 xcb_parts[2].iov_base = (char *) &xcb_out; 1250 xcb_parts[2].iov_len = sizeof(xcb_out); 1251 xcb_parts[3].iov_base = 0; 1252 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1253 1254 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1255 return xcb_ret; 1256} 1257 1258xcb_void_cookie_t 1259xcb_glx_destroy_glx_pixmap (xcb_connection_t *c, 1260 xcb_glx_pixmap_t glx_pixmap) 1261{ 1262 static const xcb_protocol_request_t xcb_req = { 1263 .count = 2, 1264 .ext = &xcb_glx_id, 1265 .opcode = XCB_GLX_DESTROY_GLX_PIXMAP, 1266 .isvoid = 1 1267 }; 1268 1269 struct iovec xcb_parts[4]; 1270 xcb_void_cookie_t xcb_ret; 1271 xcb_glx_destroy_glx_pixmap_request_t xcb_out; 1272 1273 xcb_out.glx_pixmap = glx_pixmap; 1274 1275 xcb_parts[2].iov_base = (char *) &xcb_out; 1276 xcb_parts[2].iov_len = sizeof(xcb_out); 1277 xcb_parts[3].iov_base = 0; 1278 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1279 1280 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1281 return xcb_ret; 1282} 1283 1284int 1285xcb_glx_vendor_private_sizeof (const void *_buffer, 1286 uint32_t data_len) 1287{ 1288 char *xcb_tmp = (char *)_buffer; 1289 unsigned int xcb_buffer_len = 0; 1290 unsigned int xcb_block_len = 0; 1291 unsigned int xcb_pad = 0; 1292 unsigned int xcb_align_to = 0; 1293 1294 1295 xcb_block_len += sizeof(xcb_glx_vendor_private_request_t); 1296 xcb_tmp += xcb_block_len; 1297 xcb_buffer_len += xcb_block_len; 1298 xcb_block_len = 0; 1299 /* data */ 1300 xcb_block_len += data_len * sizeof(uint8_t); 1301 xcb_tmp += xcb_block_len; 1302 xcb_align_to = ALIGNOF(uint8_t); 1303 /* insert padding */ 1304 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1305 xcb_buffer_len += xcb_block_len + xcb_pad; 1306 if (0 != xcb_pad) { 1307 xcb_tmp += xcb_pad; 1308 xcb_pad = 0; 1309 } 1310 xcb_block_len = 0; 1311 1312 return xcb_buffer_len; 1313} 1314 1315xcb_void_cookie_t 1316xcb_glx_vendor_private_checked (xcb_connection_t *c, 1317 uint32_t vendor_code, 1318 xcb_glx_context_tag_t context_tag, 1319 uint32_t data_len, 1320 const uint8_t *data) 1321{ 1322 static const xcb_protocol_request_t xcb_req = { 1323 .count = 4, 1324 .ext = &xcb_glx_id, 1325 .opcode = XCB_GLX_VENDOR_PRIVATE, 1326 .isvoid = 1 1327 }; 1328 1329 struct iovec xcb_parts[6]; 1330 xcb_void_cookie_t xcb_ret; 1331 xcb_glx_vendor_private_request_t xcb_out; 1332 1333 xcb_out.vendor_code = vendor_code; 1334 xcb_out.context_tag = context_tag; 1335 1336 xcb_parts[2].iov_base = (char *) &xcb_out; 1337 xcb_parts[2].iov_len = sizeof(xcb_out); 1338 xcb_parts[3].iov_base = 0; 1339 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1340 /* uint8_t data */ 1341 xcb_parts[4].iov_base = (char *) data; 1342 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1343 xcb_parts[5].iov_base = 0; 1344 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1345 1346 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1347 return xcb_ret; 1348} 1349 1350xcb_void_cookie_t 1351xcb_glx_vendor_private (xcb_connection_t *c, 1352 uint32_t vendor_code, 1353 xcb_glx_context_tag_t context_tag, 1354 uint32_t data_len, 1355 const uint8_t *data) 1356{ 1357 static const xcb_protocol_request_t xcb_req = { 1358 .count = 4, 1359 .ext = &xcb_glx_id, 1360 .opcode = XCB_GLX_VENDOR_PRIVATE, 1361 .isvoid = 1 1362 }; 1363 1364 struct iovec xcb_parts[6]; 1365 xcb_void_cookie_t xcb_ret; 1366 xcb_glx_vendor_private_request_t xcb_out; 1367 1368 xcb_out.vendor_code = vendor_code; 1369 xcb_out.context_tag = context_tag; 1370 1371 xcb_parts[2].iov_base = (char *) &xcb_out; 1372 xcb_parts[2].iov_len = sizeof(xcb_out); 1373 xcb_parts[3].iov_base = 0; 1374 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1375 /* uint8_t data */ 1376 xcb_parts[4].iov_base = (char *) data; 1377 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1378 xcb_parts[5].iov_base = 0; 1379 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1380 1381 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1382 return xcb_ret; 1383} 1384 1385uint8_t * 1386xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R) 1387{ 1388 return (uint8_t *) (R + 1); 1389} 1390 1391int 1392xcb_glx_vendor_private_data_length (const xcb_glx_vendor_private_request_t *R) 1393{ 1394 return (((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t)); 1395} 1396 1397xcb_generic_iterator_t 1398xcb_glx_vendor_private_data_end (const xcb_glx_vendor_private_request_t *R) 1399{ 1400 xcb_generic_iterator_t i; 1401 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t))); 1402 i.rem = 0; 1403 i.index = (char *) i.data - (char *) R; 1404 return i; 1405} 1406 1407int 1408xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer, 1409 uint32_t data_len) 1410{ 1411 char *xcb_tmp = (char *)_buffer; 1412 unsigned int xcb_buffer_len = 0; 1413 unsigned int xcb_block_len = 0; 1414 unsigned int xcb_pad = 0; 1415 unsigned int xcb_align_to = 0; 1416 1417 1418 xcb_block_len += sizeof(xcb_glx_vendor_private_with_reply_request_t); 1419 xcb_tmp += xcb_block_len; 1420 xcb_buffer_len += xcb_block_len; 1421 xcb_block_len = 0; 1422 /* data */ 1423 xcb_block_len += data_len * sizeof(uint8_t); 1424 xcb_tmp += xcb_block_len; 1425 xcb_align_to = ALIGNOF(uint8_t); 1426 /* insert padding */ 1427 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1428 xcb_buffer_len += xcb_block_len + xcb_pad; 1429 if (0 != xcb_pad) { 1430 xcb_tmp += xcb_pad; 1431 xcb_pad = 0; 1432 } 1433 xcb_block_len = 0; 1434 1435 return xcb_buffer_len; 1436} 1437 1438xcb_glx_vendor_private_with_reply_cookie_t 1439xcb_glx_vendor_private_with_reply (xcb_connection_t *c, 1440 uint32_t vendor_code, 1441 xcb_glx_context_tag_t context_tag, 1442 uint32_t data_len, 1443 const uint8_t *data) 1444{ 1445 static const xcb_protocol_request_t xcb_req = { 1446 .count = 4, 1447 .ext = &xcb_glx_id, 1448 .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 1449 .isvoid = 0 1450 }; 1451 1452 struct iovec xcb_parts[6]; 1453 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 1454 xcb_glx_vendor_private_with_reply_request_t xcb_out; 1455 1456 xcb_out.vendor_code = vendor_code; 1457 xcb_out.context_tag = context_tag; 1458 1459 xcb_parts[2].iov_base = (char *) &xcb_out; 1460 xcb_parts[2].iov_len = sizeof(xcb_out); 1461 xcb_parts[3].iov_base = 0; 1462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1463 /* uint8_t data */ 1464 xcb_parts[4].iov_base = (char *) data; 1465 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1466 xcb_parts[5].iov_base = 0; 1467 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1468 1469 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1470 return xcb_ret; 1471} 1472 1473xcb_glx_vendor_private_with_reply_cookie_t 1474xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c, 1475 uint32_t vendor_code, 1476 xcb_glx_context_tag_t context_tag, 1477 uint32_t data_len, 1478 const uint8_t *data) 1479{ 1480 static const xcb_protocol_request_t xcb_req = { 1481 .count = 4, 1482 .ext = &xcb_glx_id, 1483 .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, 1484 .isvoid = 0 1485 }; 1486 1487 struct iovec xcb_parts[6]; 1488 xcb_glx_vendor_private_with_reply_cookie_t xcb_ret; 1489 xcb_glx_vendor_private_with_reply_request_t xcb_out; 1490 1491 xcb_out.vendor_code = vendor_code; 1492 xcb_out.context_tag = context_tag; 1493 1494 xcb_parts[2].iov_base = (char *) &xcb_out; 1495 xcb_parts[2].iov_len = sizeof(xcb_out); 1496 xcb_parts[3].iov_base = 0; 1497 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1498 /* uint8_t data */ 1499 xcb_parts[4].iov_base = (char *) data; 1500 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 1501 xcb_parts[5].iov_base = 0; 1502 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1503 1504 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1505 return xcb_ret; 1506} 1507 1508uint8_t * 1509xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R) 1510{ 1511 return (uint8_t *) (R + 1); 1512} 1513 1514int 1515xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R) 1516{ 1517 return (R->length * 4); 1518} 1519 1520xcb_generic_iterator_t 1521xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R) 1522{ 1523 xcb_generic_iterator_t i; 1524 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 1525 i.rem = 0; 1526 i.index = (char *) i.data - (char *) R; 1527 return i; 1528} 1529 1530xcb_glx_vendor_private_with_reply_reply_t * 1531xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c, 1532 xcb_glx_vendor_private_with_reply_cookie_t cookie /**< */, 1533 xcb_generic_error_t **e) 1534{ 1535 return (xcb_glx_vendor_private_with_reply_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1536} 1537 1538xcb_glx_query_extensions_string_cookie_t 1539xcb_glx_query_extensions_string (xcb_connection_t *c, 1540 uint32_t screen) 1541{ 1542 static const xcb_protocol_request_t xcb_req = { 1543 .count = 2, 1544 .ext = &xcb_glx_id, 1545 .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING, 1546 .isvoid = 0 1547 }; 1548 1549 struct iovec xcb_parts[4]; 1550 xcb_glx_query_extensions_string_cookie_t xcb_ret; 1551 xcb_glx_query_extensions_string_request_t xcb_out; 1552 1553 xcb_out.screen = screen; 1554 1555 xcb_parts[2].iov_base = (char *) &xcb_out; 1556 xcb_parts[2].iov_len = sizeof(xcb_out); 1557 xcb_parts[3].iov_base = 0; 1558 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1559 1560 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1561 return xcb_ret; 1562} 1563 1564xcb_glx_query_extensions_string_cookie_t 1565xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c, 1566 uint32_t screen) 1567{ 1568 static const xcb_protocol_request_t xcb_req = { 1569 .count = 2, 1570 .ext = &xcb_glx_id, 1571 .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING, 1572 .isvoid = 0 1573 }; 1574 1575 struct iovec xcb_parts[4]; 1576 xcb_glx_query_extensions_string_cookie_t xcb_ret; 1577 xcb_glx_query_extensions_string_request_t xcb_out; 1578 1579 xcb_out.screen = screen; 1580 1581 xcb_parts[2].iov_base = (char *) &xcb_out; 1582 xcb_parts[2].iov_len = sizeof(xcb_out); 1583 xcb_parts[3].iov_base = 0; 1584 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1585 1586 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1587 return xcb_ret; 1588} 1589 1590xcb_glx_query_extensions_string_reply_t * 1591xcb_glx_query_extensions_string_reply (xcb_connection_t *c, 1592 xcb_glx_query_extensions_string_cookie_t cookie /**< */, 1593 xcb_generic_error_t **e) 1594{ 1595 return (xcb_glx_query_extensions_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1596} 1597 1598int 1599xcb_glx_query_server_string_sizeof (const void *_buffer) 1600{ 1601 char *xcb_tmp = (char *)_buffer; 1602 const xcb_glx_query_server_string_reply_t *_aux = (xcb_glx_query_server_string_reply_t *)_buffer; 1603 unsigned int xcb_buffer_len = 0; 1604 unsigned int xcb_block_len = 0; 1605 unsigned int xcb_pad = 0; 1606 unsigned int xcb_align_to = 0; 1607 1608 1609 xcb_block_len += sizeof(xcb_glx_query_server_string_reply_t); 1610 xcb_tmp += xcb_block_len; 1611 xcb_buffer_len += xcb_block_len; 1612 xcb_block_len = 0; 1613 /* string */ 1614 xcb_block_len += _aux->str_len * sizeof(char); 1615 xcb_tmp += xcb_block_len; 1616 xcb_align_to = ALIGNOF(char); 1617 /* insert padding */ 1618 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1619 xcb_buffer_len += xcb_block_len + xcb_pad; 1620 if (0 != xcb_pad) { 1621 xcb_tmp += xcb_pad; 1622 xcb_pad = 0; 1623 } 1624 xcb_block_len = 0; 1625 1626 return xcb_buffer_len; 1627} 1628 1629xcb_glx_query_server_string_cookie_t 1630xcb_glx_query_server_string (xcb_connection_t *c, 1631 uint32_t screen, 1632 uint32_t name) 1633{ 1634 static const xcb_protocol_request_t xcb_req = { 1635 .count = 2, 1636 .ext = &xcb_glx_id, 1637 .opcode = XCB_GLX_QUERY_SERVER_STRING, 1638 .isvoid = 0 1639 }; 1640 1641 struct iovec xcb_parts[4]; 1642 xcb_glx_query_server_string_cookie_t xcb_ret; 1643 xcb_glx_query_server_string_request_t xcb_out; 1644 1645 xcb_out.screen = screen; 1646 xcb_out.name = name; 1647 1648 xcb_parts[2].iov_base = (char *) &xcb_out; 1649 xcb_parts[2].iov_len = sizeof(xcb_out); 1650 xcb_parts[3].iov_base = 0; 1651 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1652 1653 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1654 return xcb_ret; 1655} 1656 1657xcb_glx_query_server_string_cookie_t 1658xcb_glx_query_server_string_unchecked (xcb_connection_t *c, 1659 uint32_t screen, 1660 uint32_t name) 1661{ 1662 static const xcb_protocol_request_t xcb_req = { 1663 .count = 2, 1664 .ext = &xcb_glx_id, 1665 .opcode = XCB_GLX_QUERY_SERVER_STRING, 1666 .isvoid = 0 1667 }; 1668 1669 struct iovec xcb_parts[4]; 1670 xcb_glx_query_server_string_cookie_t xcb_ret; 1671 xcb_glx_query_server_string_request_t xcb_out; 1672 1673 xcb_out.screen = screen; 1674 xcb_out.name = name; 1675 1676 xcb_parts[2].iov_base = (char *) &xcb_out; 1677 xcb_parts[2].iov_len = sizeof(xcb_out); 1678 xcb_parts[3].iov_base = 0; 1679 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1680 1681 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1682 return xcb_ret; 1683} 1684 1685char * 1686xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R) 1687{ 1688 return (char *) (R + 1); 1689} 1690 1691int 1692xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R) 1693{ 1694 return R->str_len; 1695} 1696 1697xcb_generic_iterator_t 1698xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R) 1699{ 1700 xcb_generic_iterator_t i; 1701 i.data = ((char *) (R + 1)) + (R->str_len); 1702 i.rem = 0; 1703 i.index = (char *) i.data - (char *) R; 1704 return i; 1705} 1706 1707xcb_glx_query_server_string_reply_t * 1708xcb_glx_query_server_string_reply (xcb_connection_t *c, 1709 xcb_glx_query_server_string_cookie_t cookie /**< */, 1710 xcb_generic_error_t **e) 1711{ 1712 return (xcb_glx_query_server_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1713} 1714 1715int 1716xcb_glx_client_info_sizeof (const void *_buffer) 1717{ 1718 char *xcb_tmp = (char *)_buffer; 1719 const xcb_glx_client_info_request_t *_aux = (xcb_glx_client_info_request_t *)_buffer; 1720 unsigned int xcb_buffer_len = 0; 1721 unsigned int xcb_block_len = 0; 1722 unsigned int xcb_pad = 0; 1723 unsigned int xcb_align_to = 0; 1724 1725 1726 xcb_block_len += sizeof(xcb_glx_client_info_request_t); 1727 xcb_tmp += xcb_block_len; 1728 xcb_buffer_len += xcb_block_len; 1729 xcb_block_len = 0; 1730 /* string */ 1731 xcb_block_len += _aux->str_len * sizeof(char); 1732 xcb_tmp += xcb_block_len; 1733 xcb_align_to = ALIGNOF(char); 1734 /* insert padding */ 1735 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1736 xcb_buffer_len += xcb_block_len + xcb_pad; 1737 if (0 != xcb_pad) { 1738 xcb_tmp += xcb_pad; 1739 xcb_pad = 0; 1740 } 1741 xcb_block_len = 0; 1742 1743 return xcb_buffer_len; 1744} 1745 1746xcb_void_cookie_t 1747xcb_glx_client_info_checked (xcb_connection_t *c, 1748 uint32_t major_version, 1749 uint32_t minor_version, 1750 uint32_t str_len, 1751 const char *string) 1752{ 1753 static const xcb_protocol_request_t xcb_req = { 1754 .count = 4, 1755 .ext = &xcb_glx_id, 1756 .opcode = XCB_GLX_CLIENT_INFO, 1757 .isvoid = 1 1758 }; 1759 1760 struct iovec xcb_parts[6]; 1761 xcb_void_cookie_t xcb_ret; 1762 xcb_glx_client_info_request_t xcb_out; 1763 1764 xcb_out.major_version = major_version; 1765 xcb_out.minor_version = minor_version; 1766 xcb_out.str_len = str_len; 1767 1768 xcb_parts[2].iov_base = (char *) &xcb_out; 1769 xcb_parts[2].iov_len = sizeof(xcb_out); 1770 xcb_parts[3].iov_base = 0; 1771 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1772 /* char string */ 1773 xcb_parts[4].iov_base = (char *) string; 1774 xcb_parts[4].iov_len = str_len * sizeof(char); 1775 xcb_parts[5].iov_base = 0; 1776 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1777 1778 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1779 return xcb_ret; 1780} 1781 1782xcb_void_cookie_t 1783xcb_glx_client_info (xcb_connection_t *c, 1784 uint32_t major_version, 1785 uint32_t minor_version, 1786 uint32_t str_len, 1787 const char *string) 1788{ 1789 static const xcb_protocol_request_t xcb_req = { 1790 .count = 4, 1791 .ext = &xcb_glx_id, 1792 .opcode = XCB_GLX_CLIENT_INFO, 1793 .isvoid = 1 1794 }; 1795 1796 struct iovec xcb_parts[6]; 1797 xcb_void_cookie_t xcb_ret; 1798 xcb_glx_client_info_request_t xcb_out; 1799 1800 xcb_out.major_version = major_version; 1801 xcb_out.minor_version = minor_version; 1802 xcb_out.str_len = str_len; 1803 1804 xcb_parts[2].iov_base = (char *) &xcb_out; 1805 xcb_parts[2].iov_len = sizeof(xcb_out); 1806 xcb_parts[3].iov_base = 0; 1807 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1808 /* char string */ 1809 xcb_parts[4].iov_base = (char *) string; 1810 xcb_parts[4].iov_len = str_len * sizeof(char); 1811 xcb_parts[5].iov_base = 0; 1812 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1813 1814 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1815 return xcb_ret; 1816} 1817 1818char * 1819xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R) 1820{ 1821 return (char *) (R + 1); 1822} 1823 1824int 1825xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R) 1826{ 1827 return R->str_len; 1828} 1829 1830xcb_generic_iterator_t 1831xcb_glx_client_info_string_end (const xcb_glx_client_info_request_t *R) 1832{ 1833 xcb_generic_iterator_t i; 1834 i.data = ((char *) (R + 1)) + (R->str_len); 1835 i.rem = 0; 1836 i.index = (char *) i.data - (char *) R; 1837 return i; 1838} 1839 1840int 1841xcb_glx_get_fb_configs_sizeof (const void *_buffer) 1842{ 1843 char *xcb_tmp = (char *)_buffer; 1844 const xcb_glx_get_fb_configs_reply_t *_aux = (xcb_glx_get_fb_configs_reply_t *)_buffer; 1845 unsigned int xcb_buffer_len = 0; 1846 unsigned int xcb_block_len = 0; 1847 unsigned int xcb_pad = 0; 1848 unsigned int xcb_align_to = 0; 1849 1850 1851 xcb_block_len += sizeof(xcb_glx_get_fb_configs_reply_t); 1852 xcb_tmp += xcb_block_len; 1853 xcb_buffer_len += xcb_block_len; 1854 xcb_block_len = 0; 1855 /* property_list */ 1856 xcb_block_len += _aux->length * sizeof(uint32_t); 1857 xcb_tmp += xcb_block_len; 1858 xcb_align_to = ALIGNOF(uint32_t); 1859 /* insert padding */ 1860 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1861 xcb_buffer_len += xcb_block_len + xcb_pad; 1862 if (0 != xcb_pad) { 1863 xcb_tmp += xcb_pad; 1864 xcb_pad = 0; 1865 } 1866 xcb_block_len = 0; 1867 1868 return xcb_buffer_len; 1869} 1870 1871xcb_glx_get_fb_configs_cookie_t 1872xcb_glx_get_fb_configs (xcb_connection_t *c, 1873 uint32_t screen) 1874{ 1875 static const xcb_protocol_request_t xcb_req = { 1876 .count = 2, 1877 .ext = &xcb_glx_id, 1878 .opcode = XCB_GLX_GET_FB_CONFIGS, 1879 .isvoid = 0 1880 }; 1881 1882 struct iovec xcb_parts[4]; 1883 xcb_glx_get_fb_configs_cookie_t xcb_ret; 1884 xcb_glx_get_fb_configs_request_t xcb_out; 1885 1886 xcb_out.screen = screen; 1887 1888 xcb_parts[2].iov_base = (char *) &xcb_out; 1889 xcb_parts[2].iov_len = sizeof(xcb_out); 1890 xcb_parts[3].iov_base = 0; 1891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1892 1893 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1894 return xcb_ret; 1895} 1896 1897xcb_glx_get_fb_configs_cookie_t 1898xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c, 1899 uint32_t screen) 1900{ 1901 static const xcb_protocol_request_t xcb_req = { 1902 .count = 2, 1903 .ext = &xcb_glx_id, 1904 .opcode = XCB_GLX_GET_FB_CONFIGS, 1905 .isvoid = 0 1906 }; 1907 1908 struct iovec xcb_parts[4]; 1909 xcb_glx_get_fb_configs_cookie_t xcb_ret; 1910 xcb_glx_get_fb_configs_request_t xcb_out; 1911 1912 xcb_out.screen = screen; 1913 1914 xcb_parts[2].iov_base = (char *) &xcb_out; 1915 xcb_parts[2].iov_len = sizeof(xcb_out); 1916 xcb_parts[3].iov_base = 0; 1917 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1918 1919 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1920 return xcb_ret; 1921} 1922 1923uint32_t * 1924xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R) 1925{ 1926 return (uint32_t *) (R + 1); 1927} 1928 1929int 1930xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R) 1931{ 1932 return R->length; 1933} 1934 1935xcb_generic_iterator_t 1936xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R) 1937{ 1938 xcb_generic_iterator_t i; 1939 i.data = ((uint32_t *) (R + 1)) + (R->length); 1940 i.rem = 0; 1941 i.index = (char *) i.data - (char *) R; 1942 return i; 1943} 1944 1945xcb_glx_get_fb_configs_reply_t * 1946xcb_glx_get_fb_configs_reply (xcb_connection_t *c, 1947 xcb_glx_get_fb_configs_cookie_t cookie /**< */, 1948 xcb_generic_error_t **e) 1949{ 1950 return (xcb_glx_get_fb_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1951} 1952 1953int 1954xcb_glx_create_pixmap_sizeof (const void *_buffer) 1955{ 1956 char *xcb_tmp = (char *)_buffer; 1957 const xcb_glx_create_pixmap_request_t *_aux = (xcb_glx_create_pixmap_request_t *)_buffer; 1958 unsigned int xcb_buffer_len = 0; 1959 unsigned int xcb_block_len = 0; 1960 unsigned int xcb_pad = 0; 1961 unsigned int xcb_align_to = 0; 1962 1963 1964 xcb_block_len += sizeof(xcb_glx_create_pixmap_request_t); 1965 xcb_tmp += xcb_block_len; 1966 xcb_buffer_len += xcb_block_len; 1967 xcb_block_len = 0; 1968 /* attribs */ 1969 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 1970 xcb_tmp += xcb_block_len; 1971 xcb_align_to = ALIGNOF(uint32_t); 1972 /* insert padding */ 1973 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1974 xcb_buffer_len += xcb_block_len + xcb_pad; 1975 if (0 != xcb_pad) { 1976 xcb_tmp += xcb_pad; 1977 xcb_pad = 0; 1978 } 1979 xcb_block_len = 0; 1980 1981 return xcb_buffer_len; 1982} 1983 1984xcb_void_cookie_t 1985xcb_glx_create_pixmap_checked (xcb_connection_t *c, 1986 uint32_t screen, 1987 xcb_glx_fbconfig_t fbconfig, 1988 xcb_pixmap_t pixmap, 1989 xcb_glx_pixmap_t glx_pixmap, 1990 uint32_t num_attribs, 1991 const uint32_t *attribs) 1992{ 1993 static const xcb_protocol_request_t xcb_req = { 1994 .count = 4, 1995 .ext = &xcb_glx_id, 1996 .opcode = XCB_GLX_CREATE_PIXMAP, 1997 .isvoid = 1 1998 }; 1999 2000 struct iovec xcb_parts[6]; 2001 xcb_void_cookie_t xcb_ret; 2002 xcb_glx_create_pixmap_request_t xcb_out; 2003 2004 xcb_out.screen = screen; 2005 xcb_out.fbconfig = fbconfig; 2006 xcb_out.pixmap = pixmap; 2007 xcb_out.glx_pixmap = glx_pixmap; 2008 xcb_out.num_attribs = num_attribs; 2009 2010 xcb_parts[2].iov_base = (char *) &xcb_out; 2011 xcb_parts[2].iov_len = sizeof(xcb_out); 2012 xcb_parts[3].iov_base = 0; 2013 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2014 /* uint32_t attribs */ 2015 xcb_parts[4].iov_base = (char *) attribs; 2016 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2017 xcb_parts[5].iov_base = 0; 2018 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2019 2020 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2021 return xcb_ret; 2022} 2023 2024xcb_void_cookie_t 2025xcb_glx_create_pixmap (xcb_connection_t *c, 2026 uint32_t screen, 2027 xcb_glx_fbconfig_t fbconfig, 2028 xcb_pixmap_t pixmap, 2029 xcb_glx_pixmap_t glx_pixmap, 2030 uint32_t num_attribs, 2031 const uint32_t *attribs) 2032{ 2033 static const xcb_protocol_request_t xcb_req = { 2034 .count = 4, 2035 .ext = &xcb_glx_id, 2036 .opcode = XCB_GLX_CREATE_PIXMAP, 2037 .isvoid = 1 2038 }; 2039 2040 struct iovec xcb_parts[6]; 2041 xcb_void_cookie_t xcb_ret; 2042 xcb_glx_create_pixmap_request_t xcb_out; 2043 2044 xcb_out.screen = screen; 2045 xcb_out.fbconfig = fbconfig; 2046 xcb_out.pixmap = pixmap; 2047 xcb_out.glx_pixmap = glx_pixmap; 2048 xcb_out.num_attribs = num_attribs; 2049 2050 xcb_parts[2].iov_base = (char *) &xcb_out; 2051 xcb_parts[2].iov_len = sizeof(xcb_out); 2052 xcb_parts[3].iov_base = 0; 2053 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2054 /* uint32_t attribs */ 2055 xcb_parts[4].iov_base = (char *) attribs; 2056 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2057 xcb_parts[5].iov_base = 0; 2058 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2059 2060 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2061 return xcb_ret; 2062} 2063 2064uint32_t * 2065xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R) 2066{ 2067 return (uint32_t *) (R + 1); 2068} 2069 2070int 2071xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R) 2072{ 2073 return (R->num_attribs * 2); 2074} 2075 2076xcb_generic_iterator_t 2077xcb_glx_create_pixmap_attribs_end (const xcb_glx_create_pixmap_request_t *R) 2078{ 2079 xcb_generic_iterator_t i; 2080 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2081 i.rem = 0; 2082 i.index = (char *) i.data - (char *) R; 2083 return i; 2084} 2085 2086xcb_void_cookie_t 2087xcb_glx_destroy_pixmap_checked (xcb_connection_t *c, 2088 xcb_glx_pixmap_t glx_pixmap) 2089{ 2090 static const xcb_protocol_request_t xcb_req = { 2091 .count = 2, 2092 .ext = &xcb_glx_id, 2093 .opcode = XCB_GLX_DESTROY_PIXMAP, 2094 .isvoid = 1 2095 }; 2096 2097 struct iovec xcb_parts[4]; 2098 xcb_void_cookie_t xcb_ret; 2099 xcb_glx_destroy_pixmap_request_t xcb_out; 2100 2101 xcb_out.glx_pixmap = glx_pixmap; 2102 2103 xcb_parts[2].iov_base = (char *) &xcb_out; 2104 xcb_parts[2].iov_len = sizeof(xcb_out); 2105 xcb_parts[3].iov_base = 0; 2106 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2107 2108 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2109 return xcb_ret; 2110} 2111 2112xcb_void_cookie_t 2113xcb_glx_destroy_pixmap (xcb_connection_t *c, 2114 xcb_glx_pixmap_t glx_pixmap) 2115{ 2116 static const xcb_protocol_request_t xcb_req = { 2117 .count = 2, 2118 .ext = &xcb_glx_id, 2119 .opcode = XCB_GLX_DESTROY_PIXMAP, 2120 .isvoid = 1 2121 }; 2122 2123 struct iovec xcb_parts[4]; 2124 xcb_void_cookie_t xcb_ret; 2125 xcb_glx_destroy_pixmap_request_t xcb_out; 2126 2127 xcb_out.glx_pixmap = glx_pixmap; 2128 2129 xcb_parts[2].iov_base = (char *) &xcb_out; 2130 xcb_parts[2].iov_len = sizeof(xcb_out); 2131 xcb_parts[3].iov_base = 0; 2132 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2133 2134 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2135 return xcb_ret; 2136} 2137 2138xcb_void_cookie_t 2139xcb_glx_create_new_context_checked (xcb_connection_t *c, 2140 xcb_glx_context_t context, 2141 xcb_glx_fbconfig_t fbconfig, 2142 uint32_t screen, 2143 uint32_t render_type, 2144 xcb_glx_context_t share_list, 2145 uint8_t is_direct) 2146{ 2147 static const xcb_protocol_request_t xcb_req = { 2148 .count = 2, 2149 .ext = &xcb_glx_id, 2150 .opcode = XCB_GLX_CREATE_NEW_CONTEXT, 2151 .isvoid = 1 2152 }; 2153 2154 struct iovec xcb_parts[4]; 2155 xcb_void_cookie_t xcb_ret; 2156 xcb_glx_create_new_context_request_t xcb_out; 2157 2158 xcb_out.context = context; 2159 xcb_out.fbconfig = fbconfig; 2160 xcb_out.screen = screen; 2161 xcb_out.render_type = render_type; 2162 xcb_out.share_list = share_list; 2163 xcb_out.is_direct = is_direct; 2164 memset(xcb_out.pad0, 0, 3); 2165 2166 xcb_parts[2].iov_base = (char *) &xcb_out; 2167 xcb_parts[2].iov_len = sizeof(xcb_out); 2168 xcb_parts[3].iov_base = 0; 2169 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2170 2171 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2172 return xcb_ret; 2173} 2174 2175xcb_void_cookie_t 2176xcb_glx_create_new_context (xcb_connection_t *c, 2177 xcb_glx_context_t context, 2178 xcb_glx_fbconfig_t fbconfig, 2179 uint32_t screen, 2180 uint32_t render_type, 2181 xcb_glx_context_t share_list, 2182 uint8_t is_direct) 2183{ 2184 static const xcb_protocol_request_t xcb_req = { 2185 .count = 2, 2186 .ext = &xcb_glx_id, 2187 .opcode = XCB_GLX_CREATE_NEW_CONTEXT, 2188 .isvoid = 1 2189 }; 2190 2191 struct iovec xcb_parts[4]; 2192 xcb_void_cookie_t xcb_ret; 2193 xcb_glx_create_new_context_request_t xcb_out; 2194 2195 xcb_out.context = context; 2196 xcb_out.fbconfig = fbconfig; 2197 xcb_out.screen = screen; 2198 xcb_out.render_type = render_type; 2199 xcb_out.share_list = share_list; 2200 xcb_out.is_direct = is_direct; 2201 memset(xcb_out.pad0, 0, 3); 2202 2203 xcb_parts[2].iov_base = (char *) &xcb_out; 2204 xcb_parts[2].iov_len = sizeof(xcb_out); 2205 xcb_parts[3].iov_base = 0; 2206 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2207 2208 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2209 return xcb_ret; 2210} 2211 2212int 2213xcb_glx_query_context_sizeof (const void *_buffer) 2214{ 2215 char *xcb_tmp = (char *)_buffer; 2216 const xcb_glx_query_context_reply_t *_aux = (xcb_glx_query_context_reply_t *)_buffer; 2217 unsigned int xcb_buffer_len = 0; 2218 unsigned int xcb_block_len = 0; 2219 unsigned int xcb_pad = 0; 2220 unsigned int xcb_align_to = 0; 2221 2222 2223 xcb_block_len += sizeof(xcb_glx_query_context_reply_t); 2224 xcb_tmp += xcb_block_len; 2225 xcb_buffer_len += xcb_block_len; 2226 xcb_block_len = 0; 2227 /* attribs */ 2228 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2229 xcb_tmp += xcb_block_len; 2230 xcb_align_to = ALIGNOF(uint32_t); 2231 /* insert padding */ 2232 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2233 xcb_buffer_len += xcb_block_len + xcb_pad; 2234 if (0 != xcb_pad) { 2235 xcb_tmp += xcb_pad; 2236 xcb_pad = 0; 2237 } 2238 xcb_block_len = 0; 2239 2240 return xcb_buffer_len; 2241} 2242 2243xcb_glx_query_context_cookie_t 2244xcb_glx_query_context (xcb_connection_t *c, 2245 xcb_glx_context_t context) 2246{ 2247 static const xcb_protocol_request_t xcb_req = { 2248 .count = 2, 2249 .ext = &xcb_glx_id, 2250 .opcode = XCB_GLX_QUERY_CONTEXT, 2251 .isvoid = 0 2252 }; 2253 2254 struct iovec xcb_parts[4]; 2255 xcb_glx_query_context_cookie_t xcb_ret; 2256 xcb_glx_query_context_request_t xcb_out; 2257 2258 xcb_out.context = context; 2259 2260 xcb_parts[2].iov_base = (char *) &xcb_out; 2261 xcb_parts[2].iov_len = sizeof(xcb_out); 2262 xcb_parts[3].iov_base = 0; 2263 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2264 2265 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2266 return xcb_ret; 2267} 2268 2269xcb_glx_query_context_cookie_t 2270xcb_glx_query_context_unchecked (xcb_connection_t *c, 2271 xcb_glx_context_t context) 2272{ 2273 static const xcb_protocol_request_t xcb_req = { 2274 .count = 2, 2275 .ext = &xcb_glx_id, 2276 .opcode = XCB_GLX_QUERY_CONTEXT, 2277 .isvoid = 0 2278 }; 2279 2280 struct iovec xcb_parts[4]; 2281 xcb_glx_query_context_cookie_t xcb_ret; 2282 xcb_glx_query_context_request_t xcb_out; 2283 2284 xcb_out.context = context; 2285 2286 xcb_parts[2].iov_base = (char *) &xcb_out; 2287 xcb_parts[2].iov_len = sizeof(xcb_out); 2288 xcb_parts[3].iov_base = 0; 2289 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2290 2291 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2292 return xcb_ret; 2293} 2294 2295uint32_t * 2296xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R) 2297{ 2298 return (uint32_t *) (R + 1); 2299} 2300 2301int 2302xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R) 2303{ 2304 return (R->num_attribs * 2); 2305} 2306 2307xcb_generic_iterator_t 2308xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R) 2309{ 2310 xcb_generic_iterator_t i; 2311 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2312 i.rem = 0; 2313 i.index = (char *) i.data - (char *) R; 2314 return i; 2315} 2316 2317xcb_glx_query_context_reply_t * 2318xcb_glx_query_context_reply (xcb_connection_t *c, 2319 xcb_glx_query_context_cookie_t cookie /**< */, 2320 xcb_generic_error_t **e) 2321{ 2322 return (xcb_glx_query_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2323} 2324 2325xcb_glx_make_context_current_cookie_t 2326xcb_glx_make_context_current (xcb_connection_t *c, 2327 xcb_glx_context_tag_t old_context_tag, 2328 xcb_glx_drawable_t drawable, 2329 xcb_glx_drawable_t read_drawable, 2330 xcb_glx_context_t context) 2331{ 2332 static const xcb_protocol_request_t xcb_req = { 2333 .count = 2, 2334 .ext = &xcb_glx_id, 2335 .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT, 2336 .isvoid = 0 2337 }; 2338 2339 struct iovec xcb_parts[4]; 2340 xcb_glx_make_context_current_cookie_t xcb_ret; 2341 xcb_glx_make_context_current_request_t xcb_out; 2342 2343 xcb_out.old_context_tag = old_context_tag; 2344 xcb_out.drawable = drawable; 2345 xcb_out.read_drawable = read_drawable; 2346 xcb_out.context = context; 2347 2348 xcb_parts[2].iov_base = (char *) &xcb_out; 2349 xcb_parts[2].iov_len = sizeof(xcb_out); 2350 xcb_parts[3].iov_base = 0; 2351 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2352 2353 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2354 return xcb_ret; 2355} 2356 2357xcb_glx_make_context_current_cookie_t 2358xcb_glx_make_context_current_unchecked (xcb_connection_t *c, 2359 xcb_glx_context_tag_t old_context_tag, 2360 xcb_glx_drawable_t drawable, 2361 xcb_glx_drawable_t read_drawable, 2362 xcb_glx_context_t context) 2363{ 2364 static const xcb_protocol_request_t xcb_req = { 2365 .count = 2, 2366 .ext = &xcb_glx_id, 2367 .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT, 2368 .isvoid = 0 2369 }; 2370 2371 struct iovec xcb_parts[4]; 2372 xcb_glx_make_context_current_cookie_t xcb_ret; 2373 xcb_glx_make_context_current_request_t xcb_out; 2374 2375 xcb_out.old_context_tag = old_context_tag; 2376 xcb_out.drawable = drawable; 2377 xcb_out.read_drawable = read_drawable; 2378 xcb_out.context = context; 2379 2380 xcb_parts[2].iov_base = (char *) &xcb_out; 2381 xcb_parts[2].iov_len = sizeof(xcb_out); 2382 xcb_parts[3].iov_base = 0; 2383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2384 2385 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2386 return xcb_ret; 2387} 2388 2389xcb_glx_make_context_current_reply_t * 2390xcb_glx_make_context_current_reply (xcb_connection_t *c, 2391 xcb_glx_make_context_current_cookie_t cookie /**< */, 2392 xcb_generic_error_t **e) 2393{ 2394 return (xcb_glx_make_context_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2395} 2396 2397int 2398xcb_glx_create_pbuffer_sizeof (const void *_buffer) 2399{ 2400 char *xcb_tmp = (char *)_buffer; 2401 const xcb_glx_create_pbuffer_request_t *_aux = (xcb_glx_create_pbuffer_request_t *)_buffer; 2402 unsigned int xcb_buffer_len = 0; 2403 unsigned int xcb_block_len = 0; 2404 unsigned int xcb_pad = 0; 2405 unsigned int xcb_align_to = 0; 2406 2407 2408 xcb_block_len += sizeof(xcb_glx_create_pbuffer_request_t); 2409 xcb_tmp += xcb_block_len; 2410 xcb_buffer_len += xcb_block_len; 2411 xcb_block_len = 0; 2412 /* attribs */ 2413 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2414 xcb_tmp += xcb_block_len; 2415 xcb_align_to = ALIGNOF(uint32_t); 2416 /* insert padding */ 2417 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2418 xcb_buffer_len += xcb_block_len + xcb_pad; 2419 if (0 != xcb_pad) { 2420 xcb_tmp += xcb_pad; 2421 xcb_pad = 0; 2422 } 2423 xcb_block_len = 0; 2424 2425 return xcb_buffer_len; 2426} 2427 2428xcb_void_cookie_t 2429xcb_glx_create_pbuffer_checked (xcb_connection_t *c, 2430 uint32_t screen, 2431 xcb_glx_fbconfig_t fbconfig, 2432 xcb_glx_pbuffer_t pbuffer, 2433 uint32_t num_attribs, 2434 const uint32_t *attribs) 2435{ 2436 static const xcb_protocol_request_t xcb_req = { 2437 .count = 4, 2438 .ext = &xcb_glx_id, 2439 .opcode = XCB_GLX_CREATE_PBUFFER, 2440 .isvoid = 1 2441 }; 2442 2443 struct iovec xcb_parts[6]; 2444 xcb_void_cookie_t xcb_ret; 2445 xcb_glx_create_pbuffer_request_t xcb_out; 2446 2447 xcb_out.screen = screen; 2448 xcb_out.fbconfig = fbconfig; 2449 xcb_out.pbuffer = pbuffer; 2450 xcb_out.num_attribs = num_attribs; 2451 2452 xcb_parts[2].iov_base = (char *) &xcb_out; 2453 xcb_parts[2].iov_len = sizeof(xcb_out); 2454 xcb_parts[3].iov_base = 0; 2455 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2456 /* uint32_t attribs */ 2457 xcb_parts[4].iov_base = (char *) attribs; 2458 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2459 xcb_parts[5].iov_base = 0; 2460 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2461 2462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2463 return xcb_ret; 2464} 2465 2466xcb_void_cookie_t 2467xcb_glx_create_pbuffer (xcb_connection_t *c, 2468 uint32_t screen, 2469 xcb_glx_fbconfig_t fbconfig, 2470 xcb_glx_pbuffer_t pbuffer, 2471 uint32_t num_attribs, 2472 const uint32_t *attribs) 2473{ 2474 static const xcb_protocol_request_t xcb_req = { 2475 .count = 4, 2476 .ext = &xcb_glx_id, 2477 .opcode = XCB_GLX_CREATE_PBUFFER, 2478 .isvoid = 1 2479 }; 2480 2481 struct iovec xcb_parts[6]; 2482 xcb_void_cookie_t xcb_ret; 2483 xcb_glx_create_pbuffer_request_t xcb_out; 2484 2485 xcb_out.screen = screen; 2486 xcb_out.fbconfig = fbconfig; 2487 xcb_out.pbuffer = pbuffer; 2488 xcb_out.num_attribs = num_attribs; 2489 2490 xcb_parts[2].iov_base = (char *) &xcb_out; 2491 xcb_parts[2].iov_len = sizeof(xcb_out); 2492 xcb_parts[3].iov_base = 0; 2493 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2494 /* uint32_t attribs */ 2495 xcb_parts[4].iov_base = (char *) attribs; 2496 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2497 xcb_parts[5].iov_base = 0; 2498 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2499 2500 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2501 return xcb_ret; 2502} 2503 2504uint32_t * 2505xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R) 2506{ 2507 return (uint32_t *) (R + 1); 2508} 2509 2510int 2511xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R) 2512{ 2513 return (R->num_attribs * 2); 2514} 2515 2516xcb_generic_iterator_t 2517xcb_glx_create_pbuffer_attribs_end (const xcb_glx_create_pbuffer_request_t *R) 2518{ 2519 xcb_generic_iterator_t i; 2520 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2521 i.rem = 0; 2522 i.index = (char *) i.data - (char *) R; 2523 return i; 2524} 2525 2526xcb_void_cookie_t 2527xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c, 2528 xcb_glx_pbuffer_t pbuffer) 2529{ 2530 static const xcb_protocol_request_t xcb_req = { 2531 .count = 2, 2532 .ext = &xcb_glx_id, 2533 .opcode = XCB_GLX_DESTROY_PBUFFER, 2534 .isvoid = 1 2535 }; 2536 2537 struct iovec xcb_parts[4]; 2538 xcb_void_cookie_t xcb_ret; 2539 xcb_glx_destroy_pbuffer_request_t xcb_out; 2540 2541 xcb_out.pbuffer = pbuffer; 2542 2543 xcb_parts[2].iov_base = (char *) &xcb_out; 2544 xcb_parts[2].iov_len = sizeof(xcb_out); 2545 xcb_parts[3].iov_base = 0; 2546 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2547 2548 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2549 return xcb_ret; 2550} 2551 2552xcb_void_cookie_t 2553xcb_glx_destroy_pbuffer (xcb_connection_t *c, 2554 xcb_glx_pbuffer_t pbuffer) 2555{ 2556 static const xcb_protocol_request_t xcb_req = { 2557 .count = 2, 2558 .ext = &xcb_glx_id, 2559 .opcode = XCB_GLX_DESTROY_PBUFFER, 2560 .isvoid = 1 2561 }; 2562 2563 struct iovec xcb_parts[4]; 2564 xcb_void_cookie_t xcb_ret; 2565 xcb_glx_destroy_pbuffer_request_t xcb_out; 2566 2567 xcb_out.pbuffer = pbuffer; 2568 2569 xcb_parts[2].iov_base = (char *) &xcb_out; 2570 xcb_parts[2].iov_len = sizeof(xcb_out); 2571 xcb_parts[3].iov_base = 0; 2572 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2573 2574 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2575 return xcb_ret; 2576} 2577 2578int 2579xcb_glx_get_drawable_attributes_sizeof (const void *_buffer) 2580{ 2581 char *xcb_tmp = (char *)_buffer; 2582 const xcb_glx_get_drawable_attributes_reply_t *_aux = (xcb_glx_get_drawable_attributes_reply_t *)_buffer; 2583 unsigned int xcb_buffer_len = 0; 2584 unsigned int xcb_block_len = 0; 2585 unsigned int xcb_pad = 0; 2586 unsigned int xcb_align_to = 0; 2587 2588 2589 xcb_block_len += sizeof(xcb_glx_get_drawable_attributes_reply_t); 2590 xcb_tmp += xcb_block_len; 2591 xcb_buffer_len += xcb_block_len; 2592 xcb_block_len = 0; 2593 /* attribs */ 2594 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2595 xcb_tmp += xcb_block_len; 2596 xcb_align_to = ALIGNOF(uint32_t); 2597 /* insert padding */ 2598 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2599 xcb_buffer_len += xcb_block_len + xcb_pad; 2600 if (0 != xcb_pad) { 2601 xcb_tmp += xcb_pad; 2602 xcb_pad = 0; 2603 } 2604 xcb_block_len = 0; 2605 2606 return xcb_buffer_len; 2607} 2608 2609xcb_glx_get_drawable_attributes_cookie_t 2610xcb_glx_get_drawable_attributes (xcb_connection_t *c, 2611 xcb_glx_drawable_t drawable) 2612{ 2613 static const xcb_protocol_request_t xcb_req = { 2614 .count = 2, 2615 .ext = &xcb_glx_id, 2616 .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 2617 .isvoid = 0 2618 }; 2619 2620 struct iovec xcb_parts[4]; 2621 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 2622 xcb_glx_get_drawable_attributes_request_t xcb_out; 2623 2624 xcb_out.drawable = drawable; 2625 2626 xcb_parts[2].iov_base = (char *) &xcb_out; 2627 xcb_parts[2].iov_len = sizeof(xcb_out); 2628 xcb_parts[3].iov_base = 0; 2629 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2630 2631 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2632 return xcb_ret; 2633} 2634 2635xcb_glx_get_drawable_attributes_cookie_t 2636xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c, 2637 xcb_glx_drawable_t drawable) 2638{ 2639 static const xcb_protocol_request_t xcb_req = { 2640 .count = 2, 2641 .ext = &xcb_glx_id, 2642 .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES, 2643 .isvoid = 0 2644 }; 2645 2646 struct iovec xcb_parts[4]; 2647 xcb_glx_get_drawable_attributes_cookie_t xcb_ret; 2648 xcb_glx_get_drawable_attributes_request_t xcb_out; 2649 2650 xcb_out.drawable = drawable; 2651 2652 xcb_parts[2].iov_base = (char *) &xcb_out; 2653 xcb_parts[2].iov_len = sizeof(xcb_out); 2654 xcb_parts[3].iov_base = 0; 2655 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2656 2657 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2658 return xcb_ret; 2659} 2660 2661uint32_t * 2662xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R) 2663{ 2664 return (uint32_t *) (R + 1); 2665} 2666 2667int 2668xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R) 2669{ 2670 return (R->num_attribs * 2); 2671} 2672 2673xcb_generic_iterator_t 2674xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R) 2675{ 2676 xcb_generic_iterator_t i; 2677 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2678 i.rem = 0; 2679 i.index = (char *) i.data - (char *) R; 2680 return i; 2681} 2682 2683xcb_glx_get_drawable_attributes_reply_t * 2684xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c, 2685 xcb_glx_get_drawable_attributes_cookie_t cookie /**< */, 2686 xcb_generic_error_t **e) 2687{ 2688 return (xcb_glx_get_drawable_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2689} 2690 2691int 2692xcb_glx_change_drawable_attributes_sizeof (const void *_buffer) 2693{ 2694 char *xcb_tmp = (char *)_buffer; 2695 const xcb_glx_change_drawable_attributes_request_t *_aux = (xcb_glx_change_drawable_attributes_request_t *)_buffer; 2696 unsigned int xcb_buffer_len = 0; 2697 unsigned int xcb_block_len = 0; 2698 unsigned int xcb_pad = 0; 2699 unsigned int xcb_align_to = 0; 2700 2701 2702 xcb_block_len += sizeof(xcb_glx_change_drawable_attributes_request_t); 2703 xcb_tmp += xcb_block_len; 2704 xcb_buffer_len += xcb_block_len; 2705 xcb_block_len = 0; 2706 /* attribs */ 2707 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2708 xcb_tmp += xcb_block_len; 2709 xcb_align_to = ALIGNOF(uint32_t); 2710 /* insert padding */ 2711 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2712 xcb_buffer_len += xcb_block_len + xcb_pad; 2713 if (0 != xcb_pad) { 2714 xcb_tmp += xcb_pad; 2715 xcb_pad = 0; 2716 } 2717 xcb_block_len = 0; 2718 2719 return xcb_buffer_len; 2720} 2721 2722xcb_void_cookie_t 2723xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c, 2724 xcb_glx_drawable_t drawable, 2725 uint32_t num_attribs, 2726 const uint32_t *attribs) 2727{ 2728 static const xcb_protocol_request_t xcb_req = { 2729 .count = 4, 2730 .ext = &xcb_glx_id, 2731 .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 2732 .isvoid = 1 2733 }; 2734 2735 struct iovec xcb_parts[6]; 2736 xcb_void_cookie_t xcb_ret; 2737 xcb_glx_change_drawable_attributes_request_t xcb_out; 2738 2739 xcb_out.drawable = drawable; 2740 xcb_out.num_attribs = num_attribs; 2741 2742 xcb_parts[2].iov_base = (char *) &xcb_out; 2743 xcb_parts[2].iov_len = sizeof(xcb_out); 2744 xcb_parts[3].iov_base = 0; 2745 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2746 /* uint32_t attribs */ 2747 xcb_parts[4].iov_base = (char *) attribs; 2748 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2749 xcb_parts[5].iov_base = 0; 2750 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2751 2752 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2753 return xcb_ret; 2754} 2755 2756xcb_void_cookie_t 2757xcb_glx_change_drawable_attributes (xcb_connection_t *c, 2758 xcb_glx_drawable_t drawable, 2759 uint32_t num_attribs, 2760 const uint32_t *attribs) 2761{ 2762 static const xcb_protocol_request_t xcb_req = { 2763 .count = 4, 2764 .ext = &xcb_glx_id, 2765 .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, 2766 .isvoid = 1 2767 }; 2768 2769 struct iovec xcb_parts[6]; 2770 xcb_void_cookie_t xcb_ret; 2771 xcb_glx_change_drawable_attributes_request_t xcb_out; 2772 2773 xcb_out.drawable = drawable; 2774 xcb_out.num_attribs = num_attribs; 2775 2776 xcb_parts[2].iov_base = (char *) &xcb_out; 2777 xcb_parts[2].iov_len = sizeof(xcb_out); 2778 xcb_parts[3].iov_base = 0; 2779 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2780 /* uint32_t attribs */ 2781 xcb_parts[4].iov_base = (char *) attribs; 2782 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2783 xcb_parts[5].iov_base = 0; 2784 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2785 2786 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2787 return xcb_ret; 2788} 2789 2790uint32_t * 2791xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R) 2792{ 2793 return (uint32_t *) (R + 1); 2794} 2795 2796int 2797xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R) 2798{ 2799 return (R->num_attribs * 2); 2800} 2801 2802xcb_generic_iterator_t 2803xcb_glx_change_drawable_attributes_attribs_end (const xcb_glx_change_drawable_attributes_request_t *R) 2804{ 2805 xcb_generic_iterator_t i; 2806 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2807 i.rem = 0; 2808 i.index = (char *) i.data - (char *) R; 2809 return i; 2810} 2811 2812int 2813xcb_glx_create_window_sizeof (const void *_buffer) 2814{ 2815 char *xcb_tmp = (char *)_buffer; 2816 const xcb_glx_create_window_request_t *_aux = (xcb_glx_create_window_request_t *)_buffer; 2817 unsigned int xcb_buffer_len = 0; 2818 unsigned int xcb_block_len = 0; 2819 unsigned int xcb_pad = 0; 2820 unsigned int xcb_align_to = 0; 2821 2822 2823 xcb_block_len += sizeof(xcb_glx_create_window_request_t); 2824 xcb_tmp += xcb_block_len; 2825 xcb_buffer_len += xcb_block_len; 2826 xcb_block_len = 0; 2827 /* attribs */ 2828 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 2829 xcb_tmp += xcb_block_len; 2830 xcb_align_to = ALIGNOF(uint32_t); 2831 /* insert padding */ 2832 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2833 xcb_buffer_len += xcb_block_len + xcb_pad; 2834 if (0 != xcb_pad) { 2835 xcb_tmp += xcb_pad; 2836 xcb_pad = 0; 2837 } 2838 xcb_block_len = 0; 2839 2840 return xcb_buffer_len; 2841} 2842 2843xcb_void_cookie_t 2844xcb_glx_create_window_checked (xcb_connection_t *c, 2845 uint32_t screen, 2846 xcb_glx_fbconfig_t fbconfig, 2847 xcb_window_t window, 2848 xcb_glx_window_t glx_window, 2849 uint32_t num_attribs, 2850 const uint32_t *attribs) 2851{ 2852 static const xcb_protocol_request_t xcb_req = { 2853 .count = 4, 2854 .ext = &xcb_glx_id, 2855 .opcode = XCB_GLX_CREATE_WINDOW, 2856 .isvoid = 1 2857 }; 2858 2859 struct iovec xcb_parts[6]; 2860 xcb_void_cookie_t xcb_ret; 2861 xcb_glx_create_window_request_t xcb_out; 2862 2863 xcb_out.screen = screen; 2864 xcb_out.fbconfig = fbconfig; 2865 xcb_out.window = window; 2866 xcb_out.glx_window = glx_window; 2867 xcb_out.num_attribs = num_attribs; 2868 2869 xcb_parts[2].iov_base = (char *) &xcb_out; 2870 xcb_parts[2].iov_len = sizeof(xcb_out); 2871 xcb_parts[3].iov_base = 0; 2872 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2873 /* uint32_t attribs */ 2874 xcb_parts[4].iov_base = (char *) attribs; 2875 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2876 xcb_parts[5].iov_base = 0; 2877 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2878 2879 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2880 return xcb_ret; 2881} 2882 2883xcb_void_cookie_t 2884xcb_glx_create_window (xcb_connection_t *c, 2885 uint32_t screen, 2886 xcb_glx_fbconfig_t fbconfig, 2887 xcb_window_t window, 2888 xcb_glx_window_t glx_window, 2889 uint32_t num_attribs, 2890 const uint32_t *attribs) 2891{ 2892 static const xcb_protocol_request_t xcb_req = { 2893 .count = 4, 2894 .ext = &xcb_glx_id, 2895 .opcode = XCB_GLX_CREATE_WINDOW, 2896 .isvoid = 1 2897 }; 2898 2899 struct iovec xcb_parts[6]; 2900 xcb_void_cookie_t xcb_ret; 2901 xcb_glx_create_window_request_t xcb_out; 2902 2903 xcb_out.screen = screen; 2904 xcb_out.fbconfig = fbconfig; 2905 xcb_out.window = window; 2906 xcb_out.glx_window = glx_window; 2907 xcb_out.num_attribs = num_attribs; 2908 2909 xcb_parts[2].iov_base = (char *) &xcb_out; 2910 xcb_parts[2].iov_len = sizeof(xcb_out); 2911 xcb_parts[3].iov_base = 0; 2912 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2913 /* uint32_t attribs */ 2914 xcb_parts[4].iov_base = (char *) attribs; 2915 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 2916 xcb_parts[5].iov_base = 0; 2917 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2918 2919 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2920 return xcb_ret; 2921} 2922 2923uint32_t * 2924xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R) 2925{ 2926 return (uint32_t *) (R + 1); 2927} 2928 2929int 2930xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R) 2931{ 2932 return (R->num_attribs * 2); 2933} 2934 2935xcb_generic_iterator_t 2936xcb_glx_create_window_attribs_end (const xcb_glx_create_window_request_t *R) 2937{ 2938 xcb_generic_iterator_t i; 2939 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 2940 i.rem = 0; 2941 i.index = (char *) i.data - (char *) R; 2942 return i; 2943} 2944 2945xcb_void_cookie_t 2946xcb_glx_delete_window_checked (xcb_connection_t *c, 2947 xcb_glx_window_t glxwindow) 2948{ 2949 static const xcb_protocol_request_t xcb_req = { 2950 .count = 2, 2951 .ext = &xcb_glx_id, 2952 .opcode = XCB_GLX_DELETE_WINDOW, 2953 .isvoid = 1 2954 }; 2955 2956 struct iovec xcb_parts[4]; 2957 xcb_void_cookie_t xcb_ret; 2958 xcb_glx_delete_window_request_t xcb_out; 2959 2960 xcb_out.glxwindow = glxwindow; 2961 2962 xcb_parts[2].iov_base = (char *) &xcb_out; 2963 xcb_parts[2].iov_len = sizeof(xcb_out); 2964 xcb_parts[3].iov_base = 0; 2965 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2966 2967 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2968 return xcb_ret; 2969} 2970 2971xcb_void_cookie_t 2972xcb_glx_delete_window (xcb_connection_t *c, 2973 xcb_glx_window_t glxwindow) 2974{ 2975 static const xcb_protocol_request_t xcb_req = { 2976 .count = 2, 2977 .ext = &xcb_glx_id, 2978 .opcode = XCB_GLX_DELETE_WINDOW, 2979 .isvoid = 1 2980 }; 2981 2982 struct iovec xcb_parts[4]; 2983 xcb_void_cookie_t xcb_ret; 2984 xcb_glx_delete_window_request_t xcb_out; 2985 2986 xcb_out.glxwindow = glxwindow; 2987 2988 xcb_parts[2].iov_base = (char *) &xcb_out; 2989 xcb_parts[2].iov_len = sizeof(xcb_out); 2990 xcb_parts[3].iov_base = 0; 2991 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2992 2993 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2994 return xcb_ret; 2995} 2996 2997int 2998xcb_glx_set_client_info_arb_sizeof (const void *_buffer) 2999{ 3000 char *xcb_tmp = (char *)_buffer; 3001 const xcb_glx_set_client_info_arb_request_t *_aux = (xcb_glx_set_client_info_arb_request_t *)_buffer; 3002 unsigned int xcb_buffer_len = 0; 3003 unsigned int xcb_block_len = 0; 3004 unsigned int xcb_pad = 0; 3005 unsigned int xcb_align_to = 0; 3006 3007 3008 xcb_block_len += sizeof(xcb_glx_set_client_info_arb_request_t); 3009 xcb_tmp += xcb_block_len; 3010 xcb_buffer_len += xcb_block_len; 3011 xcb_block_len = 0; 3012 /* gl_versions */ 3013 xcb_block_len += (_aux->num_versions * 2) * sizeof(uint32_t); 3014 xcb_tmp += xcb_block_len; 3015 xcb_align_to = ALIGNOF(uint32_t); 3016 /* insert padding */ 3017 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3018 xcb_buffer_len += xcb_block_len + xcb_pad; 3019 if (0 != xcb_pad) { 3020 xcb_tmp += xcb_pad; 3021 xcb_pad = 0; 3022 } 3023 xcb_block_len = 0; 3024 /* gl_extension_string */ 3025 xcb_block_len += _aux->gl_str_len * sizeof(char); 3026 xcb_tmp += xcb_block_len; 3027 xcb_align_to = ALIGNOF(char); 3028 xcb_align_to = 4; 3029 /* insert padding */ 3030 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3031 xcb_buffer_len += xcb_block_len + xcb_pad; 3032 if (0 != xcb_pad) { 3033 xcb_tmp += xcb_pad; 3034 xcb_pad = 0; 3035 } 3036 xcb_block_len = 0; 3037 /* insert padding */ 3038 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3039 xcb_buffer_len += xcb_block_len + xcb_pad; 3040 if (0 != xcb_pad) { 3041 xcb_tmp += xcb_pad; 3042 xcb_pad = 0; 3043 } 3044 xcb_block_len = 0; 3045 /* glx_extension_string */ 3046 xcb_block_len += _aux->glx_str_len * sizeof(char); 3047 xcb_tmp += xcb_block_len; 3048 xcb_align_to = ALIGNOF(char); 3049 /* insert padding */ 3050 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3051 xcb_buffer_len += xcb_block_len + xcb_pad; 3052 if (0 != xcb_pad) { 3053 xcb_tmp += xcb_pad; 3054 xcb_pad = 0; 3055 } 3056 xcb_block_len = 0; 3057 3058 return xcb_buffer_len; 3059} 3060 3061xcb_void_cookie_t 3062xcb_glx_set_client_info_arb_checked (xcb_connection_t *c, 3063 uint32_t major_version, 3064 uint32_t minor_version, 3065 uint32_t num_versions, 3066 uint32_t gl_str_len, 3067 uint32_t glx_str_len, 3068 const uint32_t *gl_versions, 3069 const char *gl_extension_string, 3070 const char *glx_extension_string) 3071{ 3072 static const xcb_protocol_request_t xcb_req = { 3073 .count = 8, 3074 .ext = &xcb_glx_id, 3075 .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, 3076 .isvoid = 1 3077 }; 3078 3079 struct iovec xcb_parts[10]; 3080 xcb_void_cookie_t xcb_ret; 3081 xcb_glx_set_client_info_arb_request_t xcb_out; 3082 3083 xcb_out.major_version = major_version; 3084 xcb_out.minor_version = minor_version; 3085 xcb_out.num_versions = num_versions; 3086 xcb_out.gl_str_len = gl_str_len; 3087 xcb_out.glx_str_len = glx_str_len; 3088 3089 xcb_parts[2].iov_base = (char *) &xcb_out; 3090 xcb_parts[2].iov_len = sizeof(xcb_out); 3091 xcb_parts[3].iov_base = 0; 3092 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3093 /* uint32_t gl_versions */ 3094 xcb_parts[4].iov_base = (char *) gl_versions; 3095 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 3096 xcb_parts[5].iov_base = 0; 3097 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3098 /* char gl_extension_string */ 3099 xcb_parts[6].iov_base = (char *) gl_extension_string; 3100 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3101 xcb_parts[7].iov_base = 0; 3102 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3103 /* char glx_extension_string */ 3104 xcb_parts[8].iov_base = (char *) glx_extension_string; 3105 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3106 xcb_parts[9].iov_base = 0; 3107 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3108 3109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3110 return xcb_ret; 3111} 3112 3113xcb_void_cookie_t 3114xcb_glx_set_client_info_arb (xcb_connection_t *c, 3115 uint32_t major_version, 3116 uint32_t minor_version, 3117 uint32_t num_versions, 3118 uint32_t gl_str_len, 3119 uint32_t glx_str_len, 3120 const uint32_t *gl_versions, 3121 const char *gl_extension_string, 3122 const char *glx_extension_string) 3123{ 3124 static const xcb_protocol_request_t xcb_req = { 3125 .count = 8, 3126 .ext = &xcb_glx_id, 3127 .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, 3128 .isvoid = 1 3129 }; 3130 3131 struct iovec xcb_parts[10]; 3132 xcb_void_cookie_t xcb_ret; 3133 xcb_glx_set_client_info_arb_request_t xcb_out; 3134 3135 xcb_out.major_version = major_version; 3136 xcb_out.minor_version = minor_version; 3137 xcb_out.num_versions = num_versions; 3138 xcb_out.gl_str_len = gl_str_len; 3139 xcb_out.glx_str_len = glx_str_len; 3140 3141 xcb_parts[2].iov_base = (char *) &xcb_out; 3142 xcb_parts[2].iov_len = sizeof(xcb_out); 3143 xcb_parts[3].iov_base = 0; 3144 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3145 /* uint32_t gl_versions */ 3146 xcb_parts[4].iov_base = (char *) gl_versions; 3147 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 3148 xcb_parts[5].iov_base = 0; 3149 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3150 /* char gl_extension_string */ 3151 xcb_parts[6].iov_base = (char *) gl_extension_string; 3152 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3153 xcb_parts[7].iov_base = 0; 3154 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3155 /* char glx_extension_string */ 3156 xcb_parts[8].iov_base = (char *) glx_extension_string; 3157 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3158 xcb_parts[9].iov_base = 0; 3159 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3160 3161 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3162 return xcb_ret; 3163} 3164 3165uint32_t * 3166xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R) 3167{ 3168 return (uint32_t *) (R + 1); 3169} 3170 3171int 3172xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R) 3173{ 3174 return (R->num_versions * 2); 3175} 3176 3177xcb_generic_iterator_t 3178xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R) 3179{ 3180 xcb_generic_iterator_t i; 3181 i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 2)); 3182 i.rem = 0; 3183 i.index = (char *) i.data - (char *) R; 3184 return i; 3185} 3186 3187char * 3188xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R) 3189{ 3190 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); 3191 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3192} 3193 3194int 3195xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) 3196{ 3197 return R->gl_str_len; 3198} 3199 3200xcb_generic_iterator_t 3201xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) 3202{ 3203 xcb_generic_iterator_t i; 3204 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); 3205 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); 3206 i.rem = 0; 3207 i.index = (char *) i.data - (char *) R; 3208 return i; 3209} 3210 3211char * 3212xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R) 3213{ 3214 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); 3215 return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); 3216} 3217 3218int 3219xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) 3220{ 3221 return R->glx_str_len; 3222} 3223 3224xcb_generic_iterator_t 3225xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) 3226{ 3227 xcb_generic_iterator_t i; 3228 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); 3229 i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->glx_str_len); 3230 i.rem = 0; 3231 i.index = (char *) i.data - (char *) R; 3232 return i; 3233} 3234 3235int 3236xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer) 3237{ 3238 char *xcb_tmp = (char *)_buffer; 3239 const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer; 3240 unsigned int xcb_buffer_len = 0; 3241 unsigned int xcb_block_len = 0; 3242 unsigned int xcb_pad = 0; 3243 unsigned int xcb_align_to = 0; 3244 3245 3246 xcb_block_len += sizeof(xcb_glx_create_context_attribs_arb_request_t); 3247 xcb_tmp += xcb_block_len; 3248 xcb_buffer_len += xcb_block_len; 3249 xcb_block_len = 0; 3250 /* attribs */ 3251 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3252 xcb_tmp += xcb_block_len; 3253 xcb_align_to = ALIGNOF(uint32_t); 3254 /* insert padding */ 3255 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3256 xcb_buffer_len += xcb_block_len + xcb_pad; 3257 if (0 != xcb_pad) { 3258 xcb_tmp += xcb_pad; 3259 xcb_pad = 0; 3260 } 3261 xcb_block_len = 0; 3262 3263 return xcb_buffer_len; 3264} 3265 3266xcb_void_cookie_t 3267xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c, 3268 xcb_glx_context_t context, 3269 xcb_glx_fbconfig_t fbconfig, 3270 uint32_t screen, 3271 xcb_glx_context_t share_list, 3272 uint8_t is_direct, 3273 uint32_t num_attribs, 3274 const uint32_t *attribs) 3275{ 3276 static const xcb_protocol_request_t xcb_req = { 3277 .count = 4, 3278 .ext = &xcb_glx_id, 3279 .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 3280 .isvoid = 1 3281 }; 3282 3283 struct iovec xcb_parts[6]; 3284 xcb_void_cookie_t xcb_ret; 3285 xcb_glx_create_context_attribs_arb_request_t xcb_out; 3286 3287 xcb_out.context = context; 3288 xcb_out.fbconfig = fbconfig; 3289 xcb_out.screen = screen; 3290 xcb_out.share_list = share_list; 3291 xcb_out.is_direct = is_direct; 3292 memset(xcb_out.pad0, 0, 3); 3293 xcb_out.num_attribs = num_attribs; 3294 3295 xcb_parts[2].iov_base = (char *) &xcb_out; 3296 xcb_parts[2].iov_len = sizeof(xcb_out); 3297 xcb_parts[3].iov_base = 0; 3298 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3299 /* uint32_t attribs */ 3300 xcb_parts[4].iov_base = (char *) attribs; 3301 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3302 xcb_parts[5].iov_base = 0; 3303 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3304 3305 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3306 return xcb_ret; 3307} 3308 3309xcb_void_cookie_t 3310xcb_glx_create_context_attribs_arb (xcb_connection_t *c, 3311 xcb_glx_context_t context, 3312 xcb_glx_fbconfig_t fbconfig, 3313 uint32_t screen, 3314 xcb_glx_context_t share_list, 3315 uint8_t is_direct, 3316 uint32_t num_attribs, 3317 const uint32_t *attribs) 3318{ 3319 static const xcb_protocol_request_t xcb_req = { 3320 .count = 4, 3321 .ext = &xcb_glx_id, 3322 .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 3323 .isvoid = 1 3324 }; 3325 3326 struct iovec xcb_parts[6]; 3327 xcb_void_cookie_t xcb_ret; 3328 xcb_glx_create_context_attribs_arb_request_t xcb_out; 3329 3330 xcb_out.context = context; 3331 xcb_out.fbconfig = fbconfig; 3332 xcb_out.screen = screen; 3333 xcb_out.share_list = share_list; 3334 xcb_out.is_direct = is_direct; 3335 memset(xcb_out.pad0, 0, 3); 3336 xcb_out.num_attribs = num_attribs; 3337 3338 xcb_parts[2].iov_base = (char *) &xcb_out; 3339 xcb_parts[2].iov_len = sizeof(xcb_out); 3340 xcb_parts[3].iov_base = 0; 3341 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3342 /* uint32_t attribs */ 3343 xcb_parts[4].iov_base = (char *) attribs; 3344 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3345 xcb_parts[5].iov_base = 0; 3346 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3347 3348 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3349 return xcb_ret; 3350} 3351 3352uint32_t * 3353xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R) 3354{ 3355 return (uint32_t *) (R + 1); 3356} 3357 3358int 3359xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R) 3360{ 3361 return (R->num_attribs * 2); 3362} 3363 3364xcb_generic_iterator_t 3365xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R) 3366{ 3367 xcb_generic_iterator_t i; 3368 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3369 i.rem = 0; 3370 i.index = (char *) i.data - (char *) R; 3371 return i; 3372} 3373 3374int 3375xcb_glx_set_client_info_2arb_sizeof (const void *_buffer) 3376{ 3377 char *xcb_tmp = (char *)_buffer; 3378 const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer; 3379 unsigned int xcb_buffer_len = 0; 3380 unsigned int xcb_block_len = 0; 3381 unsigned int xcb_pad = 0; 3382 unsigned int xcb_align_to = 0; 3383 3384 3385 xcb_block_len += sizeof(xcb_glx_set_client_info_2arb_request_t); 3386 xcb_tmp += xcb_block_len; 3387 xcb_buffer_len += xcb_block_len; 3388 xcb_block_len = 0; 3389 /* gl_versions */ 3390 xcb_block_len += (_aux->num_versions * 3) * sizeof(uint32_t); 3391 xcb_tmp += xcb_block_len; 3392 xcb_align_to = ALIGNOF(uint32_t); 3393 /* insert padding */ 3394 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3395 xcb_buffer_len += xcb_block_len + xcb_pad; 3396 if (0 != xcb_pad) { 3397 xcb_tmp += xcb_pad; 3398 xcb_pad = 0; 3399 } 3400 xcb_block_len = 0; 3401 /* gl_extension_string */ 3402 xcb_block_len += _aux->gl_str_len * sizeof(char); 3403 xcb_tmp += xcb_block_len; 3404 xcb_align_to = ALIGNOF(char); 3405 xcb_align_to = 4; 3406 /* insert padding */ 3407 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3408 xcb_buffer_len += xcb_block_len + xcb_pad; 3409 if (0 != xcb_pad) { 3410 xcb_tmp += xcb_pad; 3411 xcb_pad = 0; 3412 } 3413 xcb_block_len = 0; 3414 /* insert padding */ 3415 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3416 xcb_buffer_len += xcb_block_len + xcb_pad; 3417 if (0 != xcb_pad) { 3418 xcb_tmp += xcb_pad; 3419 xcb_pad = 0; 3420 } 3421 xcb_block_len = 0; 3422 /* glx_extension_string */ 3423 xcb_block_len += _aux->glx_str_len * sizeof(char); 3424 xcb_tmp += xcb_block_len; 3425 xcb_align_to = ALIGNOF(char); 3426 /* insert padding */ 3427 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3428 xcb_buffer_len += xcb_block_len + xcb_pad; 3429 if (0 != xcb_pad) { 3430 xcb_tmp += xcb_pad; 3431 xcb_pad = 0; 3432 } 3433 xcb_block_len = 0; 3434 3435 return xcb_buffer_len; 3436} 3437 3438xcb_void_cookie_t 3439xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c, 3440 uint32_t major_version, 3441 uint32_t minor_version, 3442 uint32_t num_versions, 3443 uint32_t gl_str_len, 3444 uint32_t glx_str_len, 3445 const uint32_t *gl_versions, 3446 const char *gl_extension_string, 3447 const char *glx_extension_string) 3448{ 3449 static const xcb_protocol_request_t xcb_req = { 3450 .count = 8, 3451 .ext = &xcb_glx_id, 3452 .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, 3453 .isvoid = 1 3454 }; 3455 3456 struct iovec xcb_parts[10]; 3457 xcb_void_cookie_t xcb_ret; 3458 xcb_glx_set_client_info_2arb_request_t xcb_out; 3459 3460 xcb_out.major_version = major_version; 3461 xcb_out.minor_version = minor_version; 3462 xcb_out.num_versions = num_versions; 3463 xcb_out.gl_str_len = gl_str_len; 3464 xcb_out.glx_str_len = glx_str_len; 3465 3466 xcb_parts[2].iov_base = (char *) &xcb_out; 3467 xcb_parts[2].iov_len = sizeof(xcb_out); 3468 xcb_parts[3].iov_base = 0; 3469 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3470 /* uint32_t gl_versions */ 3471 xcb_parts[4].iov_base = (char *) gl_versions; 3472 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 3473 xcb_parts[5].iov_base = 0; 3474 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3475 /* char gl_extension_string */ 3476 xcb_parts[6].iov_base = (char *) gl_extension_string; 3477 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3478 xcb_parts[7].iov_base = 0; 3479 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3480 /* char glx_extension_string */ 3481 xcb_parts[8].iov_base = (char *) glx_extension_string; 3482 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3483 xcb_parts[9].iov_base = 0; 3484 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3485 3486 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3487 return xcb_ret; 3488} 3489 3490xcb_void_cookie_t 3491xcb_glx_set_client_info_2arb (xcb_connection_t *c, 3492 uint32_t major_version, 3493 uint32_t minor_version, 3494 uint32_t num_versions, 3495 uint32_t gl_str_len, 3496 uint32_t glx_str_len, 3497 const uint32_t *gl_versions, 3498 const char *gl_extension_string, 3499 const char *glx_extension_string) 3500{ 3501 static const xcb_protocol_request_t xcb_req = { 3502 .count = 8, 3503 .ext = &xcb_glx_id, 3504 .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, 3505 .isvoid = 1 3506 }; 3507 3508 struct iovec xcb_parts[10]; 3509 xcb_void_cookie_t xcb_ret; 3510 xcb_glx_set_client_info_2arb_request_t xcb_out; 3511 3512 xcb_out.major_version = major_version; 3513 xcb_out.minor_version = minor_version; 3514 xcb_out.num_versions = num_versions; 3515 xcb_out.gl_str_len = gl_str_len; 3516 xcb_out.glx_str_len = glx_str_len; 3517 3518 xcb_parts[2].iov_base = (char *) &xcb_out; 3519 xcb_parts[2].iov_len = sizeof(xcb_out); 3520 xcb_parts[3].iov_base = 0; 3521 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3522 /* uint32_t gl_versions */ 3523 xcb_parts[4].iov_base = (char *) gl_versions; 3524 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 3525 xcb_parts[5].iov_base = 0; 3526 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3527 /* char gl_extension_string */ 3528 xcb_parts[6].iov_base = (char *) gl_extension_string; 3529 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3530 xcb_parts[7].iov_base = 0; 3531 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3532 /* char glx_extension_string */ 3533 xcb_parts[8].iov_base = (char *) glx_extension_string; 3534 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3535 xcb_parts[9].iov_base = 0; 3536 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3537 3538 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3539 return xcb_ret; 3540} 3541 3542uint32_t * 3543xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R) 3544{ 3545 return (uint32_t *) (R + 1); 3546} 3547 3548int 3549xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R) 3550{ 3551 return (R->num_versions * 3); 3552} 3553 3554xcb_generic_iterator_t 3555xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R) 3556{ 3557 xcb_generic_iterator_t i; 3558 i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 3)); 3559 i.rem = 0; 3560 i.index = (char *) i.data - (char *) R; 3561 return i; 3562} 3563 3564char * 3565xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) 3566{ 3567 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); 3568 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3569} 3570 3571int 3572xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) 3573{ 3574 return R->gl_str_len; 3575} 3576 3577xcb_generic_iterator_t 3578xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) 3579{ 3580 xcb_generic_iterator_t i; 3581 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); 3582 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); 3583 i.rem = 0; 3584 i.index = (char *) i.data - (char *) R; 3585 return i; 3586} 3587 3588char * 3589xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) 3590{ 3591 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); 3592 return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); 3593} 3594 3595int 3596xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) 3597{ 3598 return R->glx_str_len; 3599} 3600 3601xcb_generic_iterator_t 3602xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) 3603{ 3604 xcb_generic_iterator_t i; 3605 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); 3606 i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->glx_str_len); 3607 i.rem = 0; 3608 i.index = (char *) i.data - (char *) R; 3609 return i; 3610} 3611 3612xcb_void_cookie_t 3613xcb_glx_new_list_checked (xcb_connection_t *c, 3614 xcb_glx_context_tag_t context_tag, 3615 uint32_t list, 3616 uint32_t mode) 3617{ 3618 static const xcb_protocol_request_t xcb_req = { 3619 .count = 2, 3620 .ext = &xcb_glx_id, 3621 .opcode = XCB_GLX_NEW_LIST, 3622 .isvoid = 1 3623 }; 3624 3625 struct iovec xcb_parts[4]; 3626 xcb_void_cookie_t xcb_ret; 3627 xcb_glx_new_list_request_t xcb_out; 3628 3629 xcb_out.context_tag = context_tag; 3630 xcb_out.list = list; 3631 xcb_out.mode = mode; 3632 3633 xcb_parts[2].iov_base = (char *) &xcb_out; 3634 xcb_parts[2].iov_len = sizeof(xcb_out); 3635 xcb_parts[3].iov_base = 0; 3636 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3637 3638 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3639 return xcb_ret; 3640} 3641 3642xcb_void_cookie_t 3643xcb_glx_new_list (xcb_connection_t *c, 3644 xcb_glx_context_tag_t context_tag, 3645 uint32_t list, 3646 uint32_t mode) 3647{ 3648 static const xcb_protocol_request_t xcb_req = { 3649 .count = 2, 3650 .ext = &xcb_glx_id, 3651 .opcode = XCB_GLX_NEW_LIST, 3652 .isvoid = 1 3653 }; 3654 3655 struct iovec xcb_parts[4]; 3656 xcb_void_cookie_t xcb_ret; 3657 xcb_glx_new_list_request_t xcb_out; 3658 3659 xcb_out.context_tag = context_tag; 3660 xcb_out.list = list; 3661 xcb_out.mode = mode; 3662 3663 xcb_parts[2].iov_base = (char *) &xcb_out; 3664 xcb_parts[2].iov_len = sizeof(xcb_out); 3665 xcb_parts[3].iov_base = 0; 3666 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3667 3668 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3669 return xcb_ret; 3670} 3671 3672xcb_void_cookie_t 3673xcb_glx_end_list_checked (xcb_connection_t *c, 3674 xcb_glx_context_tag_t context_tag) 3675{ 3676 static const xcb_protocol_request_t xcb_req = { 3677 .count = 2, 3678 .ext = &xcb_glx_id, 3679 .opcode = XCB_GLX_END_LIST, 3680 .isvoid = 1 3681 }; 3682 3683 struct iovec xcb_parts[4]; 3684 xcb_void_cookie_t xcb_ret; 3685 xcb_glx_end_list_request_t xcb_out; 3686 3687 xcb_out.context_tag = context_tag; 3688 3689 xcb_parts[2].iov_base = (char *) &xcb_out; 3690 xcb_parts[2].iov_len = sizeof(xcb_out); 3691 xcb_parts[3].iov_base = 0; 3692 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3693 3694 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3695 return xcb_ret; 3696} 3697 3698xcb_void_cookie_t 3699xcb_glx_end_list (xcb_connection_t *c, 3700 xcb_glx_context_tag_t context_tag) 3701{ 3702 static const xcb_protocol_request_t xcb_req = { 3703 .count = 2, 3704 .ext = &xcb_glx_id, 3705 .opcode = XCB_GLX_END_LIST, 3706 .isvoid = 1 3707 }; 3708 3709 struct iovec xcb_parts[4]; 3710 xcb_void_cookie_t xcb_ret; 3711 xcb_glx_end_list_request_t xcb_out; 3712 3713 xcb_out.context_tag = context_tag; 3714 3715 xcb_parts[2].iov_base = (char *) &xcb_out; 3716 xcb_parts[2].iov_len = sizeof(xcb_out); 3717 xcb_parts[3].iov_base = 0; 3718 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3719 3720 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3721 return xcb_ret; 3722} 3723 3724xcb_void_cookie_t 3725xcb_glx_delete_lists_checked (xcb_connection_t *c, 3726 xcb_glx_context_tag_t context_tag, 3727 uint32_t list, 3728 int32_t range) 3729{ 3730 static const xcb_protocol_request_t xcb_req = { 3731 .count = 2, 3732 .ext = &xcb_glx_id, 3733 .opcode = XCB_GLX_DELETE_LISTS, 3734 .isvoid = 1 3735 }; 3736 3737 struct iovec xcb_parts[4]; 3738 xcb_void_cookie_t xcb_ret; 3739 xcb_glx_delete_lists_request_t xcb_out; 3740 3741 xcb_out.context_tag = context_tag; 3742 xcb_out.list = list; 3743 xcb_out.range = range; 3744 3745 xcb_parts[2].iov_base = (char *) &xcb_out; 3746 xcb_parts[2].iov_len = sizeof(xcb_out); 3747 xcb_parts[3].iov_base = 0; 3748 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3749 3750 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3751 return xcb_ret; 3752} 3753 3754xcb_void_cookie_t 3755xcb_glx_delete_lists (xcb_connection_t *c, 3756 xcb_glx_context_tag_t context_tag, 3757 uint32_t list, 3758 int32_t range) 3759{ 3760 static const xcb_protocol_request_t xcb_req = { 3761 .count = 2, 3762 .ext = &xcb_glx_id, 3763 .opcode = XCB_GLX_DELETE_LISTS, 3764 .isvoid = 1 3765 }; 3766 3767 struct iovec xcb_parts[4]; 3768 xcb_void_cookie_t xcb_ret; 3769 xcb_glx_delete_lists_request_t xcb_out; 3770 3771 xcb_out.context_tag = context_tag; 3772 xcb_out.list = list; 3773 xcb_out.range = range; 3774 3775 xcb_parts[2].iov_base = (char *) &xcb_out; 3776 xcb_parts[2].iov_len = sizeof(xcb_out); 3777 xcb_parts[3].iov_base = 0; 3778 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3779 3780 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3781 return xcb_ret; 3782} 3783 3784xcb_glx_gen_lists_cookie_t 3785xcb_glx_gen_lists (xcb_connection_t *c, 3786 xcb_glx_context_tag_t context_tag, 3787 int32_t range) 3788{ 3789 static const xcb_protocol_request_t xcb_req = { 3790 .count = 2, 3791 .ext = &xcb_glx_id, 3792 .opcode = XCB_GLX_GEN_LISTS, 3793 .isvoid = 0 3794 }; 3795 3796 struct iovec xcb_parts[4]; 3797 xcb_glx_gen_lists_cookie_t xcb_ret; 3798 xcb_glx_gen_lists_request_t xcb_out; 3799 3800 xcb_out.context_tag = context_tag; 3801 xcb_out.range = range; 3802 3803 xcb_parts[2].iov_base = (char *) &xcb_out; 3804 xcb_parts[2].iov_len = sizeof(xcb_out); 3805 xcb_parts[3].iov_base = 0; 3806 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3807 3808 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3809 return xcb_ret; 3810} 3811 3812xcb_glx_gen_lists_cookie_t 3813xcb_glx_gen_lists_unchecked (xcb_connection_t *c, 3814 xcb_glx_context_tag_t context_tag, 3815 int32_t range) 3816{ 3817 static const xcb_protocol_request_t xcb_req = { 3818 .count = 2, 3819 .ext = &xcb_glx_id, 3820 .opcode = XCB_GLX_GEN_LISTS, 3821 .isvoid = 0 3822 }; 3823 3824 struct iovec xcb_parts[4]; 3825 xcb_glx_gen_lists_cookie_t xcb_ret; 3826 xcb_glx_gen_lists_request_t xcb_out; 3827 3828 xcb_out.context_tag = context_tag; 3829 xcb_out.range = range; 3830 3831 xcb_parts[2].iov_base = (char *) &xcb_out; 3832 xcb_parts[2].iov_len = sizeof(xcb_out); 3833 xcb_parts[3].iov_base = 0; 3834 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3835 3836 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3837 return xcb_ret; 3838} 3839 3840xcb_glx_gen_lists_reply_t * 3841xcb_glx_gen_lists_reply (xcb_connection_t *c, 3842 xcb_glx_gen_lists_cookie_t cookie /**< */, 3843 xcb_generic_error_t **e) 3844{ 3845 return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3846} 3847 3848xcb_void_cookie_t 3849xcb_glx_feedback_buffer_checked (xcb_connection_t *c, 3850 xcb_glx_context_tag_t context_tag, 3851 int32_t size, 3852 int32_t type) 3853{ 3854 static const xcb_protocol_request_t xcb_req = { 3855 .count = 2, 3856 .ext = &xcb_glx_id, 3857 .opcode = XCB_GLX_FEEDBACK_BUFFER, 3858 .isvoid = 1 3859 }; 3860 3861 struct iovec xcb_parts[4]; 3862 xcb_void_cookie_t xcb_ret; 3863 xcb_glx_feedback_buffer_request_t xcb_out; 3864 3865 xcb_out.context_tag = context_tag; 3866 xcb_out.size = size; 3867 xcb_out.type = type; 3868 3869 xcb_parts[2].iov_base = (char *) &xcb_out; 3870 xcb_parts[2].iov_len = sizeof(xcb_out); 3871 xcb_parts[3].iov_base = 0; 3872 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3873 3874 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3875 return xcb_ret; 3876} 3877 3878xcb_void_cookie_t 3879xcb_glx_feedback_buffer (xcb_connection_t *c, 3880 xcb_glx_context_tag_t context_tag, 3881 int32_t size, 3882 int32_t type) 3883{ 3884 static const xcb_protocol_request_t xcb_req = { 3885 .count = 2, 3886 .ext = &xcb_glx_id, 3887 .opcode = XCB_GLX_FEEDBACK_BUFFER, 3888 .isvoid = 1 3889 }; 3890 3891 struct iovec xcb_parts[4]; 3892 xcb_void_cookie_t xcb_ret; 3893 xcb_glx_feedback_buffer_request_t xcb_out; 3894 3895 xcb_out.context_tag = context_tag; 3896 xcb_out.size = size; 3897 xcb_out.type = type; 3898 3899 xcb_parts[2].iov_base = (char *) &xcb_out; 3900 xcb_parts[2].iov_len = sizeof(xcb_out); 3901 xcb_parts[3].iov_base = 0; 3902 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3903 3904 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3905 return xcb_ret; 3906} 3907 3908xcb_void_cookie_t 3909xcb_glx_select_buffer_checked (xcb_connection_t *c, 3910 xcb_glx_context_tag_t context_tag, 3911 int32_t size) 3912{ 3913 static const xcb_protocol_request_t xcb_req = { 3914 .count = 2, 3915 .ext = &xcb_glx_id, 3916 .opcode = XCB_GLX_SELECT_BUFFER, 3917 .isvoid = 1 3918 }; 3919 3920 struct iovec xcb_parts[4]; 3921 xcb_void_cookie_t xcb_ret; 3922 xcb_glx_select_buffer_request_t xcb_out; 3923 3924 xcb_out.context_tag = context_tag; 3925 xcb_out.size = size; 3926 3927 xcb_parts[2].iov_base = (char *) &xcb_out; 3928 xcb_parts[2].iov_len = sizeof(xcb_out); 3929 xcb_parts[3].iov_base = 0; 3930 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3931 3932 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3933 return xcb_ret; 3934} 3935 3936xcb_void_cookie_t 3937xcb_glx_select_buffer (xcb_connection_t *c, 3938 xcb_glx_context_tag_t context_tag, 3939 int32_t size) 3940{ 3941 static const xcb_protocol_request_t xcb_req = { 3942 .count = 2, 3943 .ext = &xcb_glx_id, 3944 .opcode = XCB_GLX_SELECT_BUFFER, 3945 .isvoid = 1 3946 }; 3947 3948 struct iovec xcb_parts[4]; 3949 xcb_void_cookie_t xcb_ret; 3950 xcb_glx_select_buffer_request_t xcb_out; 3951 3952 xcb_out.context_tag = context_tag; 3953 xcb_out.size = size; 3954 3955 xcb_parts[2].iov_base = (char *) &xcb_out; 3956 xcb_parts[2].iov_len = sizeof(xcb_out); 3957 xcb_parts[3].iov_base = 0; 3958 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3959 3960 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3961 return xcb_ret; 3962} 3963 3964int 3965xcb_glx_render_mode_sizeof (const void *_buffer) 3966{ 3967 char *xcb_tmp = (char *)_buffer; 3968 const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer; 3969 unsigned int xcb_buffer_len = 0; 3970 unsigned int xcb_block_len = 0; 3971 unsigned int xcb_pad = 0; 3972 unsigned int xcb_align_to = 0; 3973 3974 3975 xcb_block_len += sizeof(xcb_glx_render_mode_reply_t); 3976 xcb_tmp += xcb_block_len; 3977 xcb_buffer_len += xcb_block_len; 3978 xcb_block_len = 0; 3979 /* data */ 3980 xcb_block_len += _aux->n * sizeof(uint32_t); 3981 xcb_tmp += xcb_block_len; 3982 xcb_align_to = ALIGNOF(uint32_t); 3983 /* insert padding */ 3984 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3985 xcb_buffer_len += xcb_block_len + xcb_pad; 3986 if (0 != xcb_pad) { 3987 xcb_tmp += xcb_pad; 3988 xcb_pad = 0; 3989 } 3990 xcb_block_len = 0; 3991 3992 return xcb_buffer_len; 3993} 3994 3995xcb_glx_render_mode_cookie_t 3996xcb_glx_render_mode (xcb_connection_t *c, 3997 xcb_glx_context_tag_t context_tag, 3998 uint32_t mode) 3999{ 4000 static const xcb_protocol_request_t xcb_req = { 4001 .count = 2, 4002 .ext = &xcb_glx_id, 4003 .opcode = XCB_GLX_RENDER_MODE, 4004 .isvoid = 0 4005 }; 4006 4007 struct iovec xcb_parts[4]; 4008 xcb_glx_render_mode_cookie_t xcb_ret; 4009 xcb_glx_render_mode_request_t xcb_out; 4010 4011 xcb_out.context_tag = context_tag; 4012 xcb_out.mode = mode; 4013 4014 xcb_parts[2].iov_base = (char *) &xcb_out; 4015 xcb_parts[2].iov_len = sizeof(xcb_out); 4016 xcb_parts[3].iov_base = 0; 4017 xcb_parts[3].iov_len = -xcb_parts[2].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 4023xcb_glx_render_mode_cookie_t 4024xcb_glx_render_mode_unchecked (xcb_connection_t *c, 4025 xcb_glx_context_tag_t context_tag, 4026 uint32_t mode) 4027{ 4028 static const xcb_protocol_request_t xcb_req = { 4029 .count = 2, 4030 .ext = &xcb_glx_id, 4031 .opcode = XCB_GLX_RENDER_MODE, 4032 .isvoid = 0 4033 }; 4034 4035 struct iovec xcb_parts[4]; 4036 xcb_glx_render_mode_cookie_t xcb_ret; 4037 xcb_glx_render_mode_request_t xcb_out; 4038 4039 xcb_out.context_tag = context_tag; 4040 xcb_out.mode = mode; 4041 4042 xcb_parts[2].iov_base = (char *) &xcb_out; 4043 xcb_parts[2].iov_len = sizeof(xcb_out); 4044 xcb_parts[3].iov_base = 0; 4045 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4046 4047 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4048 return xcb_ret; 4049} 4050 4051uint32_t * 4052xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R) 4053{ 4054 return (uint32_t *) (R + 1); 4055} 4056 4057int 4058xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R) 4059{ 4060 return R->n; 4061} 4062 4063xcb_generic_iterator_t 4064xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R) 4065{ 4066 xcb_generic_iterator_t i; 4067 i.data = ((uint32_t *) (R + 1)) + (R->n); 4068 i.rem = 0; 4069 i.index = (char *) i.data - (char *) R; 4070 return i; 4071} 4072 4073xcb_glx_render_mode_reply_t * 4074xcb_glx_render_mode_reply (xcb_connection_t *c, 4075 xcb_glx_render_mode_cookie_t cookie /**< */, 4076 xcb_generic_error_t **e) 4077{ 4078 return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4079} 4080 4081xcb_glx_finish_cookie_t 4082xcb_glx_finish (xcb_connection_t *c, 4083 xcb_glx_context_tag_t context_tag) 4084{ 4085 static const xcb_protocol_request_t xcb_req = { 4086 .count = 2, 4087 .ext = &xcb_glx_id, 4088 .opcode = XCB_GLX_FINISH, 4089 .isvoid = 0 4090 }; 4091 4092 struct iovec xcb_parts[4]; 4093 xcb_glx_finish_cookie_t xcb_ret; 4094 xcb_glx_finish_request_t xcb_out; 4095 4096 xcb_out.context_tag = context_tag; 4097 4098 xcb_parts[2].iov_base = (char *) &xcb_out; 4099 xcb_parts[2].iov_len = sizeof(xcb_out); 4100 xcb_parts[3].iov_base = 0; 4101 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4102 4103 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4104 return xcb_ret; 4105} 4106 4107xcb_glx_finish_cookie_t 4108xcb_glx_finish_unchecked (xcb_connection_t *c, 4109 xcb_glx_context_tag_t context_tag) 4110{ 4111 static const xcb_protocol_request_t xcb_req = { 4112 .count = 2, 4113 .ext = &xcb_glx_id, 4114 .opcode = XCB_GLX_FINISH, 4115 .isvoid = 0 4116 }; 4117 4118 struct iovec xcb_parts[4]; 4119 xcb_glx_finish_cookie_t xcb_ret; 4120 xcb_glx_finish_request_t xcb_out; 4121 4122 xcb_out.context_tag = context_tag; 4123 4124 xcb_parts[2].iov_base = (char *) &xcb_out; 4125 xcb_parts[2].iov_len = sizeof(xcb_out); 4126 xcb_parts[3].iov_base = 0; 4127 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4128 4129 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4130 return xcb_ret; 4131} 4132 4133xcb_glx_finish_reply_t * 4134xcb_glx_finish_reply (xcb_connection_t *c, 4135 xcb_glx_finish_cookie_t cookie /**< */, 4136 xcb_generic_error_t **e) 4137{ 4138 return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4139} 4140 4141xcb_void_cookie_t 4142xcb_glx_pixel_storef_checked (xcb_connection_t *c, 4143 xcb_glx_context_tag_t context_tag, 4144 uint32_t pname, 4145 xcb_glx_float32_t datum) 4146{ 4147 static const xcb_protocol_request_t xcb_req = { 4148 .count = 2, 4149 .ext = &xcb_glx_id, 4150 .opcode = XCB_GLX_PIXEL_STOREF, 4151 .isvoid = 1 4152 }; 4153 4154 struct iovec xcb_parts[4]; 4155 xcb_void_cookie_t xcb_ret; 4156 xcb_glx_pixel_storef_request_t xcb_out; 4157 4158 xcb_out.context_tag = context_tag; 4159 xcb_out.pname = pname; 4160 xcb_out.datum = datum; 4161 4162 xcb_parts[2].iov_base = (char *) &xcb_out; 4163 xcb_parts[2].iov_len = sizeof(xcb_out); 4164 xcb_parts[3].iov_base = 0; 4165 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4166 4167 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4168 return xcb_ret; 4169} 4170 4171xcb_void_cookie_t 4172xcb_glx_pixel_storef (xcb_connection_t *c, 4173 xcb_glx_context_tag_t context_tag, 4174 uint32_t pname, 4175 xcb_glx_float32_t datum) 4176{ 4177 static const xcb_protocol_request_t xcb_req = { 4178 .count = 2, 4179 .ext = &xcb_glx_id, 4180 .opcode = XCB_GLX_PIXEL_STOREF, 4181 .isvoid = 1 4182 }; 4183 4184 struct iovec xcb_parts[4]; 4185 xcb_void_cookie_t xcb_ret; 4186 xcb_glx_pixel_storef_request_t xcb_out; 4187 4188 xcb_out.context_tag = context_tag; 4189 xcb_out.pname = pname; 4190 xcb_out.datum = datum; 4191 4192 xcb_parts[2].iov_base = (char *) &xcb_out; 4193 xcb_parts[2].iov_len = sizeof(xcb_out); 4194 xcb_parts[3].iov_base = 0; 4195 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4196 4197 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4198 return xcb_ret; 4199} 4200 4201xcb_void_cookie_t 4202xcb_glx_pixel_storei_checked (xcb_connection_t *c, 4203 xcb_glx_context_tag_t context_tag, 4204 uint32_t pname, 4205 int32_t datum) 4206{ 4207 static const xcb_protocol_request_t xcb_req = { 4208 .count = 2, 4209 .ext = &xcb_glx_id, 4210 .opcode = XCB_GLX_PIXEL_STOREI, 4211 .isvoid = 1 4212 }; 4213 4214 struct iovec xcb_parts[4]; 4215 xcb_void_cookie_t xcb_ret; 4216 xcb_glx_pixel_storei_request_t xcb_out; 4217 4218 xcb_out.context_tag = context_tag; 4219 xcb_out.pname = pname; 4220 xcb_out.datum = datum; 4221 4222 xcb_parts[2].iov_base = (char *) &xcb_out; 4223 xcb_parts[2].iov_len = sizeof(xcb_out); 4224 xcb_parts[3].iov_base = 0; 4225 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4226 4227 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4228 return xcb_ret; 4229} 4230 4231xcb_void_cookie_t 4232xcb_glx_pixel_storei (xcb_connection_t *c, 4233 xcb_glx_context_tag_t context_tag, 4234 uint32_t pname, 4235 int32_t datum) 4236{ 4237 static const xcb_protocol_request_t xcb_req = { 4238 .count = 2, 4239 .ext = &xcb_glx_id, 4240 .opcode = XCB_GLX_PIXEL_STOREI, 4241 .isvoid = 1 4242 }; 4243 4244 struct iovec xcb_parts[4]; 4245 xcb_void_cookie_t xcb_ret; 4246 xcb_glx_pixel_storei_request_t xcb_out; 4247 4248 xcb_out.context_tag = context_tag; 4249 xcb_out.pname = pname; 4250 xcb_out.datum = datum; 4251 4252 xcb_parts[2].iov_base = (char *) &xcb_out; 4253 xcb_parts[2].iov_len = sizeof(xcb_out); 4254 xcb_parts[3].iov_base = 0; 4255 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4256 4257 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4258 return xcb_ret; 4259} 4260 4261int 4262xcb_glx_read_pixels_sizeof (const void *_buffer) 4263{ 4264 char *xcb_tmp = (char *)_buffer; 4265 const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer; 4266 unsigned int xcb_buffer_len = 0; 4267 unsigned int xcb_block_len = 0; 4268 unsigned int xcb_pad = 0; 4269 unsigned int xcb_align_to = 0; 4270 4271 4272 xcb_block_len += sizeof(xcb_glx_read_pixels_reply_t); 4273 xcb_tmp += xcb_block_len; 4274 xcb_buffer_len += xcb_block_len; 4275 xcb_block_len = 0; 4276 /* data */ 4277 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 4278 xcb_tmp += xcb_block_len; 4279 xcb_align_to = ALIGNOF(uint8_t); 4280 /* insert padding */ 4281 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4282 xcb_buffer_len += xcb_block_len + xcb_pad; 4283 if (0 != xcb_pad) { 4284 xcb_tmp += xcb_pad; 4285 xcb_pad = 0; 4286 } 4287 xcb_block_len = 0; 4288 4289 return xcb_buffer_len; 4290} 4291 4292xcb_glx_read_pixels_cookie_t 4293xcb_glx_read_pixels (xcb_connection_t *c, 4294 xcb_glx_context_tag_t context_tag, 4295 int32_t x, 4296 int32_t y, 4297 int32_t width, 4298 int32_t height, 4299 uint32_t format, 4300 uint32_t type, 4301 uint8_t swap_bytes, 4302 uint8_t lsb_first) 4303{ 4304 static const xcb_protocol_request_t xcb_req = { 4305 .count = 2, 4306 .ext = &xcb_glx_id, 4307 .opcode = XCB_GLX_READ_PIXELS, 4308 .isvoid = 0 4309 }; 4310 4311 struct iovec xcb_parts[4]; 4312 xcb_glx_read_pixels_cookie_t xcb_ret; 4313 xcb_glx_read_pixels_request_t xcb_out; 4314 4315 xcb_out.context_tag = context_tag; 4316 xcb_out.x = x; 4317 xcb_out.y = y; 4318 xcb_out.width = width; 4319 xcb_out.height = height; 4320 xcb_out.format = format; 4321 xcb_out.type = type; 4322 xcb_out.swap_bytes = swap_bytes; 4323 xcb_out.lsb_first = lsb_first; 4324 4325 xcb_parts[2].iov_base = (char *) &xcb_out; 4326 xcb_parts[2].iov_len = sizeof(xcb_out); 4327 xcb_parts[3].iov_base = 0; 4328 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4329 4330 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4331 return xcb_ret; 4332} 4333 4334xcb_glx_read_pixels_cookie_t 4335xcb_glx_read_pixels_unchecked (xcb_connection_t *c, 4336 xcb_glx_context_tag_t context_tag, 4337 int32_t x, 4338 int32_t y, 4339 int32_t width, 4340 int32_t height, 4341 uint32_t format, 4342 uint32_t type, 4343 uint8_t swap_bytes, 4344 uint8_t lsb_first) 4345{ 4346 static const xcb_protocol_request_t xcb_req = { 4347 .count = 2, 4348 .ext = &xcb_glx_id, 4349 .opcode = XCB_GLX_READ_PIXELS, 4350 .isvoid = 0 4351 }; 4352 4353 struct iovec xcb_parts[4]; 4354 xcb_glx_read_pixels_cookie_t xcb_ret; 4355 xcb_glx_read_pixels_request_t xcb_out; 4356 4357 xcb_out.context_tag = context_tag; 4358 xcb_out.x = x; 4359 xcb_out.y = y; 4360 xcb_out.width = width; 4361 xcb_out.height = height; 4362 xcb_out.format = format; 4363 xcb_out.type = type; 4364 xcb_out.swap_bytes = swap_bytes; 4365 xcb_out.lsb_first = lsb_first; 4366 4367 xcb_parts[2].iov_base = (char *) &xcb_out; 4368 xcb_parts[2].iov_len = sizeof(xcb_out); 4369 xcb_parts[3].iov_base = 0; 4370 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4371 4372 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4373 return xcb_ret; 4374} 4375 4376uint8_t * 4377xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R) 4378{ 4379 return (uint8_t *) (R + 1); 4380} 4381 4382int 4383xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R) 4384{ 4385 return (R->length * 4); 4386} 4387 4388xcb_generic_iterator_t 4389xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R) 4390{ 4391 xcb_generic_iterator_t i; 4392 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 4393 i.rem = 0; 4394 i.index = (char *) i.data - (char *) R; 4395 return i; 4396} 4397 4398xcb_glx_read_pixels_reply_t * 4399xcb_glx_read_pixels_reply (xcb_connection_t *c, 4400 xcb_glx_read_pixels_cookie_t cookie /**< */, 4401 xcb_generic_error_t **e) 4402{ 4403 return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4404} 4405 4406int 4407xcb_glx_get_booleanv_sizeof (const void *_buffer) 4408{ 4409 char *xcb_tmp = (char *)_buffer; 4410 const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer; 4411 unsigned int xcb_buffer_len = 0; 4412 unsigned int xcb_block_len = 0; 4413 unsigned int xcb_pad = 0; 4414 unsigned int xcb_align_to = 0; 4415 4416 4417 xcb_block_len += sizeof(xcb_glx_get_booleanv_reply_t); 4418 xcb_tmp += xcb_block_len; 4419 xcb_buffer_len += xcb_block_len; 4420 xcb_block_len = 0; 4421 /* data */ 4422 xcb_block_len += _aux->n * sizeof(uint8_t); 4423 xcb_tmp += xcb_block_len; 4424 xcb_align_to = ALIGNOF(uint8_t); 4425 /* insert padding */ 4426 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4427 xcb_buffer_len += xcb_block_len + xcb_pad; 4428 if (0 != xcb_pad) { 4429 xcb_tmp += xcb_pad; 4430 xcb_pad = 0; 4431 } 4432 xcb_block_len = 0; 4433 4434 return xcb_buffer_len; 4435} 4436 4437xcb_glx_get_booleanv_cookie_t 4438xcb_glx_get_booleanv (xcb_connection_t *c, 4439 xcb_glx_context_tag_t context_tag, 4440 int32_t pname) 4441{ 4442 static const xcb_protocol_request_t xcb_req = { 4443 .count = 2, 4444 .ext = &xcb_glx_id, 4445 .opcode = XCB_GLX_GET_BOOLEANV, 4446 .isvoid = 0 4447 }; 4448 4449 struct iovec xcb_parts[4]; 4450 xcb_glx_get_booleanv_cookie_t xcb_ret; 4451 xcb_glx_get_booleanv_request_t xcb_out; 4452 4453 xcb_out.context_tag = context_tag; 4454 xcb_out.pname = pname; 4455 4456 xcb_parts[2].iov_base = (char *) &xcb_out; 4457 xcb_parts[2].iov_len = sizeof(xcb_out); 4458 xcb_parts[3].iov_base = 0; 4459 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4460 4461 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4462 return xcb_ret; 4463} 4464 4465xcb_glx_get_booleanv_cookie_t 4466xcb_glx_get_booleanv_unchecked (xcb_connection_t *c, 4467 xcb_glx_context_tag_t context_tag, 4468 int32_t pname) 4469{ 4470 static const xcb_protocol_request_t xcb_req = { 4471 .count = 2, 4472 .ext = &xcb_glx_id, 4473 .opcode = XCB_GLX_GET_BOOLEANV, 4474 .isvoid = 0 4475 }; 4476 4477 struct iovec xcb_parts[4]; 4478 xcb_glx_get_booleanv_cookie_t xcb_ret; 4479 xcb_glx_get_booleanv_request_t xcb_out; 4480 4481 xcb_out.context_tag = context_tag; 4482 xcb_out.pname = pname; 4483 4484 xcb_parts[2].iov_base = (char *) &xcb_out; 4485 xcb_parts[2].iov_len = sizeof(xcb_out); 4486 xcb_parts[3].iov_base = 0; 4487 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4488 4489 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4490 return xcb_ret; 4491} 4492 4493uint8_t * 4494xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R) 4495{ 4496 return (uint8_t *) (R + 1); 4497} 4498 4499int 4500xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R) 4501{ 4502 return R->n; 4503} 4504 4505xcb_generic_iterator_t 4506xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R) 4507{ 4508 xcb_generic_iterator_t i; 4509 i.data = ((uint8_t *) (R + 1)) + (R->n); 4510 i.rem = 0; 4511 i.index = (char *) i.data - (char *) R; 4512 return i; 4513} 4514 4515xcb_glx_get_booleanv_reply_t * 4516xcb_glx_get_booleanv_reply (xcb_connection_t *c, 4517 xcb_glx_get_booleanv_cookie_t cookie /**< */, 4518 xcb_generic_error_t **e) 4519{ 4520 return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4521} 4522 4523int 4524xcb_glx_get_clip_plane_sizeof (const void *_buffer) 4525{ 4526 char *xcb_tmp = (char *)_buffer; 4527 const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer; 4528 unsigned int xcb_buffer_len = 0; 4529 unsigned int xcb_block_len = 0; 4530 unsigned int xcb_pad = 0; 4531 unsigned int xcb_align_to = 0; 4532 4533 4534 xcb_block_len += sizeof(xcb_glx_get_clip_plane_reply_t); 4535 xcb_tmp += xcb_block_len; 4536 xcb_buffer_len += xcb_block_len; 4537 xcb_block_len = 0; 4538 /* data */ 4539 xcb_block_len += (_aux->length / 2) * sizeof(xcb_glx_float64_t); 4540 xcb_tmp += xcb_block_len; 4541 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 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 4554xcb_glx_get_clip_plane_cookie_t 4555xcb_glx_get_clip_plane (xcb_connection_t *c, 4556 xcb_glx_context_tag_t context_tag, 4557 int32_t plane) 4558{ 4559 static const xcb_protocol_request_t xcb_req = { 4560 .count = 2, 4561 .ext = &xcb_glx_id, 4562 .opcode = XCB_GLX_GET_CLIP_PLANE, 4563 .isvoid = 0 4564 }; 4565 4566 struct iovec xcb_parts[4]; 4567 xcb_glx_get_clip_plane_cookie_t xcb_ret; 4568 xcb_glx_get_clip_plane_request_t xcb_out; 4569 4570 xcb_out.context_tag = context_tag; 4571 xcb_out.plane = plane; 4572 4573 xcb_parts[2].iov_base = (char *) &xcb_out; 4574 xcb_parts[2].iov_len = sizeof(xcb_out); 4575 xcb_parts[3].iov_base = 0; 4576 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4577 4578 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4579 return xcb_ret; 4580} 4581 4582xcb_glx_get_clip_plane_cookie_t 4583xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c, 4584 xcb_glx_context_tag_t context_tag, 4585 int32_t plane) 4586{ 4587 static const xcb_protocol_request_t xcb_req = { 4588 .count = 2, 4589 .ext = &xcb_glx_id, 4590 .opcode = XCB_GLX_GET_CLIP_PLANE, 4591 .isvoid = 0 4592 }; 4593 4594 struct iovec xcb_parts[4]; 4595 xcb_glx_get_clip_plane_cookie_t xcb_ret; 4596 xcb_glx_get_clip_plane_request_t xcb_out; 4597 4598 xcb_out.context_tag = context_tag; 4599 xcb_out.plane = plane; 4600 4601 xcb_parts[2].iov_base = (char *) &xcb_out; 4602 xcb_parts[2].iov_len = sizeof(xcb_out); 4603 xcb_parts[3].iov_base = 0; 4604 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4605 4606 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4607 return xcb_ret; 4608} 4609 4610xcb_glx_float64_t * 4611xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R) 4612{ 4613 return (xcb_glx_float64_t *) (R + 1); 4614} 4615 4616int 4617xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R) 4618{ 4619 return (R->length / 2); 4620} 4621 4622xcb_generic_iterator_t 4623xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R) 4624{ 4625 xcb_generic_iterator_t i; 4626 i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2)); 4627 i.rem = 0; 4628 i.index = (char *) i.data - (char *) R; 4629 return i; 4630} 4631 4632xcb_glx_get_clip_plane_reply_t * 4633xcb_glx_get_clip_plane_reply (xcb_connection_t *c, 4634 xcb_glx_get_clip_plane_cookie_t cookie /**< */, 4635 xcb_generic_error_t **e) 4636{ 4637 return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4638} 4639 4640int 4641xcb_glx_get_doublev_sizeof (const void *_buffer) 4642{ 4643 char *xcb_tmp = (char *)_buffer; 4644 const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer; 4645 unsigned int xcb_buffer_len = 0; 4646 unsigned int xcb_block_len = 0; 4647 unsigned int xcb_pad = 0; 4648 unsigned int xcb_align_to = 0; 4649 4650 4651 xcb_block_len += sizeof(xcb_glx_get_doublev_reply_t); 4652 xcb_tmp += xcb_block_len; 4653 xcb_buffer_len += xcb_block_len; 4654 xcb_block_len = 0; 4655 /* data */ 4656 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 4657 xcb_tmp += xcb_block_len; 4658 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 4659 /* insert padding */ 4660 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4661 xcb_buffer_len += xcb_block_len + xcb_pad; 4662 if (0 != xcb_pad) { 4663 xcb_tmp += xcb_pad; 4664 xcb_pad = 0; 4665 } 4666 xcb_block_len = 0; 4667 4668 return xcb_buffer_len; 4669} 4670 4671xcb_glx_get_doublev_cookie_t 4672xcb_glx_get_doublev (xcb_connection_t *c, 4673 xcb_glx_context_tag_t context_tag, 4674 uint32_t pname) 4675{ 4676 static const xcb_protocol_request_t xcb_req = { 4677 .count = 2, 4678 .ext = &xcb_glx_id, 4679 .opcode = XCB_GLX_GET_DOUBLEV, 4680 .isvoid = 0 4681 }; 4682 4683 struct iovec xcb_parts[4]; 4684 xcb_glx_get_doublev_cookie_t xcb_ret; 4685 xcb_glx_get_doublev_request_t xcb_out; 4686 4687 xcb_out.context_tag = context_tag; 4688 xcb_out.pname = pname; 4689 4690 xcb_parts[2].iov_base = (char *) &xcb_out; 4691 xcb_parts[2].iov_len = sizeof(xcb_out); 4692 xcb_parts[3].iov_base = 0; 4693 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4694 4695 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4696 return xcb_ret; 4697} 4698 4699xcb_glx_get_doublev_cookie_t 4700xcb_glx_get_doublev_unchecked (xcb_connection_t *c, 4701 xcb_glx_context_tag_t context_tag, 4702 uint32_t pname) 4703{ 4704 static const xcb_protocol_request_t xcb_req = { 4705 .count = 2, 4706 .ext = &xcb_glx_id, 4707 .opcode = XCB_GLX_GET_DOUBLEV, 4708 .isvoid = 0 4709 }; 4710 4711 struct iovec xcb_parts[4]; 4712 xcb_glx_get_doublev_cookie_t xcb_ret; 4713 xcb_glx_get_doublev_request_t xcb_out; 4714 4715 xcb_out.context_tag = context_tag; 4716 xcb_out.pname = pname; 4717 4718 xcb_parts[2].iov_base = (char *) &xcb_out; 4719 xcb_parts[2].iov_len = sizeof(xcb_out); 4720 xcb_parts[3].iov_base = 0; 4721 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4722 4723 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4724 return xcb_ret; 4725} 4726 4727xcb_glx_float64_t * 4728xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R) 4729{ 4730 return (xcb_glx_float64_t *) (R + 1); 4731} 4732 4733int 4734xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R) 4735{ 4736 return R->n; 4737} 4738 4739xcb_generic_iterator_t 4740xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R) 4741{ 4742 xcb_generic_iterator_t i; 4743 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 4744 i.rem = 0; 4745 i.index = (char *) i.data - (char *) R; 4746 return i; 4747} 4748 4749xcb_glx_get_doublev_reply_t * 4750xcb_glx_get_doublev_reply (xcb_connection_t *c, 4751 xcb_glx_get_doublev_cookie_t cookie /**< */, 4752 xcb_generic_error_t **e) 4753{ 4754 return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4755} 4756 4757xcb_glx_get_error_cookie_t 4758xcb_glx_get_error (xcb_connection_t *c, 4759 xcb_glx_context_tag_t context_tag) 4760{ 4761 static const xcb_protocol_request_t xcb_req = { 4762 .count = 2, 4763 .ext = &xcb_glx_id, 4764 .opcode = XCB_GLX_GET_ERROR, 4765 .isvoid = 0 4766 }; 4767 4768 struct iovec xcb_parts[4]; 4769 xcb_glx_get_error_cookie_t xcb_ret; 4770 xcb_glx_get_error_request_t xcb_out; 4771 4772 xcb_out.context_tag = context_tag; 4773 4774 xcb_parts[2].iov_base = (char *) &xcb_out; 4775 xcb_parts[2].iov_len = sizeof(xcb_out); 4776 xcb_parts[3].iov_base = 0; 4777 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4778 4779 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4780 return xcb_ret; 4781} 4782 4783xcb_glx_get_error_cookie_t 4784xcb_glx_get_error_unchecked (xcb_connection_t *c, 4785 xcb_glx_context_tag_t context_tag) 4786{ 4787 static const xcb_protocol_request_t xcb_req = { 4788 .count = 2, 4789 .ext = &xcb_glx_id, 4790 .opcode = XCB_GLX_GET_ERROR, 4791 .isvoid = 0 4792 }; 4793 4794 struct iovec xcb_parts[4]; 4795 xcb_glx_get_error_cookie_t xcb_ret; 4796 xcb_glx_get_error_request_t xcb_out; 4797 4798 xcb_out.context_tag = context_tag; 4799 4800 xcb_parts[2].iov_base = (char *) &xcb_out; 4801 xcb_parts[2].iov_len = sizeof(xcb_out); 4802 xcb_parts[3].iov_base = 0; 4803 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4804 4805 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4806 return xcb_ret; 4807} 4808 4809xcb_glx_get_error_reply_t * 4810xcb_glx_get_error_reply (xcb_connection_t *c, 4811 xcb_glx_get_error_cookie_t cookie /**< */, 4812 xcb_generic_error_t **e) 4813{ 4814 return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4815} 4816 4817int 4818xcb_glx_get_floatv_sizeof (const void *_buffer) 4819{ 4820 char *xcb_tmp = (char *)_buffer; 4821 const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer; 4822 unsigned int xcb_buffer_len = 0; 4823 unsigned int xcb_block_len = 0; 4824 unsigned int xcb_pad = 0; 4825 unsigned int xcb_align_to = 0; 4826 4827 4828 xcb_block_len += sizeof(xcb_glx_get_floatv_reply_t); 4829 xcb_tmp += xcb_block_len; 4830 xcb_buffer_len += xcb_block_len; 4831 xcb_block_len = 0; 4832 /* data */ 4833 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 4834 xcb_tmp += xcb_block_len; 4835 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 4836 /* insert padding */ 4837 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4838 xcb_buffer_len += xcb_block_len + xcb_pad; 4839 if (0 != xcb_pad) { 4840 xcb_tmp += xcb_pad; 4841 xcb_pad = 0; 4842 } 4843 xcb_block_len = 0; 4844 4845 return xcb_buffer_len; 4846} 4847 4848xcb_glx_get_floatv_cookie_t 4849xcb_glx_get_floatv (xcb_connection_t *c, 4850 xcb_glx_context_tag_t context_tag, 4851 uint32_t pname) 4852{ 4853 static const xcb_protocol_request_t xcb_req = { 4854 .count = 2, 4855 .ext = &xcb_glx_id, 4856 .opcode = XCB_GLX_GET_FLOATV, 4857 .isvoid = 0 4858 }; 4859 4860 struct iovec xcb_parts[4]; 4861 xcb_glx_get_floatv_cookie_t xcb_ret; 4862 xcb_glx_get_floatv_request_t xcb_out; 4863 4864 xcb_out.context_tag = context_tag; 4865 xcb_out.pname = pname; 4866 4867 xcb_parts[2].iov_base = (char *) &xcb_out; 4868 xcb_parts[2].iov_len = sizeof(xcb_out); 4869 xcb_parts[3].iov_base = 0; 4870 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4871 4872 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4873 return xcb_ret; 4874} 4875 4876xcb_glx_get_floatv_cookie_t 4877xcb_glx_get_floatv_unchecked (xcb_connection_t *c, 4878 xcb_glx_context_tag_t context_tag, 4879 uint32_t pname) 4880{ 4881 static const xcb_protocol_request_t xcb_req = { 4882 .count = 2, 4883 .ext = &xcb_glx_id, 4884 .opcode = XCB_GLX_GET_FLOATV, 4885 .isvoid = 0 4886 }; 4887 4888 struct iovec xcb_parts[4]; 4889 xcb_glx_get_floatv_cookie_t xcb_ret; 4890 xcb_glx_get_floatv_request_t xcb_out; 4891 4892 xcb_out.context_tag = context_tag; 4893 xcb_out.pname = pname; 4894 4895 xcb_parts[2].iov_base = (char *) &xcb_out; 4896 xcb_parts[2].iov_len = sizeof(xcb_out); 4897 xcb_parts[3].iov_base = 0; 4898 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4899 4900 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4901 return xcb_ret; 4902} 4903 4904xcb_glx_float32_t * 4905xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R) 4906{ 4907 return (xcb_glx_float32_t *) (R + 1); 4908} 4909 4910int 4911xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R) 4912{ 4913 return R->n; 4914} 4915 4916xcb_generic_iterator_t 4917xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R) 4918{ 4919 xcb_generic_iterator_t i; 4920 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 4921 i.rem = 0; 4922 i.index = (char *) i.data - (char *) R; 4923 return i; 4924} 4925 4926xcb_glx_get_floatv_reply_t * 4927xcb_glx_get_floatv_reply (xcb_connection_t *c, 4928 xcb_glx_get_floatv_cookie_t cookie /**< */, 4929 xcb_generic_error_t **e) 4930{ 4931 return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4932} 4933 4934int 4935xcb_glx_get_integerv_sizeof (const void *_buffer) 4936{ 4937 char *xcb_tmp = (char *)_buffer; 4938 const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer; 4939 unsigned int xcb_buffer_len = 0; 4940 unsigned int xcb_block_len = 0; 4941 unsigned int xcb_pad = 0; 4942 unsigned int xcb_align_to = 0; 4943 4944 4945 xcb_block_len += sizeof(xcb_glx_get_integerv_reply_t); 4946 xcb_tmp += xcb_block_len; 4947 xcb_buffer_len += xcb_block_len; 4948 xcb_block_len = 0; 4949 /* data */ 4950 xcb_block_len += _aux->n * sizeof(int32_t); 4951 xcb_tmp += xcb_block_len; 4952 xcb_align_to = ALIGNOF(int32_t); 4953 /* insert padding */ 4954 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4955 xcb_buffer_len += xcb_block_len + xcb_pad; 4956 if (0 != xcb_pad) { 4957 xcb_tmp += xcb_pad; 4958 xcb_pad = 0; 4959 } 4960 xcb_block_len = 0; 4961 4962 return xcb_buffer_len; 4963} 4964 4965xcb_glx_get_integerv_cookie_t 4966xcb_glx_get_integerv (xcb_connection_t *c, 4967 xcb_glx_context_tag_t context_tag, 4968 uint32_t pname) 4969{ 4970 static const xcb_protocol_request_t xcb_req = { 4971 .count = 2, 4972 .ext = &xcb_glx_id, 4973 .opcode = XCB_GLX_GET_INTEGERV, 4974 .isvoid = 0 4975 }; 4976 4977 struct iovec xcb_parts[4]; 4978 xcb_glx_get_integerv_cookie_t xcb_ret; 4979 xcb_glx_get_integerv_request_t xcb_out; 4980 4981 xcb_out.context_tag = context_tag; 4982 xcb_out.pname = pname; 4983 4984 xcb_parts[2].iov_base = (char *) &xcb_out; 4985 xcb_parts[2].iov_len = sizeof(xcb_out); 4986 xcb_parts[3].iov_base = 0; 4987 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4988 4989 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4990 return xcb_ret; 4991} 4992 4993xcb_glx_get_integerv_cookie_t 4994xcb_glx_get_integerv_unchecked (xcb_connection_t *c, 4995 xcb_glx_context_tag_t context_tag, 4996 uint32_t pname) 4997{ 4998 static const xcb_protocol_request_t xcb_req = { 4999 .count = 2, 5000 .ext = &xcb_glx_id, 5001 .opcode = XCB_GLX_GET_INTEGERV, 5002 .isvoid = 0 5003 }; 5004 5005 struct iovec xcb_parts[4]; 5006 xcb_glx_get_integerv_cookie_t xcb_ret; 5007 xcb_glx_get_integerv_request_t xcb_out; 5008 5009 xcb_out.context_tag = context_tag; 5010 xcb_out.pname = pname; 5011 5012 xcb_parts[2].iov_base = (char *) &xcb_out; 5013 xcb_parts[2].iov_len = sizeof(xcb_out); 5014 xcb_parts[3].iov_base = 0; 5015 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5016 5017 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5018 return xcb_ret; 5019} 5020 5021int32_t * 5022xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R) 5023{ 5024 return (int32_t *) (R + 1); 5025} 5026 5027int 5028xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R) 5029{ 5030 return R->n; 5031} 5032 5033xcb_generic_iterator_t 5034xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R) 5035{ 5036 xcb_generic_iterator_t i; 5037 i.data = ((int32_t *) (R + 1)) + (R->n); 5038 i.rem = 0; 5039 i.index = (char *) i.data - (char *) R; 5040 return i; 5041} 5042 5043xcb_glx_get_integerv_reply_t * 5044xcb_glx_get_integerv_reply (xcb_connection_t *c, 5045 xcb_glx_get_integerv_cookie_t cookie /**< */, 5046 xcb_generic_error_t **e) 5047{ 5048 return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5049} 5050 5051int 5052xcb_glx_get_lightfv_sizeof (const void *_buffer) 5053{ 5054 char *xcb_tmp = (char *)_buffer; 5055 const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer; 5056 unsigned int xcb_buffer_len = 0; 5057 unsigned int xcb_block_len = 0; 5058 unsigned int xcb_pad = 0; 5059 unsigned int xcb_align_to = 0; 5060 5061 5062 xcb_block_len += sizeof(xcb_glx_get_lightfv_reply_t); 5063 xcb_tmp += xcb_block_len; 5064 xcb_buffer_len += xcb_block_len; 5065 xcb_block_len = 0; 5066 /* data */ 5067 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5068 xcb_tmp += xcb_block_len; 5069 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5070 /* insert padding */ 5071 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5072 xcb_buffer_len += xcb_block_len + xcb_pad; 5073 if (0 != xcb_pad) { 5074 xcb_tmp += xcb_pad; 5075 xcb_pad = 0; 5076 } 5077 xcb_block_len = 0; 5078 5079 return xcb_buffer_len; 5080} 5081 5082xcb_glx_get_lightfv_cookie_t 5083xcb_glx_get_lightfv (xcb_connection_t *c, 5084 xcb_glx_context_tag_t context_tag, 5085 uint32_t light, 5086 uint32_t pname) 5087{ 5088 static const xcb_protocol_request_t xcb_req = { 5089 .count = 2, 5090 .ext = &xcb_glx_id, 5091 .opcode = XCB_GLX_GET_LIGHTFV, 5092 .isvoid = 0 5093 }; 5094 5095 struct iovec xcb_parts[4]; 5096 xcb_glx_get_lightfv_cookie_t xcb_ret; 5097 xcb_glx_get_lightfv_request_t xcb_out; 5098 5099 xcb_out.context_tag = context_tag; 5100 xcb_out.light = light; 5101 xcb_out.pname = pname; 5102 5103 xcb_parts[2].iov_base = (char *) &xcb_out; 5104 xcb_parts[2].iov_len = sizeof(xcb_out); 5105 xcb_parts[3].iov_base = 0; 5106 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5107 5108 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5109 return xcb_ret; 5110} 5111 5112xcb_glx_get_lightfv_cookie_t 5113xcb_glx_get_lightfv_unchecked (xcb_connection_t *c, 5114 xcb_glx_context_tag_t context_tag, 5115 uint32_t light, 5116 uint32_t pname) 5117{ 5118 static const xcb_protocol_request_t xcb_req = { 5119 .count = 2, 5120 .ext = &xcb_glx_id, 5121 .opcode = XCB_GLX_GET_LIGHTFV, 5122 .isvoid = 0 5123 }; 5124 5125 struct iovec xcb_parts[4]; 5126 xcb_glx_get_lightfv_cookie_t xcb_ret; 5127 xcb_glx_get_lightfv_request_t xcb_out; 5128 5129 xcb_out.context_tag = context_tag; 5130 xcb_out.light = light; 5131 xcb_out.pname = pname; 5132 5133 xcb_parts[2].iov_base = (char *) &xcb_out; 5134 xcb_parts[2].iov_len = sizeof(xcb_out); 5135 xcb_parts[3].iov_base = 0; 5136 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5137 5138 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5139 return xcb_ret; 5140} 5141 5142xcb_glx_float32_t * 5143xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R) 5144{ 5145 return (xcb_glx_float32_t *) (R + 1); 5146} 5147 5148int 5149xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R) 5150{ 5151 return R->n; 5152} 5153 5154xcb_generic_iterator_t 5155xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R) 5156{ 5157 xcb_generic_iterator_t i; 5158 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5159 i.rem = 0; 5160 i.index = (char *) i.data - (char *) R; 5161 return i; 5162} 5163 5164xcb_glx_get_lightfv_reply_t * 5165xcb_glx_get_lightfv_reply (xcb_connection_t *c, 5166 xcb_glx_get_lightfv_cookie_t cookie /**< */, 5167 xcb_generic_error_t **e) 5168{ 5169 return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5170} 5171 5172int 5173xcb_glx_get_lightiv_sizeof (const void *_buffer) 5174{ 5175 char *xcb_tmp = (char *)_buffer; 5176 const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer; 5177 unsigned int xcb_buffer_len = 0; 5178 unsigned int xcb_block_len = 0; 5179 unsigned int xcb_pad = 0; 5180 unsigned int xcb_align_to = 0; 5181 5182 5183 xcb_block_len += sizeof(xcb_glx_get_lightiv_reply_t); 5184 xcb_tmp += xcb_block_len; 5185 xcb_buffer_len += xcb_block_len; 5186 xcb_block_len = 0; 5187 /* data */ 5188 xcb_block_len += _aux->n * sizeof(int32_t); 5189 xcb_tmp += xcb_block_len; 5190 xcb_align_to = ALIGNOF(int32_t); 5191 /* insert padding */ 5192 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5193 xcb_buffer_len += xcb_block_len + xcb_pad; 5194 if (0 != xcb_pad) { 5195 xcb_tmp += xcb_pad; 5196 xcb_pad = 0; 5197 } 5198 xcb_block_len = 0; 5199 5200 return xcb_buffer_len; 5201} 5202 5203xcb_glx_get_lightiv_cookie_t 5204xcb_glx_get_lightiv (xcb_connection_t *c, 5205 xcb_glx_context_tag_t context_tag, 5206 uint32_t light, 5207 uint32_t pname) 5208{ 5209 static const xcb_protocol_request_t xcb_req = { 5210 .count = 2, 5211 .ext = &xcb_glx_id, 5212 .opcode = XCB_GLX_GET_LIGHTIV, 5213 .isvoid = 0 5214 }; 5215 5216 struct iovec xcb_parts[4]; 5217 xcb_glx_get_lightiv_cookie_t xcb_ret; 5218 xcb_glx_get_lightiv_request_t xcb_out; 5219 5220 xcb_out.context_tag = context_tag; 5221 xcb_out.light = light; 5222 xcb_out.pname = pname; 5223 5224 xcb_parts[2].iov_base = (char *) &xcb_out; 5225 xcb_parts[2].iov_len = sizeof(xcb_out); 5226 xcb_parts[3].iov_base = 0; 5227 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5228 5229 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5230 return xcb_ret; 5231} 5232 5233xcb_glx_get_lightiv_cookie_t 5234xcb_glx_get_lightiv_unchecked (xcb_connection_t *c, 5235 xcb_glx_context_tag_t context_tag, 5236 uint32_t light, 5237 uint32_t pname) 5238{ 5239 static const xcb_protocol_request_t xcb_req = { 5240 .count = 2, 5241 .ext = &xcb_glx_id, 5242 .opcode = XCB_GLX_GET_LIGHTIV, 5243 .isvoid = 0 5244 }; 5245 5246 struct iovec xcb_parts[4]; 5247 xcb_glx_get_lightiv_cookie_t xcb_ret; 5248 xcb_glx_get_lightiv_request_t xcb_out; 5249 5250 xcb_out.context_tag = context_tag; 5251 xcb_out.light = light; 5252 xcb_out.pname = pname; 5253 5254 xcb_parts[2].iov_base = (char *) &xcb_out; 5255 xcb_parts[2].iov_len = sizeof(xcb_out); 5256 xcb_parts[3].iov_base = 0; 5257 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5258 5259 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5260 return xcb_ret; 5261} 5262 5263int32_t * 5264xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R) 5265{ 5266 return (int32_t *) (R + 1); 5267} 5268 5269int 5270xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R) 5271{ 5272 return R->n; 5273} 5274 5275xcb_generic_iterator_t 5276xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R) 5277{ 5278 xcb_generic_iterator_t i; 5279 i.data = ((int32_t *) (R + 1)) + (R->n); 5280 i.rem = 0; 5281 i.index = (char *) i.data - (char *) R; 5282 return i; 5283} 5284 5285xcb_glx_get_lightiv_reply_t * 5286xcb_glx_get_lightiv_reply (xcb_connection_t *c, 5287 xcb_glx_get_lightiv_cookie_t cookie /**< */, 5288 xcb_generic_error_t **e) 5289{ 5290 return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5291} 5292 5293int 5294xcb_glx_get_mapdv_sizeof (const void *_buffer) 5295{ 5296 char *xcb_tmp = (char *)_buffer; 5297 const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer; 5298 unsigned int xcb_buffer_len = 0; 5299 unsigned int xcb_block_len = 0; 5300 unsigned int xcb_pad = 0; 5301 unsigned int xcb_align_to = 0; 5302 5303 5304 xcb_block_len += sizeof(xcb_glx_get_mapdv_reply_t); 5305 xcb_tmp += xcb_block_len; 5306 xcb_buffer_len += xcb_block_len; 5307 xcb_block_len = 0; 5308 /* data */ 5309 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 5310 xcb_tmp += xcb_block_len; 5311 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 5312 /* insert padding */ 5313 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5314 xcb_buffer_len += xcb_block_len + xcb_pad; 5315 if (0 != xcb_pad) { 5316 xcb_tmp += xcb_pad; 5317 xcb_pad = 0; 5318 } 5319 xcb_block_len = 0; 5320 5321 return xcb_buffer_len; 5322} 5323 5324xcb_glx_get_mapdv_cookie_t 5325xcb_glx_get_mapdv (xcb_connection_t *c, 5326 xcb_glx_context_tag_t context_tag, 5327 uint32_t target, 5328 uint32_t query) 5329{ 5330 static const xcb_protocol_request_t xcb_req = { 5331 .count = 2, 5332 .ext = &xcb_glx_id, 5333 .opcode = XCB_GLX_GET_MAPDV, 5334 .isvoid = 0 5335 }; 5336 5337 struct iovec xcb_parts[4]; 5338 xcb_glx_get_mapdv_cookie_t xcb_ret; 5339 xcb_glx_get_mapdv_request_t xcb_out; 5340 5341 xcb_out.context_tag = context_tag; 5342 xcb_out.target = target; 5343 xcb_out.query = query; 5344 5345 xcb_parts[2].iov_base = (char *) &xcb_out; 5346 xcb_parts[2].iov_len = sizeof(xcb_out); 5347 xcb_parts[3].iov_base = 0; 5348 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5349 5350 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5351 return xcb_ret; 5352} 5353 5354xcb_glx_get_mapdv_cookie_t 5355xcb_glx_get_mapdv_unchecked (xcb_connection_t *c, 5356 xcb_glx_context_tag_t context_tag, 5357 uint32_t target, 5358 uint32_t query) 5359{ 5360 static const xcb_protocol_request_t xcb_req = { 5361 .count = 2, 5362 .ext = &xcb_glx_id, 5363 .opcode = XCB_GLX_GET_MAPDV, 5364 .isvoid = 0 5365 }; 5366 5367 struct iovec xcb_parts[4]; 5368 xcb_glx_get_mapdv_cookie_t xcb_ret; 5369 xcb_glx_get_mapdv_request_t xcb_out; 5370 5371 xcb_out.context_tag = context_tag; 5372 xcb_out.target = target; 5373 xcb_out.query = query; 5374 5375 xcb_parts[2].iov_base = (char *) &xcb_out; 5376 xcb_parts[2].iov_len = sizeof(xcb_out); 5377 xcb_parts[3].iov_base = 0; 5378 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5379 5380 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5381 return xcb_ret; 5382} 5383 5384xcb_glx_float64_t * 5385xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R) 5386{ 5387 return (xcb_glx_float64_t *) (R + 1); 5388} 5389 5390int 5391xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R) 5392{ 5393 return R->n; 5394} 5395 5396xcb_generic_iterator_t 5397xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R) 5398{ 5399 xcb_generic_iterator_t i; 5400 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 5401 i.rem = 0; 5402 i.index = (char *) i.data - (char *) R; 5403 return i; 5404} 5405 5406xcb_glx_get_mapdv_reply_t * 5407xcb_glx_get_mapdv_reply (xcb_connection_t *c, 5408 xcb_glx_get_mapdv_cookie_t cookie /**< */, 5409 xcb_generic_error_t **e) 5410{ 5411 return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5412} 5413 5414int 5415xcb_glx_get_mapfv_sizeof (const void *_buffer) 5416{ 5417 char *xcb_tmp = (char *)_buffer; 5418 const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer; 5419 unsigned int xcb_buffer_len = 0; 5420 unsigned int xcb_block_len = 0; 5421 unsigned int xcb_pad = 0; 5422 unsigned int xcb_align_to = 0; 5423 5424 5425 xcb_block_len += sizeof(xcb_glx_get_mapfv_reply_t); 5426 xcb_tmp += xcb_block_len; 5427 xcb_buffer_len += xcb_block_len; 5428 xcb_block_len = 0; 5429 /* data */ 5430 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5431 xcb_tmp += xcb_block_len; 5432 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5433 /* insert padding */ 5434 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5435 xcb_buffer_len += xcb_block_len + xcb_pad; 5436 if (0 != xcb_pad) { 5437 xcb_tmp += xcb_pad; 5438 xcb_pad = 0; 5439 } 5440 xcb_block_len = 0; 5441 5442 return xcb_buffer_len; 5443} 5444 5445xcb_glx_get_mapfv_cookie_t 5446xcb_glx_get_mapfv (xcb_connection_t *c, 5447 xcb_glx_context_tag_t context_tag, 5448 uint32_t target, 5449 uint32_t query) 5450{ 5451 static const xcb_protocol_request_t xcb_req = { 5452 .count = 2, 5453 .ext = &xcb_glx_id, 5454 .opcode = XCB_GLX_GET_MAPFV, 5455 .isvoid = 0 5456 }; 5457 5458 struct iovec xcb_parts[4]; 5459 xcb_glx_get_mapfv_cookie_t xcb_ret; 5460 xcb_glx_get_mapfv_request_t xcb_out; 5461 5462 xcb_out.context_tag = context_tag; 5463 xcb_out.target = target; 5464 xcb_out.query = query; 5465 5466 xcb_parts[2].iov_base = (char *) &xcb_out; 5467 xcb_parts[2].iov_len = sizeof(xcb_out); 5468 xcb_parts[3].iov_base = 0; 5469 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5470 5471 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5472 return xcb_ret; 5473} 5474 5475xcb_glx_get_mapfv_cookie_t 5476xcb_glx_get_mapfv_unchecked (xcb_connection_t *c, 5477 xcb_glx_context_tag_t context_tag, 5478 uint32_t target, 5479 uint32_t query) 5480{ 5481 static const xcb_protocol_request_t xcb_req = { 5482 .count = 2, 5483 .ext = &xcb_glx_id, 5484 .opcode = XCB_GLX_GET_MAPFV, 5485 .isvoid = 0 5486 }; 5487 5488 struct iovec xcb_parts[4]; 5489 xcb_glx_get_mapfv_cookie_t xcb_ret; 5490 xcb_glx_get_mapfv_request_t xcb_out; 5491 5492 xcb_out.context_tag = context_tag; 5493 xcb_out.target = target; 5494 xcb_out.query = query; 5495 5496 xcb_parts[2].iov_base = (char *) &xcb_out; 5497 xcb_parts[2].iov_len = sizeof(xcb_out); 5498 xcb_parts[3].iov_base = 0; 5499 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5500 5501 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5502 return xcb_ret; 5503} 5504 5505xcb_glx_float32_t * 5506xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R) 5507{ 5508 return (xcb_glx_float32_t *) (R + 1); 5509} 5510 5511int 5512xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R) 5513{ 5514 return R->n; 5515} 5516 5517xcb_generic_iterator_t 5518xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R) 5519{ 5520 xcb_generic_iterator_t i; 5521 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5522 i.rem = 0; 5523 i.index = (char *) i.data - (char *) R; 5524 return i; 5525} 5526 5527xcb_glx_get_mapfv_reply_t * 5528xcb_glx_get_mapfv_reply (xcb_connection_t *c, 5529 xcb_glx_get_mapfv_cookie_t cookie /**< */, 5530 xcb_generic_error_t **e) 5531{ 5532 return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5533} 5534 5535int 5536xcb_glx_get_mapiv_sizeof (const void *_buffer) 5537{ 5538 char *xcb_tmp = (char *)_buffer; 5539 const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer; 5540 unsigned int xcb_buffer_len = 0; 5541 unsigned int xcb_block_len = 0; 5542 unsigned int xcb_pad = 0; 5543 unsigned int xcb_align_to = 0; 5544 5545 5546 xcb_block_len += sizeof(xcb_glx_get_mapiv_reply_t); 5547 xcb_tmp += xcb_block_len; 5548 xcb_buffer_len += xcb_block_len; 5549 xcb_block_len = 0; 5550 /* data */ 5551 xcb_block_len += _aux->n * sizeof(int32_t); 5552 xcb_tmp += xcb_block_len; 5553 xcb_align_to = ALIGNOF(int32_t); 5554 /* insert padding */ 5555 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5556 xcb_buffer_len += xcb_block_len + xcb_pad; 5557 if (0 != xcb_pad) { 5558 xcb_tmp += xcb_pad; 5559 xcb_pad = 0; 5560 } 5561 xcb_block_len = 0; 5562 5563 return xcb_buffer_len; 5564} 5565 5566xcb_glx_get_mapiv_cookie_t 5567xcb_glx_get_mapiv (xcb_connection_t *c, 5568 xcb_glx_context_tag_t context_tag, 5569 uint32_t target, 5570 uint32_t query) 5571{ 5572 static const xcb_protocol_request_t xcb_req = { 5573 .count = 2, 5574 .ext = &xcb_glx_id, 5575 .opcode = XCB_GLX_GET_MAPIV, 5576 .isvoid = 0 5577 }; 5578 5579 struct iovec xcb_parts[4]; 5580 xcb_glx_get_mapiv_cookie_t xcb_ret; 5581 xcb_glx_get_mapiv_request_t xcb_out; 5582 5583 xcb_out.context_tag = context_tag; 5584 xcb_out.target = target; 5585 xcb_out.query = query; 5586 5587 xcb_parts[2].iov_base = (char *) &xcb_out; 5588 xcb_parts[2].iov_len = sizeof(xcb_out); 5589 xcb_parts[3].iov_base = 0; 5590 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5591 5592 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5593 return xcb_ret; 5594} 5595 5596xcb_glx_get_mapiv_cookie_t 5597xcb_glx_get_mapiv_unchecked (xcb_connection_t *c, 5598 xcb_glx_context_tag_t context_tag, 5599 uint32_t target, 5600 uint32_t query) 5601{ 5602 static const xcb_protocol_request_t xcb_req = { 5603 .count = 2, 5604 .ext = &xcb_glx_id, 5605 .opcode = XCB_GLX_GET_MAPIV, 5606 .isvoid = 0 5607 }; 5608 5609 struct iovec xcb_parts[4]; 5610 xcb_glx_get_mapiv_cookie_t xcb_ret; 5611 xcb_glx_get_mapiv_request_t xcb_out; 5612 5613 xcb_out.context_tag = context_tag; 5614 xcb_out.target = target; 5615 xcb_out.query = query; 5616 5617 xcb_parts[2].iov_base = (char *) &xcb_out; 5618 xcb_parts[2].iov_len = sizeof(xcb_out); 5619 xcb_parts[3].iov_base = 0; 5620 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5621 5622 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5623 return xcb_ret; 5624} 5625 5626int32_t * 5627xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R) 5628{ 5629 return (int32_t *) (R + 1); 5630} 5631 5632int 5633xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R) 5634{ 5635 return R->n; 5636} 5637 5638xcb_generic_iterator_t 5639xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R) 5640{ 5641 xcb_generic_iterator_t i; 5642 i.data = ((int32_t *) (R + 1)) + (R->n); 5643 i.rem = 0; 5644 i.index = (char *) i.data - (char *) R; 5645 return i; 5646} 5647 5648xcb_glx_get_mapiv_reply_t * 5649xcb_glx_get_mapiv_reply (xcb_connection_t *c, 5650 xcb_glx_get_mapiv_cookie_t cookie /**< */, 5651 xcb_generic_error_t **e) 5652{ 5653 return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5654} 5655 5656int 5657xcb_glx_get_materialfv_sizeof (const void *_buffer) 5658{ 5659 char *xcb_tmp = (char *)_buffer; 5660 const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer; 5661 unsigned int xcb_buffer_len = 0; 5662 unsigned int xcb_block_len = 0; 5663 unsigned int xcb_pad = 0; 5664 unsigned int xcb_align_to = 0; 5665 5666 5667 xcb_block_len += sizeof(xcb_glx_get_materialfv_reply_t); 5668 xcb_tmp += xcb_block_len; 5669 xcb_buffer_len += xcb_block_len; 5670 xcb_block_len = 0; 5671 /* data */ 5672 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5673 xcb_tmp += xcb_block_len; 5674 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5675 /* insert padding */ 5676 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5677 xcb_buffer_len += xcb_block_len + xcb_pad; 5678 if (0 != xcb_pad) { 5679 xcb_tmp += xcb_pad; 5680 xcb_pad = 0; 5681 } 5682 xcb_block_len = 0; 5683 5684 return xcb_buffer_len; 5685} 5686 5687xcb_glx_get_materialfv_cookie_t 5688xcb_glx_get_materialfv (xcb_connection_t *c, 5689 xcb_glx_context_tag_t context_tag, 5690 uint32_t face, 5691 uint32_t pname) 5692{ 5693 static const xcb_protocol_request_t xcb_req = { 5694 .count = 2, 5695 .ext = &xcb_glx_id, 5696 .opcode = XCB_GLX_GET_MATERIALFV, 5697 .isvoid = 0 5698 }; 5699 5700 struct iovec xcb_parts[4]; 5701 xcb_glx_get_materialfv_cookie_t xcb_ret; 5702 xcb_glx_get_materialfv_request_t xcb_out; 5703 5704 xcb_out.context_tag = context_tag; 5705 xcb_out.face = face; 5706 xcb_out.pname = pname; 5707 5708 xcb_parts[2].iov_base = (char *) &xcb_out; 5709 xcb_parts[2].iov_len = sizeof(xcb_out); 5710 xcb_parts[3].iov_base = 0; 5711 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5712 5713 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5714 return xcb_ret; 5715} 5716 5717xcb_glx_get_materialfv_cookie_t 5718xcb_glx_get_materialfv_unchecked (xcb_connection_t *c, 5719 xcb_glx_context_tag_t context_tag, 5720 uint32_t face, 5721 uint32_t pname) 5722{ 5723 static const xcb_protocol_request_t xcb_req = { 5724 .count = 2, 5725 .ext = &xcb_glx_id, 5726 .opcode = XCB_GLX_GET_MATERIALFV, 5727 .isvoid = 0 5728 }; 5729 5730 struct iovec xcb_parts[4]; 5731 xcb_glx_get_materialfv_cookie_t xcb_ret; 5732 xcb_glx_get_materialfv_request_t xcb_out; 5733 5734 xcb_out.context_tag = context_tag; 5735 xcb_out.face = face; 5736 xcb_out.pname = pname; 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, 0, xcb_parts + 2, &xcb_req); 5744 return xcb_ret; 5745} 5746 5747xcb_glx_float32_t * 5748xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R) 5749{ 5750 return (xcb_glx_float32_t *) (R + 1); 5751} 5752 5753int 5754xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R) 5755{ 5756 return R->n; 5757} 5758 5759xcb_generic_iterator_t 5760xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R) 5761{ 5762 xcb_generic_iterator_t i; 5763 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5764 i.rem = 0; 5765 i.index = (char *) i.data - (char *) R; 5766 return i; 5767} 5768 5769xcb_glx_get_materialfv_reply_t * 5770xcb_glx_get_materialfv_reply (xcb_connection_t *c, 5771 xcb_glx_get_materialfv_cookie_t cookie /**< */, 5772 xcb_generic_error_t **e) 5773{ 5774 return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5775} 5776 5777int 5778xcb_glx_get_materialiv_sizeof (const void *_buffer) 5779{ 5780 char *xcb_tmp = (char *)_buffer; 5781 const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer; 5782 unsigned int xcb_buffer_len = 0; 5783 unsigned int xcb_block_len = 0; 5784 unsigned int xcb_pad = 0; 5785 unsigned int xcb_align_to = 0; 5786 5787 5788 xcb_block_len += sizeof(xcb_glx_get_materialiv_reply_t); 5789 xcb_tmp += xcb_block_len; 5790 xcb_buffer_len += xcb_block_len; 5791 xcb_block_len = 0; 5792 /* data */ 5793 xcb_block_len += _aux->n * sizeof(int32_t); 5794 xcb_tmp += xcb_block_len; 5795 xcb_align_to = ALIGNOF(int32_t); 5796 /* insert padding */ 5797 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5798 xcb_buffer_len += xcb_block_len + xcb_pad; 5799 if (0 != xcb_pad) { 5800 xcb_tmp += xcb_pad; 5801 xcb_pad = 0; 5802 } 5803 xcb_block_len = 0; 5804 5805 return xcb_buffer_len; 5806} 5807 5808xcb_glx_get_materialiv_cookie_t 5809xcb_glx_get_materialiv (xcb_connection_t *c, 5810 xcb_glx_context_tag_t context_tag, 5811 uint32_t face, 5812 uint32_t pname) 5813{ 5814 static const xcb_protocol_request_t xcb_req = { 5815 .count = 2, 5816 .ext = &xcb_glx_id, 5817 .opcode = XCB_GLX_GET_MATERIALIV, 5818 .isvoid = 0 5819 }; 5820 5821 struct iovec xcb_parts[4]; 5822 xcb_glx_get_materialiv_cookie_t xcb_ret; 5823 xcb_glx_get_materialiv_request_t xcb_out; 5824 5825 xcb_out.context_tag = context_tag; 5826 xcb_out.face = face; 5827 xcb_out.pname = pname; 5828 5829 xcb_parts[2].iov_base = (char *) &xcb_out; 5830 xcb_parts[2].iov_len = sizeof(xcb_out); 5831 xcb_parts[3].iov_base = 0; 5832 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5833 5834 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5835 return xcb_ret; 5836} 5837 5838xcb_glx_get_materialiv_cookie_t 5839xcb_glx_get_materialiv_unchecked (xcb_connection_t *c, 5840 xcb_glx_context_tag_t context_tag, 5841 uint32_t face, 5842 uint32_t pname) 5843{ 5844 static const xcb_protocol_request_t xcb_req = { 5845 .count = 2, 5846 .ext = &xcb_glx_id, 5847 .opcode = XCB_GLX_GET_MATERIALIV, 5848 .isvoid = 0 5849 }; 5850 5851 struct iovec xcb_parts[4]; 5852 xcb_glx_get_materialiv_cookie_t xcb_ret; 5853 xcb_glx_get_materialiv_request_t xcb_out; 5854 5855 xcb_out.context_tag = context_tag; 5856 xcb_out.face = face; 5857 xcb_out.pname = pname; 5858 5859 xcb_parts[2].iov_base = (char *) &xcb_out; 5860 xcb_parts[2].iov_len = sizeof(xcb_out); 5861 xcb_parts[3].iov_base = 0; 5862 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5863 5864 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5865 return xcb_ret; 5866} 5867 5868int32_t * 5869xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R) 5870{ 5871 return (int32_t *) (R + 1); 5872} 5873 5874int 5875xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R) 5876{ 5877 return R->n; 5878} 5879 5880xcb_generic_iterator_t 5881xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R) 5882{ 5883 xcb_generic_iterator_t i; 5884 i.data = ((int32_t *) (R + 1)) + (R->n); 5885 i.rem = 0; 5886 i.index = (char *) i.data - (char *) R; 5887 return i; 5888} 5889 5890xcb_glx_get_materialiv_reply_t * 5891xcb_glx_get_materialiv_reply (xcb_connection_t *c, 5892 xcb_glx_get_materialiv_cookie_t cookie /**< */, 5893 xcb_generic_error_t **e) 5894{ 5895 return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5896} 5897 5898int 5899xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer) 5900{ 5901 char *xcb_tmp = (char *)_buffer; 5902 const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer; 5903 unsigned int xcb_buffer_len = 0; 5904 unsigned int xcb_block_len = 0; 5905 unsigned int xcb_pad = 0; 5906 unsigned int xcb_align_to = 0; 5907 5908 5909 xcb_block_len += sizeof(xcb_glx_get_pixel_mapfv_reply_t); 5910 xcb_tmp += xcb_block_len; 5911 xcb_buffer_len += xcb_block_len; 5912 xcb_block_len = 0; 5913 /* data */ 5914 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5915 xcb_tmp += xcb_block_len; 5916 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5917 /* insert padding */ 5918 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5919 xcb_buffer_len += xcb_block_len + xcb_pad; 5920 if (0 != xcb_pad) { 5921 xcb_tmp += xcb_pad; 5922 xcb_pad = 0; 5923 } 5924 xcb_block_len = 0; 5925 5926 return xcb_buffer_len; 5927} 5928 5929xcb_glx_get_pixel_mapfv_cookie_t 5930xcb_glx_get_pixel_mapfv (xcb_connection_t *c, 5931 xcb_glx_context_tag_t context_tag, 5932 uint32_t map) 5933{ 5934 static const xcb_protocol_request_t xcb_req = { 5935 .count = 2, 5936 .ext = &xcb_glx_id, 5937 .opcode = XCB_GLX_GET_PIXEL_MAPFV, 5938 .isvoid = 0 5939 }; 5940 5941 struct iovec xcb_parts[4]; 5942 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 5943 xcb_glx_get_pixel_mapfv_request_t xcb_out; 5944 5945 xcb_out.context_tag = context_tag; 5946 xcb_out.map = map; 5947 5948 xcb_parts[2].iov_base = (char *) &xcb_out; 5949 xcb_parts[2].iov_len = sizeof(xcb_out); 5950 xcb_parts[3].iov_base = 0; 5951 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5952 5953 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5954 return xcb_ret; 5955} 5956 5957xcb_glx_get_pixel_mapfv_cookie_t 5958xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c, 5959 xcb_glx_context_tag_t context_tag, 5960 uint32_t map) 5961{ 5962 static const xcb_protocol_request_t xcb_req = { 5963 .count = 2, 5964 .ext = &xcb_glx_id, 5965 .opcode = XCB_GLX_GET_PIXEL_MAPFV, 5966 .isvoid = 0 5967 }; 5968 5969 struct iovec xcb_parts[4]; 5970 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 5971 xcb_glx_get_pixel_mapfv_request_t xcb_out; 5972 5973 xcb_out.context_tag = context_tag; 5974 xcb_out.map = map; 5975 5976 xcb_parts[2].iov_base = (char *) &xcb_out; 5977 xcb_parts[2].iov_len = sizeof(xcb_out); 5978 xcb_parts[3].iov_base = 0; 5979 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5980 5981 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5982 return xcb_ret; 5983} 5984 5985xcb_glx_float32_t * 5986xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R) 5987{ 5988 return (xcb_glx_float32_t *) (R + 1); 5989} 5990 5991int 5992xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R) 5993{ 5994 return R->n; 5995} 5996 5997xcb_generic_iterator_t 5998xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R) 5999{ 6000 xcb_generic_iterator_t i; 6001 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6002 i.rem = 0; 6003 i.index = (char *) i.data - (char *) R; 6004 return i; 6005} 6006 6007xcb_glx_get_pixel_mapfv_reply_t * 6008xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c, 6009 xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, 6010 xcb_generic_error_t **e) 6011{ 6012 return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6013} 6014 6015int 6016xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer) 6017{ 6018 char *xcb_tmp = (char *)_buffer; 6019 const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer; 6020 unsigned int xcb_buffer_len = 0; 6021 unsigned int xcb_block_len = 0; 6022 unsigned int xcb_pad = 0; 6023 unsigned int xcb_align_to = 0; 6024 6025 6026 xcb_block_len += sizeof(xcb_glx_get_pixel_mapuiv_reply_t); 6027 xcb_tmp += xcb_block_len; 6028 xcb_buffer_len += xcb_block_len; 6029 xcb_block_len = 0; 6030 /* data */ 6031 xcb_block_len += _aux->n * sizeof(uint32_t); 6032 xcb_tmp += xcb_block_len; 6033 xcb_align_to = ALIGNOF(uint32_t); 6034 /* insert padding */ 6035 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6036 xcb_buffer_len += xcb_block_len + xcb_pad; 6037 if (0 != xcb_pad) { 6038 xcb_tmp += xcb_pad; 6039 xcb_pad = 0; 6040 } 6041 xcb_block_len = 0; 6042 6043 return xcb_buffer_len; 6044} 6045 6046xcb_glx_get_pixel_mapuiv_cookie_t 6047xcb_glx_get_pixel_mapuiv (xcb_connection_t *c, 6048 xcb_glx_context_tag_t context_tag, 6049 uint32_t map) 6050{ 6051 static const xcb_protocol_request_t xcb_req = { 6052 .count = 2, 6053 .ext = &xcb_glx_id, 6054 .opcode = XCB_GLX_GET_PIXEL_MAPUIV, 6055 .isvoid = 0 6056 }; 6057 6058 struct iovec xcb_parts[4]; 6059 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 6060 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 6061 6062 xcb_out.context_tag = context_tag; 6063 xcb_out.map = map; 6064 6065 xcb_parts[2].iov_base = (char *) &xcb_out; 6066 xcb_parts[2].iov_len = sizeof(xcb_out); 6067 xcb_parts[3].iov_base = 0; 6068 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6069 6070 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6071 return xcb_ret; 6072} 6073 6074xcb_glx_get_pixel_mapuiv_cookie_t 6075xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c, 6076 xcb_glx_context_tag_t context_tag, 6077 uint32_t map) 6078{ 6079 static const xcb_protocol_request_t xcb_req = { 6080 .count = 2, 6081 .ext = &xcb_glx_id, 6082 .opcode = XCB_GLX_GET_PIXEL_MAPUIV, 6083 .isvoid = 0 6084 }; 6085 6086 struct iovec xcb_parts[4]; 6087 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 6088 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 6089 6090 xcb_out.context_tag = context_tag; 6091 xcb_out.map = map; 6092 6093 xcb_parts[2].iov_base = (char *) &xcb_out; 6094 xcb_parts[2].iov_len = sizeof(xcb_out); 6095 xcb_parts[3].iov_base = 0; 6096 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6097 6098 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6099 return xcb_ret; 6100} 6101 6102uint32_t * 6103xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6104{ 6105 return (uint32_t *) (R + 1); 6106} 6107 6108int 6109xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6110{ 6111 return R->n; 6112} 6113 6114xcb_generic_iterator_t 6115xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6116{ 6117 xcb_generic_iterator_t i; 6118 i.data = ((uint32_t *) (R + 1)) + (R->n); 6119 i.rem = 0; 6120 i.index = (char *) i.data - (char *) R; 6121 return i; 6122} 6123 6124xcb_glx_get_pixel_mapuiv_reply_t * 6125xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c, 6126 xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, 6127 xcb_generic_error_t **e) 6128{ 6129 return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6130} 6131 6132int 6133xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer) 6134{ 6135 char *xcb_tmp = (char *)_buffer; 6136 const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer; 6137 unsigned int xcb_buffer_len = 0; 6138 unsigned int xcb_block_len = 0; 6139 unsigned int xcb_pad = 0; 6140 unsigned int xcb_align_to = 0; 6141 6142 6143 xcb_block_len += sizeof(xcb_glx_get_pixel_mapusv_reply_t); 6144 xcb_tmp += xcb_block_len; 6145 xcb_buffer_len += xcb_block_len; 6146 xcb_block_len = 0; 6147 /* data */ 6148 xcb_block_len += _aux->n * sizeof(uint16_t); 6149 xcb_tmp += xcb_block_len; 6150 xcb_align_to = ALIGNOF(uint16_t); 6151 /* insert padding */ 6152 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6153 xcb_buffer_len += xcb_block_len + xcb_pad; 6154 if (0 != xcb_pad) { 6155 xcb_tmp += xcb_pad; 6156 xcb_pad = 0; 6157 } 6158 xcb_block_len = 0; 6159 6160 return xcb_buffer_len; 6161} 6162 6163xcb_glx_get_pixel_mapusv_cookie_t 6164xcb_glx_get_pixel_mapusv (xcb_connection_t *c, 6165 xcb_glx_context_tag_t context_tag, 6166 uint32_t map) 6167{ 6168 static const xcb_protocol_request_t xcb_req = { 6169 .count = 2, 6170 .ext = &xcb_glx_id, 6171 .opcode = XCB_GLX_GET_PIXEL_MAPUSV, 6172 .isvoid = 0 6173 }; 6174 6175 struct iovec xcb_parts[4]; 6176 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 6177 xcb_glx_get_pixel_mapusv_request_t xcb_out; 6178 6179 xcb_out.context_tag = context_tag; 6180 xcb_out.map = map; 6181 6182 xcb_parts[2].iov_base = (char *) &xcb_out; 6183 xcb_parts[2].iov_len = sizeof(xcb_out); 6184 xcb_parts[3].iov_base = 0; 6185 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6186 6187 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6188 return xcb_ret; 6189} 6190 6191xcb_glx_get_pixel_mapusv_cookie_t 6192xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c, 6193 xcb_glx_context_tag_t context_tag, 6194 uint32_t map) 6195{ 6196 static const xcb_protocol_request_t xcb_req = { 6197 .count = 2, 6198 .ext = &xcb_glx_id, 6199 .opcode = XCB_GLX_GET_PIXEL_MAPUSV, 6200 .isvoid = 0 6201 }; 6202 6203 struct iovec xcb_parts[4]; 6204 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 6205 xcb_glx_get_pixel_mapusv_request_t xcb_out; 6206 6207 xcb_out.context_tag = context_tag; 6208 xcb_out.map = map; 6209 6210 xcb_parts[2].iov_base = (char *) &xcb_out; 6211 xcb_parts[2].iov_len = sizeof(xcb_out); 6212 xcb_parts[3].iov_base = 0; 6213 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6214 6215 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6216 return xcb_ret; 6217} 6218 6219uint16_t * 6220xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R) 6221{ 6222 return (uint16_t *) (R + 1); 6223} 6224 6225int 6226xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R) 6227{ 6228 return R->n; 6229} 6230 6231xcb_generic_iterator_t 6232xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R) 6233{ 6234 xcb_generic_iterator_t i; 6235 i.data = ((uint16_t *) (R + 1)) + (R->n); 6236 i.rem = 0; 6237 i.index = (char *) i.data - (char *) R; 6238 return i; 6239} 6240 6241xcb_glx_get_pixel_mapusv_reply_t * 6242xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c, 6243 xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, 6244 xcb_generic_error_t **e) 6245{ 6246 return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6247} 6248 6249int 6250xcb_glx_get_polygon_stipple_sizeof (const void *_buffer) 6251{ 6252 char *xcb_tmp = (char *)_buffer; 6253 const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer; 6254 unsigned int xcb_buffer_len = 0; 6255 unsigned int xcb_block_len = 0; 6256 unsigned int xcb_pad = 0; 6257 unsigned int xcb_align_to = 0; 6258 6259 6260 xcb_block_len += sizeof(xcb_glx_get_polygon_stipple_reply_t); 6261 xcb_tmp += xcb_block_len; 6262 xcb_buffer_len += xcb_block_len; 6263 xcb_block_len = 0; 6264 /* data */ 6265 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 6266 xcb_tmp += xcb_block_len; 6267 xcb_align_to = ALIGNOF(uint8_t); 6268 /* insert padding */ 6269 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6270 xcb_buffer_len += xcb_block_len + xcb_pad; 6271 if (0 != xcb_pad) { 6272 xcb_tmp += xcb_pad; 6273 xcb_pad = 0; 6274 } 6275 xcb_block_len = 0; 6276 6277 return xcb_buffer_len; 6278} 6279 6280xcb_glx_get_polygon_stipple_cookie_t 6281xcb_glx_get_polygon_stipple (xcb_connection_t *c, 6282 xcb_glx_context_tag_t context_tag, 6283 uint8_t lsb_first) 6284{ 6285 static const xcb_protocol_request_t xcb_req = { 6286 .count = 2, 6287 .ext = &xcb_glx_id, 6288 .opcode = XCB_GLX_GET_POLYGON_STIPPLE, 6289 .isvoid = 0 6290 }; 6291 6292 struct iovec xcb_parts[4]; 6293 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 6294 xcb_glx_get_polygon_stipple_request_t xcb_out; 6295 6296 xcb_out.context_tag = context_tag; 6297 xcb_out.lsb_first = lsb_first; 6298 6299 xcb_parts[2].iov_base = (char *) &xcb_out; 6300 xcb_parts[2].iov_len = sizeof(xcb_out); 6301 xcb_parts[3].iov_base = 0; 6302 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6303 6304 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6305 return xcb_ret; 6306} 6307 6308xcb_glx_get_polygon_stipple_cookie_t 6309xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c, 6310 xcb_glx_context_tag_t context_tag, 6311 uint8_t lsb_first) 6312{ 6313 static const xcb_protocol_request_t xcb_req = { 6314 .count = 2, 6315 .ext = &xcb_glx_id, 6316 .opcode = XCB_GLX_GET_POLYGON_STIPPLE, 6317 .isvoid = 0 6318 }; 6319 6320 struct iovec xcb_parts[4]; 6321 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 6322 xcb_glx_get_polygon_stipple_request_t xcb_out; 6323 6324 xcb_out.context_tag = context_tag; 6325 xcb_out.lsb_first = lsb_first; 6326 6327 xcb_parts[2].iov_base = (char *) &xcb_out; 6328 xcb_parts[2].iov_len = sizeof(xcb_out); 6329 xcb_parts[3].iov_base = 0; 6330 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6331 6332 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6333 return xcb_ret; 6334} 6335 6336uint8_t * 6337xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R) 6338{ 6339 return (uint8_t *) (R + 1); 6340} 6341 6342int 6343xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R) 6344{ 6345 return (R->length * 4); 6346} 6347 6348xcb_generic_iterator_t 6349xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R) 6350{ 6351 xcb_generic_iterator_t i; 6352 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 6353 i.rem = 0; 6354 i.index = (char *) i.data - (char *) R; 6355 return i; 6356} 6357 6358xcb_glx_get_polygon_stipple_reply_t * 6359xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c, 6360 xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, 6361 xcb_generic_error_t **e) 6362{ 6363 return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6364} 6365 6366int 6367xcb_glx_get_string_sizeof (const void *_buffer) 6368{ 6369 char *xcb_tmp = (char *)_buffer; 6370 const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer; 6371 unsigned int xcb_buffer_len = 0; 6372 unsigned int xcb_block_len = 0; 6373 unsigned int xcb_pad = 0; 6374 unsigned int xcb_align_to = 0; 6375 6376 6377 xcb_block_len += sizeof(xcb_glx_get_string_reply_t); 6378 xcb_tmp += xcb_block_len; 6379 xcb_buffer_len += xcb_block_len; 6380 xcb_block_len = 0; 6381 /* string */ 6382 xcb_block_len += _aux->n * sizeof(char); 6383 xcb_tmp += xcb_block_len; 6384 xcb_align_to = ALIGNOF(char); 6385 /* insert padding */ 6386 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6387 xcb_buffer_len += xcb_block_len + xcb_pad; 6388 if (0 != xcb_pad) { 6389 xcb_tmp += xcb_pad; 6390 xcb_pad = 0; 6391 } 6392 xcb_block_len = 0; 6393 6394 return xcb_buffer_len; 6395} 6396 6397xcb_glx_get_string_cookie_t 6398xcb_glx_get_string (xcb_connection_t *c, 6399 xcb_glx_context_tag_t context_tag, 6400 uint32_t name) 6401{ 6402 static const xcb_protocol_request_t xcb_req = { 6403 .count = 2, 6404 .ext = &xcb_glx_id, 6405 .opcode = XCB_GLX_GET_STRING, 6406 .isvoid = 0 6407 }; 6408 6409 struct iovec xcb_parts[4]; 6410 xcb_glx_get_string_cookie_t xcb_ret; 6411 xcb_glx_get_string_request_t xcb_out; 6412 6413 xcb_out.context_tag = context_tag; 6414 xcb_out.name = name; 6415 6416 xcb_parts[2].iov_base = (char *) &xcb_out; 6417 xcb_parts[2].iov_len = sizeof(xcb_out); 6418 xcb_parts[3].iov_base = 0; 6419 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6420 6421 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6422 return xcb_ret; 6423} 6424 6425xcb_glx_get_string_cookie_t 6426xcb_glx_get_string_unchecked (xcb_connection_t *c, 6427 xcb_glx_context_tag_t context_tag, 6428 uint32_t name) 6429{ 6430 static const xcb_protocol_request_t xcb_req = { 6431 .count = 2, 6432 .ext = &xcb_glx_id, 6433 .opcode = XCB_GLX_GET_STRING, 6434 .isvoid = 0 6435 }; 6436 6437 struct iovec xcb_parts[4]; 6438 xcb_glx_get_string_cookie_t xcb_ret; 6439 xcb_glx_get_string_request_t xcb_out; 6440 6441 xcb_out.context_tag = context_tag; 6442 xcb_out.name = name; 6443 6444 xcb_parts[2].iov_base = (char *) &xcb_out; 6445 xcb_parts[2].iov_len = sizeof(xcb_out); 6446 xcb_parts[3].iov_base = 0; 6447 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6448 6449 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6450 return xcb_ret; 6451} 6452 6453char * 6454xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R) 6455{ 6456 return (char *) (R + 1); 6457} 6458 6459int 6460xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R) 6461{ 6462 return R->n; 6463} 6464 6465xcb_generic_iterator_t 6466xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R) 6467{ 6468 xcb_generic_iterator_t i; 6469 i.data = ((char *) (R + 1)) + (R->n); 6470 i.rem = 0; 6471 i.index = (char *) i.data - (char *) R; 6472 return i; 6473} 6474 6475xcb_glx_get_string_reply_t * 6476xcb_glx_get_string_reply (xcb_connection_t *c, 6477 xcb_glx_get_string_cookie_t cookie /**< */, 6478 xcb_generic_error_t **e) 6479{ 6480 return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6481} 6482 6483int 6484xcb_glx_get_tex_envfv_sizeof (const void *_buffer) 6485{ 6486 char *xcb_tmp = (char *)_buffer; 6487 const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer; 6488 unsigned int xcb_buffer_len = 0; 6489 unsigned int xcb_block_len = 0; 6490 unsigned int xcb_pad = 0; 6491 unsigned int xcb_align_to = 0; 6492 6493 6494 xcb_block_len += sizeof(xcb_glx_get_tex_envfv_reply_t); 6495 xcb_tmp += xcb_block_len; 6496 xcb_buffer_len += xcb_block_len; 6497 xcb_block_len = 0; 6498 /* data */ 6499 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6500 xcb_tmp += xcb_block_len; 6501 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6502 /* insert padding */ 6503 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6504 xcb_buffer_len += xcb_block_len + xcb_pad; 6505 if (0 != xcb_pad) { 6506 xcb_tmp += xcb_pad; 6507 xcb_pad = 0; 6508 } 6509 xcb_block_len = 0; 6510 6511 return xcb_buffer_len; 6512} 6513 6514xcb_glx_get_tex_envfv_cookie_t 6515xcb_glx_get_tex_envfv (xcb_connection_t *c, 6516 xcb_glx_context_tag_t context_tag, 6517 uint32_t target, 6518 uint32_t pname) 6519{ 6520 static const xcb_protocol_request_t xcb_req = { 6521 .count = 2, 6522 .ext = &xcb_glx_id, 6523 .opcode = XCB_GLX_GET_TEX_ENVFV, 6524 .isvoid = 0 6525 }; 6526 6527 struct iovec xcb_parts[4]; 6528 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 6529 xcb_glx_get_tex_envfv_request_t xcb_out; 6530 6531 xcb_out.context_tag = context_tag; 6532 xcb_out.target = target; 6533 xcb_out.pname = pname; 6534 6535 xcb_parts[2].iov_base = (char *) &xcb_out; 6536 xcb_parts[2].iov_len = sizeof(xcb_out); 6537 xcb_parts[3].iov_base = 0; 6538 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6539 6540 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6541 return xcb_ret; 6542} 6543 6544xcb_glx_get_tex_envfv_cookie_t 6545xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c, 6546 xcb_glx_context_tag_t context_tag, 6547 uint32_t target, 6548 uint32_t pname) 6549{ 6550 static const xcb_protocol_request_t xcb_req = { 6551 .count = 2, 6552 .ext = &xcb_glx_id, 6553 .opcode = XCB_GLX_GET_TEX_ENVFV, 6554 .isvoid = 0 6555 }; 6556 6557 struct iovec xcb_parts[4]; 6558 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 6559 xcb_glx_get_tex_envfv_request_t xcb_out; 6560 6561 xcb_out.context_tag = context_tag; 6562 xcb_out.target = target; 6563 xcb_out.pname = pname; 6564 6565 xcb_parts[2].iov_base = (char *) &xcb_out; 6566 xcb_parts[2].iov_len = sizeof(xcb_out); 6567 xcb_parts[3].iov_base = 0; 6568 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6569 6570 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6571 return xcb_ret; 6572} 6573 6574xcb_glx_float32_t * 6575xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R) 6576{ 6577 return (xcb_glx_float32_t *) (R + 1); 6578} 6579 6580int 6581xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R) 6582{ 6583 return R->n; 6584} 6585 6586xcb_generic_iterator_t 6587xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R) 6588{ 6589 xcb_generic_iterator_t i; 6590 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6591 i.rem = 0; 6592 i.index = (char *) i.data - (char *) R; 6593 return i; 6594} 6595 6596xcb_glx_get_tex_envfv_reply_t * 6597xcb_glx_get_tex_envfv_reply (xcb_connection_t *c, 6598 xcb_glx_get_tex_envfv_cookie_t cookie /**< */, 6599 xcb_generic_error_t **e) 6600{ 6601 return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6602} 6603 6604int 6605xcb_glx_get_tex_enviv_sizeof (const void *_buffer) 6606{ 6607 char *xcb_tmp = (char *)_buffer; 6608 const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer; 6609 unsigned int xcb_buffer_len = 0; 6610 unsigned int xcb_block_len = 0; 6611 unsigned int xcb_pad = 0; 6612 unsigned int xcb_align_to = 0; 6613 6614 6615 xcb_block_len += sizeof(xcb_glx_get_tex_enviv_reply_t); 6616 xcb_tmp += xcb_block_len; 6617 xcb_buffer_len += xcb_block_len; 6618 xcb_block_len = 0; 6619 /* data */ 6620 xcb_block_len += _aux->n * sizeof(int32_t); 6621 xcb_tmp += xcb_block_len; 6622 xcb_align_to = ALIGNOF(int32_t); 6623 /* insert padding */ 6624 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6625 xcb_buffer_len += xcb_block_len + xcb_pad; 6626 if (0 != xcb_pad) { 6627 xcb_tmp += xcb_pad; 6628 xcb_pad = 0; 6629 } 6630 xcb_block_len = 0; 6631 6632 return xcb_buffer_len; 6633} 6634 6635xcb_glx_get_tex_enviv_cookie_t 6636xcb_glx_get_tex_enviv (xcb_connection_t *c, 6637 xcb_glx_context_tag_t context_tag, 6638 uint32_t target, 6639 uint32_t pname) 6640{ 6641 static const xcb_protocol_request_t xcb_req = { 6642 .count = 2, 6643 .ext = &xcb_glx_id, 6644 .opcode = XCB_GLX_GET_TEX_ENVIV, 6645 .isvoid = 0 6646 }; 6647 6648 struct iovec xcb_parts[4]; 6649 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 6650 xcb_glx_get_tex_enviv_request_t xcb_out; 6651 6652 xcb_out.context_tag = context_tag; 6653 xcb_out.target = target; 6654 xcb_out.pname = pname; 6655 6656 xcb_parts[2].iov_base = (char *) &xcb_out; 6657 xcb_parts[2].iov_len = sizeof(xcb_out); 6658 xcb_parts[3].iov_base = 0; 6659 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6660 6661 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6662 return xcb_ret; 6663} 6664 6665xcb_glx_get_tex_enviv_cookie_t 6666xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c, 6667 xcb_glx_context_tag_t context_tag, 6668 uint32_t target, 6669 uint32_t pname) 6670{ 6671 static const xcb_protocol_request_t xcb_req = { 6672 .count = 2, 6673 .ext = &xcb_glx_id, 6674 .opcode = XCB_GLX_GET_TEX_ENVIV, 6675 .isvoid = 0 6676 }; 6677 6678 struct iovec xcb_parts[4]; 6679 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 6680 xcb_glx_get_tex_enviv_request_t xcb_out; 6681 6682 xcb_out.context_tag = context_tag; 6683 xcb_out.target = target; 6684 xcb_out.pname = pname; 6685 6686 xcb_parts[2].iov_base = (char *) &xcb_out; 6687 xcb_parts[2].iov_len = sizeof(xcb_out); 6688 xcb_parts[3].iov_base = 0; 6689 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6690 6691 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6692 return xcb_ret; 6693} 6694 6695int32_t * 6696xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R) 6697{ 6698 return (int32_t *) (R + 1); 6699} 6700 6701int 6702xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R) 6703{ 6704 return R->n; 6705} 6706 6707xcb_generic_iterator_t 6708xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R) 6709{ 6710 xcb_generic_iterator_t i; 6711 i.data = ((int32_t *) (R + 1)) + (R->n); 6712 i.rem = 0; 6713 i.index = (char *) i.data - (char *) R; 6714 return i; 6715} 6716 6717xcb_glx_get_tex_enviv_reply_t * 6718xcb_glx_get_tex_enviv_reply (xcb_connection_t *c, 6719 xcb_glx_get_tex_enviv_cookie_t cookie /**< */, 6720 xcb_generic_error_t **e) 6721{ 6722 return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6723} 6724 6725int 6726xcb_glx_get_tex_gendv_sizeof (const void *_buffer) 6727{ 6728 char *xcb_tmp = (char *)_buffer; 6729 const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer; 6730 unsigned int xcb_buffer_len = 0; 6731 unsigned int xcb_block_len = 0; 6732 unsigned int xcb_pad = 0; 6733 unsigned int xcb_align_to = 0; 6734 6735 6736 xcb_block_len += sizeof(xcb_glx_get_tex_gendv_reply_t); 6737 xcb_tmp += xcb_block_len; 6738 xcb_buffer_len += xcb_block_len; 6739 xcb_block_len = 0; 6740 /* data */ 6741 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 6742 xcb_tmp += xcb_block_len; 6743 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6744 /* insert padding */ 6745 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6746 xcb_buffer_len += xcb_block_len + xcb_pad; 6747 if (0 != xcb_pad) { 6748 xcb_tmp += xcb_pad; 6749 xcb_pad = 0; 6750 } 6751 xcb_block_len = 0; 6752 6753 return xcb_buffer_len; 6754} 6755 6756xcb_glx_get_tex_gendv_cookie_t 6757xcb_glx_get_tex_gendv (xcb_connection_t *c, 6758 xcb_glx_context_tag_t context_tag, 6759 uint32_t coord, 6760 uint32_t pname) 6761{ 6762 static const xcb_protocol_request_t xcb_req = { 6763 .count = 2, 6764 .ext = &xcb_glx_id, 6765 .opcode = XCB_GLX_GET_TEX_GENDV, 6766 .isvoid = 0 6767 }; 6768 6769 struct iovec xcb_parts[4]; 6770 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 6771 xcb_glx_get_tex_gendv_request_t xcb_out; 6772 6773 xcb_out.context_tag = context_tag; 6774 xcb_out.coord = coord; 6775 xcb_out.pname = pname; 6776 6777 xcb_parts[2].iov_base = (char *) &xcb_out; 6778 xcb_parts[2].iov_len = sizeof(xcb_out); 6779 xcb_parts[3].iov_base = 0; 6780 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6781 6782 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6783 return xcb_ret; 6784} 6785 6786xcb_glx_get_tex_gendv_cookie_t 6787xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c, 6788 xcb_glx_context_tag_t context_tag, 6789 uint32_t coord, 6790 uint32_t pname) 6791{ 6792 static const xcb_protocol_request_t xcb_req = { 6793 .count = 2, 6794 .ext = &xcb_glx_id, 6795 .opcode = XCB_GLX_GET_TEX_GENDV, 6796 .isvoid = 0 6797 }; 6798 6799 struct iovec xcb_parts[4]; 6800 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 6801 xcb_glx_get_tex_gendv_request_t xcb_out; 6802 6803 xcb_out.context_tag = context_tag; 6804 xcb_out.coord = coord; 6805 xcb_out.pname = pname; 6806 6807 xcb_parts[2].iov_base = (char *) &xcb_out; 6808 xcb_parts[2].iov_len = sizeof(xcb_out); 6809 xcb_parts[3].iov_base = 0; 6810 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6811 6812 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6813 return xcb_ret; 6814} 6815 6816xcb_glx_float64_t * 6817xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R) 6818{ 6819 return (xcb_glx_float64_t *) (R + 1); 6820} 6821 6822int 6823xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R) 6824{ 6825 return R->n; 6826} 6827 6828xcb_generic_iterator_t 6829xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R) 6830{ 6831 xcb_generic_iterator_t i; 6832 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 6833 i.rem = 0; 6834 i.index = (char *) i.data - (char *) R; 6835 return i; 6836} 6837 6838xcb_glx_get_tex_gendv_reply_t * 6839xcb_glx_get_tex_gendv_reply (xcb_connection_t *c, 6840 xcb_glx_get_tex_gendv_cookie_t cookie /**< */, 6841 xcb_generic_error_t **e) 6842{ 6843 return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6844} 6845 6846int 6847xcb_glx_get_tex_genfv_sizeof (const void *_buffer) 6848{ 6849 char *xcb_tmp = (char *)_buffer; 6850 const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer; 6851 unsigned int xcb_buffer_len = 0; 6852 unsigned int xcb_block_len = 0; 6853 unsigned int xcb_pad = 0; 6854 unsigned int xcb_align_to = 0; 6855 6856 6857 xcb_block_len += sizeof(xcb_glx_get_tex_genfv_reply_t); 6858 xcb_tmp += xcb_block_len; 6859 xcb_buffer_len += xcb_block_len; 6860 xcb_block_len = 0; 6861 /* data */ 6862 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6863 xcb_tmp += xcb_block_len; 6864 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6865 /* insert padding */ 6866 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6867 xcb_buffer_len += xcb_block_len + xcb_pad; 6868 if (0 != xcb_pad) { 6869 xcb_tmp += xcb_pad; 6870 xcb_pad = 0; 6871 } 6872 xcb_block_len = 0; 6873 6874 return xcb_buffer_len; 6875} 6876 6877xcb_glx_get_tex_genfv_cookie_t 6878xcb_glx_get_tex_genfv (xcb_connection_t *c, 6879 xcb_glx_context_tag_t context_tag, 6880 uint32_t coord, 6881 uint32_t pname) 6882{ 6883 static const xcb_protocol_request_t xcb_req = { 6884 .count = 2, 6885 .ext = &xcb_glx_id, 6886 .opcode = XCB_GLX_GET_TEX_GENFV, 6887 .isvoid = 0 6888 }; 6889 6890 struct iovec xcb_parts[4]; 6891 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 6892 xcb_glx_get_tex_genfv_request_t xcb_out; 6893 6894 xcb_out.context_tag = context_tag; 6895 xcb_out.coord = coord; 6896 xcb_out.pname = pname; 6897 6898 xcb_parts[2].iov_base = (char *) &xcb_out; 6899 xcb_parts[2].iov_len = sizeof(xcb_out); 6900 xcb_parts[3].iov_base = 0; 6901 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6902 6903 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6904 return xcb_ret; 6905} 6906 6907xcb_glx_get_tex_genfv_cookie_t 6908xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c, 6909 xcb_glx_context_tag_t context_tag, 6910 uint32_t coord, 6911 uint32_t pname) 6912{ 6913 static const xcb_protocol_request_t xcb_req = { 6914 .count = 2, 6915 .ext = &xcb_glx_id, 6916 .opcode = XCB_GLX_GET_TEX_GENFV, 6917 .isvoid = 0 6918 }; 6919 6920 struct iovec xcb_parts[4]; 6921 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 6922 xcb_glx_get_tex_genfv_request_t xcb_out; 6923 6924 xcb_out.context_tag = context_tag; 6925 xcb_out.coord = coord; 6926 xcb_out.pname = pname; 6927 6928 xcb_parts[2].iov_base = (char *) &xcb_out; 6929 xcb_parts[2].iov_len = sizeof(xcb_out); 6930 xcb_parts[3].iov_base = 0; 6931 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6932 6933 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6934 return xcb_ret; 6935} 6936 6937xcb_glx_float32_t * 6938xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R) 6939{ 6940 return (xcb_glx_float32_t *) (R + 1); 6941} 6942 6943int 6944xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R) 6945{ 6946 return R->n; 6947} 6948 6949xcb_generic_iterator_t 6950xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R) 6951{ 6952 xcb_generic_iterator_t i; 6953 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6954 i.rem = 0; 6955 i.index = (char *) i.data - (char *) R; 6956 return i; 6957} 6958 6959xcb_glx_get_tex_genfv_reply_t * 6960xcb_glx_get_tex_genfv_reply (xcb_connection_t *c, 6961 xcb_glx_get_tex_genfv_cookie_t cookie /**< */, 6962 xcb_generic_error_t **e) 6963{ 6964 return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6965} 6966 6967int 6968xcb_glx_get_tex_geniv_sizeof (const void *_buffer) 6969{ 6970 char *xcb_tmp = (char *)_buffer; 6971 const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer; 6972 unsigned int xcb_buffer_len = 0; 6973 unsigned int xcb_block_len = 0; 6974 unsigned int xcb_pad = 0; 6975 unsigned int xcb_align_to = 0; 6976 6977 6978 xcb_block_len += sizeof(xcb_glx_get_tex_geniv_reply_t); 6979 xcb_tmp += xcb_block_len; 6980 xcb_buffer_len += xcb_block_len; 6981 xcb_block_len = 0; 6982 /* data */ 6983 xcb_block_len += _aux->n * sizeof(int32_t); 6984 xcb_tmp += xcb_block_len; 6985 xcb_align_to = ALIGNOF(int32_t); 6986 /* insert padding */ 6987 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6988 xcb_buffer_len += xcb_block_len + xcb_pad; 6989 if (0 != xcb_pad) { 6990 xcb_tmp += xcb_pad; 6991 xcb_pad = 0; 6992 } 6993 xcb_block_len = 0; 6994 6995 return xcb_buffer_len; 6996} 6997 6998xcb_glx_get_tex_geniv_cookie_t 6999xcb_glx_get_tex_geniv (xcb_connection_t *c, 7000 xcb_glx_context_tag_t context_tag, 7001 uint32_t coord, 7002 uint32_t pname) 7003{ 7004 static const xcb_protocol_request_t xcb_req = { 7005 .count = 2, 7006 .ext = &xcb_glx_id, 7007 .opcode = XCB_GLX_GET_TEX_GENIV, 7008 .isvoid = 0 7009 }; 7010 7011 struct iovec xcb_parts[4]; 7012 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 7013 xcb_glx_get_tex_geniv_request_t xcb_out; 7014 7015 xcb_out.context_tag = context_tag; 7016 xcb_out.coord = coord; 7017 xcb_out.pname = pname; 7018 7019 xcb_parts[2].iov_base = (char *) &xcb_out; 7020 xcb_parts[2].iov_len = sizeof(xcb_out); 7021 xcb_parts[3].iov_base = 0; 7022 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7023 7024 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7025 return xcb_ret; 7026} 7027 7028xcb_glx_get_tex_geniv_cookie_t 7029xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c, 7030 xcb_glx_context_tag_t context_tag, 7031 uint32_t coord, 7032 uint32_t pname) 7033{ 7034 static const xcb_protocol_request_t xcb_req = { 7035 .count = 2, 7036 .ext = &xcb_glx_id, 7037 .opcode = XCB_GLX_GET_TEX_GENIV, 7038 .isvoid = 0 7039 }; 7040 7041 struct iovec xcb_parts[4]; 7042 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 7043 xcb_glx_get_tex_geniv_request_t xcb_out; 7044 7045 xcb_out.context_tag = context_tag; 7046 xcb_out.coord = coord; 7047 xcb_out.pname = pname; 7048 7049 xcb_parts[2].iov_base = (char *) &xcb_out; 7050 xcb_parts[2].iov_len = sizeof(xcb_out); 7051 xcb_parts[3].iov_base = 0; 7052 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7053 7054 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7055 return xcb_ret; 7056} 7057 7058int32_t * 7059xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R) 7060{ 7061 return (int32_t *) (R + 1); 7062} 7063 7064int 7065xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R) 7066{ 7067 return R->n; 7068} 7069 7070xcb_generic_iterator_t 7071xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R) 7072{ 7073 xcb_generic_iterator_t i; 7074 i.data = ((int32_t *) (R + 1)) + (R->n); 7075 i.rem = 0; 7076 i.index = (char *) i.data - (char *) R; 7077 return i; 7078} 7079 7080xcb_glx_get_tex_geniv_reply_t * 7081xcb_glx_get_tex_geniv_reply (xcb_connection_t *c, 7082 xcb_glx_get_tex_geniv_cookie_t cookie /**< */, 7083 xcb_generic_error_t **e) 7084{ 7085 return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7086} 7087 7088int 7089xcb_glx_get_tex_image_sizeof (const void *_buffer) 7090{ 7091 char *xcb_tmp = (char *)_buffer; 7092 const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer; 7093 unsigned int xcb_buffer_len = 0; 7094 unsigned int xcb_block_len = 0; 7095 unsigned int xcb_pad = 0; 7096 unsigned int xcb_align_to = 0; 7097 7098 7099 xcb_block_len += sizeof(xcb_glx_get_tex_image_reply_t); 7100 xcb_tmp += xcb_block_len; 7101 xcb_buffer_len += xcb_block_len; 7102 xcb_block_len = 0; 7103 /* data */ 7104 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 7105 xcb_tmp += xcb_block_len; 7106 xcb_align_to = ALIGNOF(uint8_t); 7107 /* insert padding */ 7108 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7109 xcb_buffer_len += xcb_block_len + xcb_pad; 7110 if (0 != xcb_pad) { 7111 xcb_tmp += xcb_pad; 7112 xcb_pad = 0; 7113 } 7114 xcb_block_len = 0; 7115 7116 return xcb_buffer_len; 7117} 7118 7119xcb_glx_get_tex_image_cookie_t 7120xcb_glx_get_tex_image (xcb_connection_t *c, 7121 xcb_glx_context_tag_t context_tag, 7122 uint32_t target, 7123 int32_t level, 7124 uint32_t format, 7125 uint32_t type, 7126 uint8_t swap_bytes) 7127{ 7128 static const xcb_protocol_request_t xcb_req = { 7129 .count = 2, 7130 .ext = &xcb_glx_id, 7131 .opcode = XCB_GLX_GET_TEX_IMAGE, 7132 .isvoid = 0 7133 }; 7134 7135 struct iovec xcb_parts[4]; 7136 xcb_glx_get_tex_image_cookie_t xcb_ret; 7137 xcb_glx_get_tex_image_request_t xcb_out; 7138 7139 xcb_out.context_tag = context_tag; 7140 xcb_out.target = target; 7141 xcb_out.level = level; 7142 xcb_out.format = format; 7143 xcb_out.type = type; 7144 xcb_out.swap_bytes = swap_bytes; 7145 7146 xcb_parts[2].iov_base = (char *) &xcb_out; 7147 xcb_parts[2].iov_len = sizeof(xcb_out); 7148 xcb_parts[3].iov_base = 0; 7149 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7150 7151 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7152 return xcb_ret; 7153} 7154 7155xcb_glx_get_tex_image_cookie_t 7156xcb_glx_get_tex_image_unchecked (xcb_connection_t *c, 7157 xcb_glx_context_tag_t context_tag, 7158 uint32_t target, 7159 int32_t level, 7160 uint32_t format, 7161 uint32_t type, 7162 uint8_t swap_bytes) 7163{ 7164 static const xcb_protocol_request_t xcb_req = { 7165 .count = 2, 7166 .ext = &xcb_glx_id, 7167 .opcode = XCB_GLX_GET_TEX_IMAGE, 7168 .isvoid = 0 7169 }; 7170 7171 struct iovec xcb_parts[4]; 7172 xcb_glx_get_tex_image_cookie_t xcb_ret; 7173 xcb_glx_get_tex_image_request_t xcb_out; 7174 7175 xcb_out.context_tag = context_tag; 7176 xcb_out.target = target; 7177 xcb_out.level = level; 7178 xcb_out.format = format; 7179 xcb_out.type = type; 7180 xcb_out.swap_bytes = swap_bytes; 7181 7182 xcb_parts[2].iov_base = (char *) &xcb_out; 7183 xcb_parts[2].iov_len = sizeof(xcb_out); 7184 xcb_parts[3].iov_base = 0; 7185 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7186 7187 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7188 return xcb_ret; 7189} 7190 7191uint8_t * 7192xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R) 7193{ 7194 return (uint8_t *) (R + 1); 7195} 7196 7197int 7198xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R) 7199{ 7200 return (R->length * 4); 7201} 7202 7203xcb_generic_iterator_t 7204xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R) 7205{ 7206 xcb_generic_iterator_t i; 7207 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 7208 i.rem = 0; 7209 i.index = (char *) i.data - (char *) R; 7210 return i; 7211} 7212 7213xcb_glx_get_tex_image_reply_t * 7214xcb_glx_get_tex_image_reply (xcb_connection_t *c, 7215 xcb_glx_get_tex_image_cookie_t cookie /**< */, 7216 xcb_generic_error_t **e) 7217{ 7218 return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7219} 7220 7221int 7222xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer) 7223{ 7224 char *xcb_tmp = (char *)_buffer; 7225 const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer; 7226 unsigned int xcb_buffer_len = 0; 7227 unsigned int xcb_block_len = 0; 7228 unsigned int xcb_pad = 0; 7229 unsigned int xcb_align_to = 0; 7230 7231 7232 xcb_block_len += sizeof(xcb_glx_get_tex_parameterfv_reply_t); 7233 xcb_tmp += xcb_block_len; 7234 xcb_buffer_len += xcb_block_len; 7235 xcb_block_len = 0; 7236 /* data */ 7237 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7238 xcb_tmp += xcb_block_len; 7239 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7240 /* insert padding */ 7241 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7242 xcb_buffer_len += xcb_block_len + xcb_pad; 7243 if (0 != xcb_pad) { 7244 xcb_tmp += xcb_pad; 7245 xcb_pad = 0; 7246 } 7247 xcb_block_len = 0; 7248 7249 return xcb_buffer_len; 7250} 7251 7252xcb_glx_get_tex_parameterfv_cookie_t 7253xcb_glx_get_tex_parameterfv (xcb_connection_t *c, 7254 xcb_glx_context_tag_t context_tag, 7255 uint32_t target, 7256 uint32_t pname) 7257{ 7258 static const xcb_protocol_request_t xcb_req = { 7259 .count = 2, 7260 .ext = &xcb_glx_id, 7261 .opcode = XCB_GLX_GET_TEX_PARAMETERFV, 7262 .isvoid = 0 7263 }; 7264 7265 struct iovec xcb_parts[4]; 7266 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 7267 xcb_glx_get_tex_parameterfv_request_t xcb_out; 7268 7269 xcb_out.context_tag = context_tag; 7270 xcb_out.target = target; 7271 xcb_out.pname = pname; 7272 7273 xcb_parts[2].iov_base = (char *) &xcb_out; 7274 xcb_parts[2].iov_len = sizeof(xcb_out); 7275 xcb_parts[3].iov_base = 0; 7276 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7277 7278 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7279 return xcb_ret; 7280} 7281 7282xcb_glx_get_tex_parameterfv_cookie_t 7283xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c, 7284 xcb_glx_context_tag_t context_tag, 7285 uint32_t target, 7286 uint32_t pname) 7287{ 7288 static const xcb_protocol_request_t xcb_req = { 7289 .count = 2, 7290 .ext = &xcb_glx_id, 7291 .opcode = XCB_GLX_GET_TEX_PARAMETERFV, 7292 .isvoid = 0 7293 }; 7294 7295 struct iovec xcb_parts[4]; 7296 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 7297 xcb_glx_get_tex_parameterfv_request_t xcb_out; 7298 7299 xcb_out.context_tag = context_tag; 7300 xcb_out.target = target; 7301 xcb_out.pname = pname; 7302 7303 xcb_parts[2].iov_base = (char *) &xcb_out; 7304 xcb_parts[2].iov_len = sizeof(xcb_out); 7305 xcb_parts[3].iov_base = 0; 7306 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7307 7308 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7309 return xcb_ret; 7310} 7311 7312xcb_glx_float32_t * 7313xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R) 7314{ 7315 return (xcb_glx_float32_t *) (R + 1); 7316} 7317 7318int 7319xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R) 7320{ 7321 return R->n; 7322} 7323 7324xcb_generic_iterator_t 7325xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R) 7326{ 7327 xcb_generic_iterator_t i; 7328 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7329 i.rem = 0; 7330 i.index = (char *) i.data - (char *) R; 7331 return i; 7332} 7333 7334xcb_glx_get_tex_parameterfv_reply_t * 7335xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c, 7336 xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, 7337 xcb_generic_error_t **e) 7338{ 7339 return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7340} 7341 7342int 7343xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer) 7344{ 7345 char *xcb_tmp = (char *)_buffer; 7346 const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer; 7347 unsigned int xcb_buffer_len = 0; 7348 unsigned int xcb_block_len = 0; 7349 unsigned int xcb_pad = 0; 7350 unsigned int xcb_align_to = 0; 7351 7352 7353 xcb_block_len += sizeof(xcb_glx_get_tex_parameteriv_reply_t); 7354 xcb_tmp += xcb_block_len; 7355 xcb_buffer_len += xcb_block_len; 7356 xcb_block_len = 0; 7357 /* data */ 7358 xcb_block_len += _aux->n * sizeof(int32_t); 7359 xcb_tmp += xcb_block_len; 7360 xcb_align_to = ALIGNOF(int32_t); 7361 /* insert padding */ 7362 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7363 xcb_buffer_len += xcb_block_len + xcb_pad; 7364 if (0 != xcb_pad) { 7365 xcb_tmp += xcb_pad; 7366 xcb_pad = 0; 7367 } 7368 xcb_block_len = 0; 7369 7370 return xcb_buffer_len; 7371} 7372 7373xcb_glx_get_tex_parameteriv_cookie_t 7374xcb_glx_get_tex_parameteriv (xcb_connection_t *c, 7375 xcb_glx_context_tag_t context_tag, 7376 uint32_t target, 7377 uint32_t pname) 7378{ 7379 static const xcb_protocol_request_t xcb_req = { 7380 .count = 2, 7381 .ext = &xcb_glx_id, 7382 .opcode = XCB_GLX_GET_TEX_PARAMETERIV, 7383 .isvoid = 0 7384 }; 7385 7386 struct iovec xcb_parts[4]; 7387 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 7388 xcb_glx_get_tex_parameteriv_request_t xcb_out; 7389 7390 xcb_out.context_tag = context_tag; 7391 xcb_out.target = target; 7392 xcb_out.pname = pname; 7393 7394 xcb_parts[2].iov_base = (char *) &xcb_out; 7395 xcb_parts[2].iov_len = sizeof(xcb_out); 7396 xcb_parts[3].iov_base = 0; 7397 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7398 7399 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7400 return xcb_ret; 7401} 7402 7403xcb_glx_get_tex_parameteriv_cookie_t 7404xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c, 7405 xcb_glx_context_tag_t context_tag, 7406 uint32_t target, 7407 uint32_t pname) 7408{ 7409 static const xcb_protocol_request_t xcb_req = { 7410 .count = 2, 7411 .ext = &xcb_glx_id, 7412 .opcode = XCB_GLX_GET_TEX_PARAMETERIV, 7413 .isvoid = 0 7414 }; 7415 7416 struct iovec xcb_parts[4]; 7417 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 7418 xcb_glx_get_tex_parameteriv_request_t xcb_out; 7419 7420 xcb_out.context_tag = context_tag; 7421 xcb_out.target = target; 7422 xcb_out.pname = pname; 7423 7424 xcb_parts[2].iov_base = (char *) &xcb_out; 7425 xcb_parts[2].iov_len = sizeof(xcb_out); 7426 xcb_parts[3].iov_base = 0; 7427 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7428 7429 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7430 return xcb_ret; 7431} 7432 7433int32_t * 7434xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R) 7435{ 7436 return (int32_t *) (R + 1); 7437} 7438 7439int 7440xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R) 7441{ 7442 return R->n; 7443} 7444 7445xcb_generic_iterator_t 7446xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R) 7447{ 7448 xcb_generic_iterator_t i; 7449 i.data = ((int32_t *) (R + 1)) + (R->n); 7450 i.rem = 0; 7451 i.index = (char *) i.data - (char *) R; 7452 return i; 7453} 7454 7455xcb_glx_get_tex_parameteriv_reply_t * 7456xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c, 7457 xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, 7458 xcb_generic_error_t **e) 7459{ 7460 return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7461} 7462 7463int 7464xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer) 7465{ 7466 char *xcb_tmp = (char *)_buffer; 7467 const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer; 7468 unsigned int xcb_buffer_len = 0; 7469 unsigned int xcb_block_len = 0; 7470 unsigned int xcb_pad = 0; 7471 unsigned int xcb_align_to = 0; 7472 7473 7474 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameterfv_reply_t); 7475 xcb_tmp += xcb_block_len; 7476 xcb_buffer_len += xcb_block_len; 7477 xcb_block_len = 0; 7478 /* data */ 7479 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7480 xcb_tmp += xcb_block_len; 7481 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7482 /* insert padding */ 7483 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7484 xcb_buffer_len += xcb_block_len + xcb_pad; 7485 if (0 != xcb_pad) { 7486 xcb_tmp += xcb_pad; 7487 xcb_pad = 0; 7488 } 7489 xcb_block_len = 0; 7490 7491 return xcb_buffer_len; 7492} 7493 7494xcb_glx_get_tex_level_parameterfv_cookie_t 7495xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c, 7496 xcb_glx_context_tag_t context_tag, 7497 uint32_t target, 7498 int32_t level, 7499 uint32_t pname) 7500{ 7501 static const xcb_protocol_request_t xcb_req = { 7502 .count = 2, 7503 .ext = &xcb_glx_id, 7504 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 7505 .isvoid = 0 7506 }; 7507 7508 struct iovec xcb_parts[4]; 7509 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 7510 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 7511 7512 xcb_out.context_tag = context_tag; 7513 xcb_out.target = target; 7514 xcb_out.level = level; 7515 xcb_out.pname = pname; 7516 7517 xcb_parts[2].iov_base = (char *) &xcb_out; 7518 xcb_parts[2].iov_len = sizeof(xcb_out); 7519 xcb_parts[3].iov_base = 0; 7520 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7521 7522 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7523 return xcb_ret; 7524} 7525 7526xcb_glx_get_tex_level_parameterfv_cookie_t 7527xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c, 7528 xcb_glx_context_tag_t context_tag, 7529 uint32_t target, 7530 int32_t level, 7531 uint32_t pname) 7532{ 7533 static const xcb_protocol_request_t xcb_req = { 7534 .count = 2, 7535 .ext = &xcb_glx_id, 7536 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 7537 .isvoid = 0 7538 }; 7539 7540 struct iovec xcb_parts[4]; 7541 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 7542 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 7543 7544 xcb_out.context_tag = context_tag; 7545 xcb_out.target = target; 7546 xcb_out.level = level; 7547 xcb_out.pname = pname; 7548 7549 xcb_parts[2].iov_base = (char *) &xcb_out; 7550 xcb_parts[2].iov_len = sizeof(xcb_out); 7551 xcb_parts[3].iov_base = 0; 7552 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7553 7554 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7555 return xcb_ret; 7556} 7557 7558xcb_glx_float32_t * 7559xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7560{ 7561 return (xcb_glx_float32_t *) (R + 1); 7562} 7563 7564int 7565xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7566{ 7567 return R->n; 7568} 7569 7570xcb_generic_iterator_t 7571xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7572{ 7573 xcb_generic_iterator_t i; 7574 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7575 i.rem = 0; 7576 i.index = (char *) i.data - (char *) R; 7577 return i; 7578} 7579 7580xcb_glx_get_tex_level_parameterfv_reply_t * 7581xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c, 7582 xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, 7583 xcb_generic_error_t **e) 7584{ 7585 return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7586} 7587 7588int 7589xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer) 7590{ 7591 char *xcb_tmp = (char *)_buffer; 7592 const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer; 7593 unsigned int xcb_buffer_len = 0; 7594 unsigned int xcb_block_len = 0; 7595 unsigned int xcb_pad = 0; 7596 unsigned int xcb_align_to = 0; 7597 7598 7599 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameteriv_reply_t); 7600 xcb_tmp += xcb_block_len; 7601 xcb_buffer_len += xcb_block_len; 7602 xcb_block_len = 0; 7603 /* data */ 7604 xcb_block_len += _aux->n * sizeof(int32_t); 7605 xcb_tmp += xcb_block_len; 7606 xcb_align_to = ALIGNOF(int32_t); 7607 /* insert padding */ 7608 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7609 xcb_buffer_len += xcb_block_len + xcb_pad; 7610 if (0 != xcb_pad) { 7611 xcb_tmp += xcb_pad; 7612 xcb_pad = 0; 7613 } 7614 xcb_block_len = 0; 7615 7616 return xcb_buffer_len; 7617} 7618 7619xcb_glx_get_tex_level_parameteriv_cookie_t 7620xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c, 7621 xcb_glx_context_tag_t context_tag, 7622 uint32_t target, 7623 int32_t level, 7624 uint32_t pname) 7625{ 7626 static const xcb_protocol_request_t xcb_req = { 7627 .count = 2, 7628 .ext = &xcb_glx_id, 7629 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 7630 .isvoid = 0 7631 }; 7632 7633 struct iovec xcb_parts[4]; 7634 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 7635 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 7636 7637 xcb_out.context_tag = context_tag; 7638 xcb_out.target = target; 7639 xcb_out.level = level; 7640 xcb_out.pname = pname; 7641 7642 xcb_parts[2].iov_base = (char *) &xcb_out; 7643 xcb_parts[2].iov_len = sizeof(xcb_out); 7644 xcb_parts[3].iov_base = 0; 7645 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7646 7647 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7648 return xcb_ret; 7649} 7650 7651xcb_glx_get_tex_level_parameteriv_cookie_t 7652xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c, 7653 xcb_glx_context_tag_t context_tag, 7654 uint32_t target, 7655 int32_t level, 7656 uint32_t pname) 7657{ 7658 static const xcb_protocol_request_t xcb_req = { 7659 .count = 2, 7660 .ext = &xcb_glx_id, 7661 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 7662 .isvoid = 0 7663 }; 7664 7665 struct iovec xcb_parts[4]; 7666 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 7667 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 7668 7669 xcb_out.context_tag = context_tag; 7670 xcb_out.target = target; 7671 xcb_out.level = level; 7672 xcb_out.pname = pname; 7673 7674 xcb_parts[2].iov_base = (char *) &xcb_out; 7675 xcb_parts[2].iov_len = sizeof(xcb_out); 7676 xcb_parts[3].iov_base = 0; 7677 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7678 7679 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7680 return xcb_ret; 7681} 7682 7683int32_t * 7684xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7685{ 7686 return (int32_t *) (R + 1); 7687} 7688 7689int 7690xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7691{ 7692 return R->n; 7693} 7694 7695xcb_generic_iterator_t 7696xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7697{ 7698 xcb_generic_iterator_t i; 7699 i.data = ((int32_t *) (R + 1)) + (R->n); 7700 i.rem = 0; 7701 i.index = (char *) i.data - (char *) R; 7702 return i; 7703} 7704 7705xcb_glx_get_tex_level_parameteriv_reply_t * 7706xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c, 7707 xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, 7708 xcb_generic_error_t **e) 7709{ 7710 return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7711} 7712 7713xcb_glx_is_enabled_cookie_t 7714xcb_glx_is_enabled (xcb_connection_t *c, 7715 xcb_glx_context_tag_t context_tag, 7716 uint32_t capability) 7717{ 7718 static const xcb_protocol_request_t xcb_req = { 7719 .count = 2, 7720 .ext = &xcb_glx_id, 7721 .opcode = XCB_GLX_IS_ENABLED, 7722 .isvoid = 0 7723 }; 7724 7725 struct iovec xcb_parts[4]; 7726 xcb_glx_is_enabled_cookie_t xcb_ret; 7727 xcb_glx_is_enabled_request_t xcb_out; 7728 7729 xcb_out.context_tag = context_tag; 7730 xcb_out.capability = capability; 7731 7732 xcb_parts[2].iov_base = (char *) &xcb_out; 7733 xcb_parts[2].iov_len = sizeof(xcb_out); 7734 xcb_parts[3].iov_base = 0; 7735 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7736 7737 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7738 return xcb_ret; 7739} 7740 7741xcb_glx_is_enabled_cookie_t 7742xcb_glx_is_enabled_unchecked (xcb_connection_t *c, 7743 xcb_glx_context_tag_t context_tag, 7744 uint32_t capability) 7745{ 7746 static const xcb_protocol_request_t xcb_req = { 7747 .count = 2, 7748 .ext = &xcb_glx_id, 7749 .opcode = XCB_GLX_IS_ENABLED, 7750 .isvoid = 0 7751 }; 7752 7753 struct iovec xcb_parts[4]; 7754 xcb_glx_is_enabled_cookie_t xcb_ret; 7755 xcb_glx_is_enabled_request_t xcb_out; 7756 7757 xcb_out.context_tag = context_tag; 7758 xcb_out.capability = capability; 7759 7760 xcb_parts[2].iov_base = (char *) &xcb_out; 7761 xcb_parts[2].iov_len = sizeof(xcb_out); 7762 xcb_parts[3].iov_base = 0; 7763 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7764 7765 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7766 return xcb_ret; 7767} 7768 7769xcb_glx_is_enabled_reply_t * 7770xcb_glx_is_enabled_reply (xcb_connection_t *c, 7771 xcb_glx_is_enabled_cookie_t cookie /**< */, 7772 xcb_generic_error_t **e) 7773{ 7774 return (xcb_glx_is_enabled_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7775} 7776 7777xcb_glx_is_list_cookie_t 7778xcb_glx_is_list (xcb_connection_t *c, 7779 xcb_glx_context_tag_t context_tag, 7780 uint32_t list) 7781{ 7782 static const xcb_protocol_request_t xcb_req = { 7783 .count = 2, 7784 .ext = &xcb_glx_id, 7785 .opcode = XCB_GLX_IS_LIST, 7786 .isvoid = 0 7787 }; 7788 7789 struct iovec xcb_parts[4]; 7790 xcb_glx_is_list_cookie_t xcb_ret; 7791 xcb_glx_is_list_request_t xcb_out; 7792 7793 xcb_out.context_tag = context_tag; 7794 xcb_out.list = list; 7795 7796 xcb_parts[2].iov_base = (char *) &xcb_out; 7797 xcb_parts[2].iov_len = sizeof(xcb_out); 7798 xcb_parts[3].iov_base = 0; 7799 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7800 7801 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7802 return xcb_ret; 7803} 7804 7805xcb_glx_is_list_cookie_t 7806xcb_glx_is_list_unchecked (xcb_connection_t *c, 7807 xcb_glx_context_tag_t context_tag, 7808 uint32_t list) 7809{ 7810 static const xcb_protocol_request_t xcb_req = { 7811 .count = 2, 7812 .ext = &xcb_glx_id, 7813 .opcode = XCB_GLX_IS_LIST, 7814 .isvoid = 0 7815 }; 7816 7817 struct iovec xcb_parts[4]; 7818 xcb_glx_is_list_cookie_t xcb_ret; 7819 xcb_glx_is_list_request_t xcb_out; 7820 7821 xcb_out.context_tag = context_tag; 7822 xcb_out.list = list; 7823 7824 xcb_parts[2].iov_base = (char *) &xcb_out; 7825 xcb_parts[2].iov_len = sizeof(xcb_out); 7826 xcb_parts[3].iov_base = 0; 7827 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7828 7829 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7830 return xcb_ret; 7831} 7832 7833xcb_glx_is_list_reply_t * 7834xcb_glx_is_list_reply (xcb_connection_t *c, 7835 xcb_glx_is_list_cookie_t cookie /**< */, 7836 xcb_generic_error_t **e) 7837{ 7838 return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7839} 7840 7841xcb_void_cookie_t 7842xcb_glx_flush_checked (xcb_connection_t *c, 7843 xcb_glx_context_tag_t context_tag) 7844{ 7845 static const xcb_protocol_request_t xcb_req = { 7846 .count = 2, 7847 .ext = &xcb_glx_id, 7848 .opcode = XCB_GLX_FLUSH, 7849 .isvoid = 1 7850 }; 7851 7852 struct iovec xcb_parts[4]; 7853 xcb_void_cookie_t xcb_ret; 7854 xcb_glx_flush_request_t xcb_out; 7855 7856 xcb_out.context_tag = context_tag; 7857 7858 xcb_parts[2].iov_base = (char *) &xcb_out; 7859 xcb_parts[2].iov_len = sizeof(xcb_out); 7860 xcb_parts[3].iov_base = 0; 7861 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7862 7863 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7864 return xcb_ret; 7865} 7866 7867xcb_void_cookie_t 7868xcb_glx_flush (xcb_connection_t *c, 7869 xcb_glx_context_tag_t context_tag) 7870{ 7871 static const xcb_protocol_request_t xcb_req = { 7872 .count = 2, 7873 .ext = &xcb_glx_id, 7874 .opcode = XCB_GLX_FLUSH, 7875 .isvoid = 1 7876 }; 7877 7878 struct iovec xcb_parts[4]; 7879 xcb_void_cookie_t xcb_ret; 7880 xcb_glx_flush_request_t xcb_out; 7881 7882 xcb_out.context_tag = context_tag; 7883 7884 xcb_parts[2].iov_base = (char *) &xcb_out; 7885 xcb_parts[2].iov_len = sizeof(xcb_out); 7886 xcb_parts[3].iov_base = 0; 7887 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7888 7889 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7890 return xcb_ret; 7891} 7892 7893int 7894xcb_glx_are_textures_resident_sizeof (const void *_buffer) 7895{ 7896 char *xcb_tmp = (char *)_buffer; 7897 const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer; 7898 unsigned int xcb_buffer_len = 0; 7899 unsigned int xcb_block_len = 0; 7900 unsigned int xcb_pad = 0; 7901 unsigned int xcb_align_to = 0; 7902 7903 7904 xcb_block_len += sizeof(xcb_glx_are_textures_resident_request_t); 7905 xcb_tmp += xcb_block_len; 7906 xcb_buffer_len += xcb_block_len; 7907 xcb_block_len = 0; 7908 /* textures */ 7909 xcb_block_len += _aux->n * sizeof(uint32_t); 7910 xcb_tmp += xcb_block_len; 7911 xcb_align_to = ALIGNOF(uint32_t); 7912 /* insert padding */ 7913 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7914 xcb_buffer_len += xcb_block_len + xcb_pad; 7915 if (0 != xcb_pad) { 7916 xcb_tmp += xcb_pad; 7917 xcb_pad = 0; 7918 } 7919 xcb_block_len = 0; 7920 7921 return xcb_buffer_len; 7922} 7923 7924xcb_glx_are_textures_resident_cookie_t 7925xcb_glx_are_textures_resident (xcb_connection_t *c, 7926 xcb_glx_context_tag_t context_tag, 7927 int32_t n, 7928 const uint32_t *textures) 7929{ 7930 static const xcb_protocol_request_t xcb_req = { 7931 .count = 4, 7932 .ext = &xcb_glx_id, 7933 .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, 7934 .isvoid = 0 7935 }; 7936 7937 struct iovec xcb_parts[6]; 7938 xcb_glx_are_textures_resident_cookie_t xcb_ret; 7939 xcb_glx_are_textures_resident_request_t xcb_out; 7940 7941 xcb_out.context_tag = context_tag; 7942 xcb_out.n = n; 7943 7944 xcb_parts[2].iov_base = (char *) &xcb_out; 7945 xcb_parts[2].iov_len = sizeof(xcb_out); 7946 xcb_parts[3].iov_base = 0; 7947 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7948 /* uint32_t textures */ 7949 xcb_parts[4].iov_base = (char *) textures; 7950 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 7951 xcb_parts[5].iov_base = 0; 7952 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7953 7954 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7955 return xcb_ret; 7956} 7957 7958xcb_glx_are_textures_resident_cookie_t 7959xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c, 7960 xcb_glx_context_tag_t context_tag, 7961 int32_t n, 7962 const uint32_t *textures) 7963{ 7964 static const xcb_protocol_request_t xcb_req = { 7965 .count = 4, 7966 .ext = &xcb_glx_id, 7967 .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, 7968 .isvoid = 0 7969 }; 7970 7971 struct iovec xcb_parts[6]; 7972 xcb_glx_are_textures_resident_cookie_t xcb_ret; 7973 xcb_glx_are_textures_resident_request_t xcb_out; 7974 7975 xcb_out.context_tag = context_tag; 7976 xcb_out.n = n; 7977 7978 xcb_parts[2].iov_base = (char *) &xcb_out; 7979 xcb_parts[2].iov_len = sizeof(xcb_out); 7980 xcb_parts[3].iov_base = 0; 7981 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7982 /* uint32_t textures */ 7983 xcb_parts[4].iov_base = (char *) textures; 7984 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 7985 xcb_parts[5].iov_base = 0; 7986 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7987 7988 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7989 return xcb_ret; 7990} 7991 7992uint8_t * 7993xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R) 7994{ 7995 return (uint8_t *) (R + 1); 7996} 7997 7998int 7999xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R) 8000{ 8001 return (R->length * 4); 8002} 8003 8004xcb_generic_iterator_t 8005xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R) 8006{ 8007 xcb_generic_iterator_t i; 8008 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8009 i.rem = 0; 8010 i.index = (char *) i.data - (char *) R; 8011 return i; 8012} 8013 8014xcb_glx_are_textures_resident_reply_t * 8015xcb_glx_are_textures_resident_reply (xcb_connection_t *c, 8016 xcb_glx_are_textures_resident_cookie_t cookie /**< */, 8017 xcb_generic_error_t **e) 8018{ 8019 return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8020} 8021 8022int 8023xcb_glx_delete_textures_sizeof (const void *_buffer) 8024{ 8025 char *xcb_tmp = (char *)_buffer; 8026 const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer; 8027 unsigned int xcb_buffer_len = 0; 8028 unsigned int xcb_block_len = 0; 8029 unsigned int xcb_pad = 0; 8030 unsigned int xcb_align_to = 0; 8031 8032 8033 xcb_block_len += sizeof(xcb_glx_delete_textures_request_t); 8034 xcb_tmp += xcb_block_len; 8035 xcb_buffer_len += xcb_block_len; 8036 xcb_block_len = 0; 8037 /* textures */ 8038 xcb_block_len += _aux->n * sizeof(uint32_t); 8039 xcb_tmp += xcb_block_len; 8040 xcb_align_to = ALIGNOF(uint32_t); 8041 /* insert padding */ 8042 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8043 xcb_buffer_len += xcb_block_len + xcb_pad; 8044 if (0 != xcb_pad) { 8045 xcb_tmp += xcb_pad; 8046 xcb_pad = 0; 8047 } 8048 xcb_block_len = 0; 8049 8050 return xcb_buffer_len; 8051} 8052 8053xcb_void_cookie_t 8054xcb_glx_delete_textures_checked (xcb_connection_t *c, 8055 xcb_glx_context_tag_t context_tag, 8056 int32_t n, 8057 const uint32_t *textures) 8058{ 8059 static const xcb_protocol_request_t xcb_req = { 8060 .count = 4, 8061 .ext = &xcb_glx_id, 8062 .opcode = XCB_GLX_DELETE_TEXTURES, 8063 .isvoid = 1 8064 }; 8065 8066 struct iovec xcb_parts[6]; 8067 xcb_void_cookie_t xcb_ret; 8068 xcb_glx_delete_textures_request_t xcb_out; 8069 8070 xcb_out.context_tag = context_tag; 8071 xcb_out.n = n; 8072 8073 xcb_parts[2].iov_base = (char *) &xcb_out; 8074 xcb_parts[2].iov_len = sizeof(xcb_out); 8075 xcb_parts[3].iov_base = 0; 8076 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8077 /* uint32_t textures */ 8078 xcb_parts[4].iov_base = (char *) textures; 8079 xcb_parts[4].iov_len = n * sizeof(uint32_t); 8080 xcb_parts[5].iov_base = 0; 8081 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8082 8083 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8084 return xcb_ret; 8085} 8086 8087xcb_void_cookie_t 8088xcb_glx_delete_textures (xcb_connection_t *c, 8089 xcb_glx_context_tag_t context_tag, 8090 int32_t n, 8091 const uint32_t *textures) 8092{ 8093 static const xcb_protocol_request_t xcb_req = { 8094 .count = 4, 8095 .ext = &xcb_glx_id, 8096 .opcode = XCB_GLX_DELETE_TEXTURES, 8097 .isvoid = 1 8098 }; 8099 8100 struct iovec xcb_parts[6]; 8101 xcb_void_cookie_t xcb_ret; 8102 xcb_glx_delete_textures_request_t xcb_out; 8103 8104 xcb_out.context_tag = context_tag; 8105 xcb_out.n = n; 8106 8107 xcb_parts[2].iov_base = (char *) &xcb_out; 8108 xcb_parts[2].iov_len = sizeof(xcb_out); 8109 xcb_parts[3].iov_base = 0; 8110 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8111 /* uint32_t textures */ 8112 xcb_parts[4].iov_base = (char *) textures; 8113 xcb_parts[4].iov_len = n * sizeof(uint32_t); 8114 xcb_parts[5].iov_base = 0; 8115 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8116 8117 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8118 return xcb_ret; 8119} 8120 8121uint32_t * 8122xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R) 8123{ 8124 return (uint32_t *) (R + 1); 8125} 8126 8127int 8128xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R) 8129{ 8130 return R->n; 8131} 8132 8133xcb_generic_iterator_t 8134xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R) 8135{ 8136 xcb_generic_iterator_t i; 8137 i.data = ((uint32_t *) (R + 1)) + (R->n); 8138 i.rem = 0; 8139 i.index = (char *) i.data - (char *) R; 8140 return i; 8141} 8142 8143int 8144xcb_glx_gen_textures_sizeof (const void *_buffer) 8145{ 8146 char *xcb_tmp = (char *)_buffer; 8147 const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer; 8148 unsigned int xcb_buffer_len = 0; 8149 unsigned int xcb_block_len = 0; 8150 unsigned int xcb_pad = 0; 8151 unsigned int xcb_align_to = 0; 8152 8153 8154 xcb_block_len += sizeof(xcb_glx_gen_textures_reply_t); 8155 xcb_tmp += xcb_block_len; 8156 xcb_buffer_len += xcb_block_len; 8157 xcb_block_len = 0; 8158 /* data */ 8159 xcb_block_len += _aux->length * sizeof(uint32_t); 8160 xcb_tmp += xcb_block_len; 8161 xcb_align_to = ALIGNOF(uint32_t); 8162 /* insert padding */ 8163 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8164 xcb_buffer_len += xcb_block_len + xcb_pad; 8165 if (0 != xcb_pad) { 8166 xcb_tmp += xcb_pad; 8167 xcb_pad = 0; 8168 } 8169 xcb_block_len = 0; 8170 8171 return xcb_buffer_len; 8172} 8173 8174xcb_glx_gen_textures_cookie_t 8175xcb_glx_gen_textures (xcb_connection_t *c, 8176 xcb_glx_context_tag_t context_tag, 8177 int32_t n) 8178{ 8179 static const xcb_protocol_request_t xcb_req = { 8180 .count = 2, 8181 .ext = &xcb_glx_id, 8182 .opcode = XCB_GLX_GEN_TEXTURES, 8183 .isvoid = 0 8184 }; 8185 8186 struct iovec xcb_parts[4]; 8187 xcb_glx_gen_textures_cookie_t xcb_ret; 8188 xcb_glx_gen_textures_request_t xcb_out; 8189 8190 xcb_out.context_tag = context_tag; 8191 xcb_out.n = n; 8192 8193 xcb_parts[2].iov_base = (char *) &xcb_out; 8194 xcb_parts[2].iov_len = sizeof(xcb_out); 8195 xcb_parts[3].iov_base = 0; 8196 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8197 8198 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8199 return xcb_ret; 8200} 8201 8202xcb_glx_gen_textures_cookie_t 8203xcb_glx_gen_textures_unchecked (xcb_connection_t *c, 8204 xcb_glx_context_tag_t context_tag, 8205 int32_t n) 8206{ 8207 static const xcb_protocol_request_t xcb_req = { 8208 .count = 2, 8209 .ext = &xcb_glx_id, 8210 .opcode = XCB_GLX_GEN_TEXTURES, 8211 .isvoid = 0 8212 }; 8213 8214 struct iovec xcb_parts[4]; 8215 xcb_glx_gen_textures_cookie_t xcb_ret; 8216 xcb_glx_gen_textures_request_t xcb_out; 8217 8218 xcb_out.context_tag = context_tag; 8219 xcb_out.n = n; 8220 8221 xcb_parts[2].iov_base = (char *) &xcb_out; 8222 xcb_parts[2].iov_len = sizeof(xcb_out); 8223 xcb_parts[3].iov_base = 0; 8224 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8225 8226 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8227 return xcb_ret; 8228} 8229 8230uint32_t * 8231xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R) 8232{ 8233 return (uint32_t *) (R + 1); 8234} 8235 8236int 8237xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R) 8238{ 8239 return R->length; 8240} 8241 8242xcb_generic_iterator_t 8243xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R) 8244{ 8245 xcb_generic_iterator_t i; 8246 i.data = ((uint32_t *) (R + 1)) + (R->length); 8247 i.rem = 0; 8248 i.index = (char *) i.data - (char *) R; 8249 return i; 8250} 8251 8252xcb_glx_gen_textures_reply_t * 8253xcb_glx_gen_textures_reply (xcb_connection_t *c, 8254 xcb_glx_gen_textures_cookie_t cookie /**< */, 8255 xcb_generic_error_t **e) 8256{ 8257 return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8258} 8259 8260xcb_glx_is_texture_cookie_t 8261xcb_glx_is_texture (xcb_connection_t *c, 8262 xcb_glx_context_tag_t context_tag, 8263 uint32_t texture) 8264{ 8265 static const xcb_protocol_request_t xcb_req = { 8266 .count = 2, 8267 .ext = &xcb_glx_id, 8268 .opcode = XCB_GLX_IS_TEXTURE, 8269 .isvoid = 0 8270 }; 8271 8272 struct iovec xcb_parts[4]; 8273 xcb_glx_is_texture_cookie_t xcb_ret; 8274 xcb_glx_is_texture_request_t xcb_out; 8275 8276 xcb_out.context_tag = context_tag; 8277 xcb_out.texture = texture; 8278 8279 xcb_parts[2].iov_base = (char *) &xcb_out; 8280 xcb_parts[2].iov_len = sizeof(xcb_out); 8281 xcb_parts[3].iov_base = 0; 8282 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8283 8284 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8285 return xcb_ret; 8286} 8287 8288xcb_glx_is_texture_cookie_t 8289xcb_glx_is_texture_unchecked (xcb_connection_t *c, 8290 xcb_glx_context_tag_t context_tag, 8291 uint32_t texture) 8292{ 8293 static const xcb_protocol_request_t xcb_req = { 8294 .count = 2, 8295 .ext = &xcb_glx_id, 8296 .opcode = XCB_GLX_IS_TEXTURE, 8297 .isvoid = 0 8298 }; 8299 8300 struct iovec xcb_parts[4]; 8301 xcb_glx_is_texture_cookie_t xcb_ret; 8302 xcb_glx_is_texture_request_t xcb_out; 8303 8304 xcb_out.context_tag = context_tag; 8305 xcb_out.texture = texture; 8306 8307 xcb_parts[2].iov_base = (char *) &xcb_out; 8308 xcb_parts[2].iov_len = sizeof(xcb_out); 8309 xcb_parts[3].iov_base = 0; 8310 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8311 8312 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8313 return xcb_ret; 8314} 8315 8316xcb_glx_is_texture_reply_t * 8317xcb_glx_is_texture_reply (xcb_connection_t *c, 8318 xcb_glx_is_texture_cookie_t cookie /**< */, 8319 xcb_generic_error_t **e) 8320{ 8321 return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8322} 8323 8324int 8325xcb_glx_get_color_table_sizeof (const void *_buffer) 8326{ 8327 char *xcb_tmp = (char *)_buffer; 8328 const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer; 8329 unsigned int xcb_buffer_len = 0; 8330 unsigned int xcb_block_len = 0; 8331 unsigned int xcb_pad = 0; 8332 unsigned int xcb_align_to = 0; 8333 8334 8335 xcb_block_len += sizeof(xcb_glx_get_color_table_reply_t); 8336 xcb_tmp += xcb_block_len; 8337 xcb_buffer_len += xcb_block_len; 8338 xcb_block_len = 0; 8339 /* data */ 8340 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8341 xcb_tmp += xcb_block_len; 8342 xcb_align_to = ALIGNOF(uint8_t); 8343 /* insert padding */ 8344 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8345 xcb_buffer_len += xcb_block_len + xcb_pad; 8346 if (0 != xcb_pad) { 8347 xcb_tmp += xcb_pad; 8348 xcb_pad = 0; 8349 } 8350 xcb_block_len = 0; 8351 8352 return xcb_buffer_len; 8353} 8354 8355xcb_glx_get_color_table_cookie_t 8356xcb_glx_get_color_table (xcb_connection_t *c, 8357 xcb_glx_context_tag_t context_tag, 8358 uint32_t target, 8359 uint32_t format, 8360 uint32_t type, 8361 uint8_t swap_bytes) 8362{ 8363 static const xcb_protocol_request_t xcb_req = { 8364 .count = 2, 8365 .ext = &xcb_glx_id, 8366 .opcode = XCB_GLX_GET_COLOR_TABLE, 8367 .isvoid = 0 8368 }; 8369 8370 struct iovec xcb_parts[4]; 8371 xcb_glx_get_color_table_cookie_t xcb_ret; 8372 xcb_glx_get_color_table_request_t xcb_out; 8373 8374 xcb_out.context_tag = context_tag; 8375 xcb_out.target = target; 8376 xcb_out.format = format; 8377 xcb_out.type = type; 8378 xcb_out.swap_bytes = swap_bytes; 8379 8380 xcb_parts[2].iov_base = (char *) &xcb_out; 8381 xcb_parts[2].iov_len = sizeof(xcb_out); 8382 xcb_parts[3].iov_base = 0; 8383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8384 8385 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8386 return xcb_ret; 8387} 8388 8389xcb_glx_get_color_table_cookie_t 8390xcb_glx_get_color_table_unchecked (xcb_connection_t *c, 8391 xcb_glx_context_tag_t context_tag, 8392 uint32_t target, 8393 uint32_t format, 8394 uint32_t type, 8395 uint8_t swap_bytes) 8396{ 8397 static const xcb_protocol_request_t xcb_req = { 8398 .count = 2, 8399 .ext = &xcb_glx_id, 8400 .opcode = XCB_GLX_GET_COLOR_TABLE, 8401 .isvoid = 0 8402 }; 8403 8404 struct iovec xcb_parts[4]; 8405 xcb_glx_get_color_table_cookie_t xcb_ret; 8406 xcb_glx_get_color_table_request_t xcb_out; 8407 8408 xcb_out.context_tag = context_tag; 8409 xcb_out.target = target; 8410 xcb_out.format = format; 8411 xcb_out.type = type; 8412 xcb_out.swap_bytes = swap_bytes; 8413 8414 xcb_parts[2].iov_base = (char *) &xcb_out; 8415 xcb_parts[2].iov_len = sizeof(xcb_out); 8416 xcb_parts[3].iov_base = 0; 8417 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8418 8419 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8420 return xcb_ret; 8421} 8422 8423uint8_t * 8424xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R) 8425{ 8426 return (uint8_t *) (R + 1); 8427} 8428 8429int 8430xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R) 8431{ 8432 return (R->length * 4); 8433} 8434 8435xcb_generic_iterator_t 8436xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R) 8437{ 8438 xcb_generic_iterator_t i; 8439 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8440 i.rem = 0; 8441 i.index = (char *) i.data - (char *) R; 8442 return i; 8443} 8444 8445xcb_glx_get_color_table_reply_t * 8446xcb_glx_get_color_table_reply (xcb_connection_t *c, 8447 xcb_glx_get_color_table_cookie_t cookie /**< */, 8448 xcb_generic_error_t **e) 8449{ 8450 return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8451} 8452 8453int 8454xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer) 8455{ 8456 char *xcb_tmp = (char *)_buffer; 8457 const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer; 8458 unsigned int xcb_buffer_len = 0; 8459 unsigned int xcb_block_len = 0; 8460 unsigned int xcb_pad = 0; 8461 unsigned int xcb_align_to = 0; 8462 8463 8464 xcb_block_len += sizeof(xcb_glx_get_color_table_parameterfv_reply_t); 8465 xcb_tmp += xcb_block_len; 8466 xcb_buffer_len += xcb_block_len; 8467 xcb_block_len = 0; 8468 /* data */ 8469 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8470 xcb_tmp += xcb_block_len; 8471 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8472 /* insert padding */ 8473 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8474 xcb_buffer_len += xcb_block_len + xcb_pad; 8475 if (0 != xcb_pad) { 8476 xcb_tmp += xcb_pad; 8477 xcb_pad = 0; 8478 } 8479 xcb_block_len = 0; 8480 8481 return xcb_buffer_len; 8482} 8483 8484xcb_glx_get_color_table_parameterfv_cookie_t 8485xcb_glx_get_color_table_parameterfv (xcb_connection_t *c, 8486 xcb_glx_context_tag_t context_tag, 8487 uint32_t target, 8488 uint32_t pname) 8489{ 8490 static const xcb_protocol_request_t xcb_req = { 8491 .count = 2, 8492 .ext = &xcb_glx_id, 8493 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 8494 .isvoid = 0 8495 }; 8496 8497 struct iovec xcb_parts[4]; 8498 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 8499 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 8500 8501 xcb_out.context_tag = context_tag; 8502 xcb_out.target = target; 8503 xcb_out.pname = pname; 8504 8505 xcb_parts[2].iov_base = (char *) &xcb_out; 8506 xcb_parts[2].iov_len = sizeof(xcb_out); 8507 xcb_parts[3].iov_base = 0; 8508 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8509 8510 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8511 return xcb_ret; 8512} 8513 8514xcb_glx_get_color_table_parameterfv_cookie_t 8515xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c, 8516 xcb_glx_context_tag_t context_tag, 8517 uint32_t target, 8518 uint32_t pname) 8519{ 8520 static const xcb_protocol_request_t xcb_req = { 8521 .count = 2, 8522 .ext = &xcb_glx_id, 8523 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 8524 .isvoid = 0 8525 }; 8526 8527 struct iovec xcb_parts[4]; 8528 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 8529 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 8530 8531 xcb_out.context_tag = context_tag; 8532 xcb_out.target = target; 8533 xcb_out.pname = pname; 8534 8535 xcb_parts[2].iov_base = (char *) &xcb_out; 8536 xcb_parts[2].iov_len = sizeof(xcb_out); 8537 xcb_parts[3].iov_base = 0; 8538 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8539 8540 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8541 return xcb_ret; 8542} 8543 8544xcb_glx_float32_t * 8545xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8546{ 8547 return (xcb_glx_float32_t *) (R + 1); 8548} 8549 8550int 8551xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8552{ 8553 return R->n; 8554} 8555 8556xcb_generic_iterator_t 8557xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8558{ 8559 xcb_generic_iterator_t i; 8560 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8561 i.rem = 0; 8562 i.index = (char *) i.data - (char *) R; 8563 return i; 8564} 8565 8566xcb_glx_get_color_table_parameterfv_reply_t * 8567xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c, 8568 xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, 8569 xcb_generic_error_t **e) 8570{ 8571 return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8572} 8573 8574int 8575xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer) 8576{ 8577 char *xcb_tmp = (char *)_buffer; 8578 const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer; 8579 unsigned int xcb_buffer_len = 0; 8580 unsigned int xcb_block_len = 0; 8581 unsigned int xcb_pad = 0; 8582 unsigned int xcb_align_to = 0; 8583 8584 8585 xcb_block_len += sizeof(xcb_glx_get_color_table_parameteriv_reply_t); 8586 xcb_tmp += xcb_block_len; 8587 xcb_buffer_len += xcb_block_len; 8588 xcb_block_len = 0; 8589 /* data */ 8590 xcb_block_len += _aux->n * sizeof(int32_t); 8591 xcb_tmp += xcb_block_len; 8592 xcb_align_to = ALIGNOF(int32_t); 8593 /* insert padding */ 8594 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8595 xcb_buffer_len += xcb_block_len + xcb_pad; 8596 if (0 != xcb_pad) { 8597 xcb_tmp += xcb_pad; 8598 xcb_pad = 0; 8599 } 8600 xcb_block_len = 0; 8601 8602 return xcb_buffer_len; 8603} 8604 8605xcb_glx_get_color_table_parameteriv_cookie_t 8606xcb_glx_get_color_table_parameteriv (xcb_connection_t *c, 8607 xcb_glx_context_tag_t context_tag, 8608 uint32_t target, 8609 uint32_t pname) 8610{ 8611 static const xcb_protocol_request_t xcb_req = { 8612 .count = 2, 8613 .ext = &xcb_glx_id, 8614 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 8615 .isvoid = 0 8616 }; 8617 8618 struct iovec xcb_parts[4]; 8619 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 8620 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 8621 8622 xcb_out.context_tag = context_tag; 8623 xcb_out.target = target; 8624 xcb_out.pname = pname; 8625 8626 xcb_parts[2].iov_base = (char *) &xcb_out; 8627 xcb_parts[2].iov_len = sizeof(xcb_out); 8628 xcb_parts[3].iov_base = 0; 8629 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8630 8631 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8632 return xcb_ret; 8633} 8634 8635xcb_glx_get_color_table_parameteriv_cookie_t 8636xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c, 8637 xcb_glx_context_tag_t context_tag, 8638 uint32_t target, 8639 uint32_t pname) 8640{ 8641 static const xcb_protocol_request_t xcb_req = { 8642 .count = 2, 8643 .ext = &xcb_glx_id, 8644 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 8645 .isvoid = 0 8646 }; 8647 8648 struct iovec xcb_parts[4]; 8649 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 8650 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 8651 8652 xcb_out.context_tag = context_tag; 8653 xcb_out.target = target; 8654 xcb_out.pname = pname; 8655 8656 xcb_parts[2].iov_base = (char *) &xcb_out; 8657 xcb_parts[2].iov_len = sizeof(xcb_out); 8658 xcb_parts[3].iov_base = 0; 8659 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8660 8661 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8662 return xcb_ret; 8663} 8664 8665int32_t * 8666xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8667{ 8668 return (int32_t *) (R + 1); 8669} 8670 8671int 8672xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8673{ 8674 return R->n; 8675} 8676 8677xcb_generic_iterator_t 8678xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8679{ 8680 xcb_generic_iterator_t i; 8681 i.data = ((int32_t *) (R + 1)) + (R->n); 8682 i.rem = 0; 8683 i.index = (char *) i.data - (char *) R; 8684 return i; 8685} 8686 8687xcb_glx_get_color_table_parameteriv_reply_t * 8688xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c, 8689 xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, 8690 xcb_generic_error_t **e) 8691{ 8692 return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8693} 8694 8695int 8696xcb_glx_get_convolution_filter_sizeof (const void *_buffer) 8697{ 8698 char *xcb_tmp = (char *)_buffer; 8699 const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer; 8700 unsigned int xcb_buffer_len = 0; 8701 unsigned int xcb_block_len = 0; 8702 unsigned int xcb_pad = 0; 8703 unsigned int xcb_align_to = 0; 8704 8705 8706 xcb_block_len += sizeof(xcb_glx_get_convolution_filter_reply_t); 8707 xcb_tmp += xcb_block_len; 8708 xcb_buffer_len += xcb_block_len; 8709 xcb_block_len = 0; 8710 /* data */ 8711 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8712 xcb_tmp += xcb_block_len; 8713 xcb_align_to = ALIGNOF(uint8_t); 8714 /* insert padding */ 8715 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8716 xcb_buffer_len += xcb_block_len + xcb_pad; 8717 if (0 != xcb_pad) { 8718 xcb_tmp += xcb_pad; 8719 xcb_pad = 0; 8720 } 8721 xcb_block_len = 0; 8722 8723 return xcb_buffer_len; 8724} 8725 8726xcb_glx_get_convolution_filter_cookie_t 8727xcb_glx_get_convolution_filter (xcb_connection_t *c, 8728 xcb_glx_context_tag_t context_tag, 8729 uint32_t target, 8730 uint32_t format, 8731 uint32_t type, 8732 uint8_t swap_bytes) 8733{ 8734 static const xcb_protocol_request_t xcb_req = { 8735 .count = 2, 8736 .ext = &xcb_glx_id, 8737 .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, 8738 .isvoid = 0 8739 }; 8740 8741 struct iovec xcb_parts[4]; 8742 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 8743 xcb_glx_get_convolution_filter_request_t xcb_out; 8744 8745 xcb_out.context_tag = context_tag; 8746 xcb_out.target = target; 8747 xcb_out.format = format; 8748 xcb_out.type = type; 8749 xcb_out.swap_bytes = swap_bytes; 8750 8751 xcb_parts[2].iov_base = (char *) &xcb_out; 8752 xcb_parts[2].iov_len = sizeof(xcb_out); 8753 xcb_parts[3].iov_base = 0; 8754 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8755 8756 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8757 return xcb_ret; 8758} 8759 8760xcb_glx_get_convolution_filter_cookie_t 8761xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c, 8762 xcb_glx_context_tag_t context_tag, 8763 uint32_t target, 8764 uint32_t format, 8765 uint32_t type, 8766 uint8_t swap_bytes) 8767{ 8768 static const xcb_protocol_request_t xcb_req = { 8769 .count = 2, 8770 .ext = &xcb_glx_id, 8771 .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, 8772 .isvoid = 0 8773 }; 8774 8775 struct iovec xcb_parts[4]; 8776 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 8777 xcb_glx_get_convolution_filter_request_t xcb_out; 8778 8779 xcb_out.context_tag = context_tag; 8780 xcb_out.target = target; 8781 xcb_out.format = format; 8782 xcb_out.type = type; 8783 xcb_out.swap_bytes = swap_bytes; 8784 8785 xcb_parts[2].iov_base = (char *) &xcb_out; 8786 xcb_parts[2].iov_len = sizeof(xcb_out); 8787 xcb_parts[3].iov_base = 0; 8788 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8789 8790 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8791 return xcb_ret; 8792} 8793 8794uint8_t * 8795xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R) 8796{ 8797 return (uint8_t *) (R + 1); 8798} 8799 8800int 8801xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R) 8802{ 8803 return (R->length * 4); 8804} 8805 8806xcb_generic_iterator_t 8807xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R) 8808{ 8809 xcb_generic_iterator_t i; 8810 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8811 i.rem = 0; 8812 i.index = (char *) i.data - (char *) R; 8813 return i; 8814} 8815 8816xcb_glx_get_convolution_filter_reply_t * 8817xcb_glx_get_convolution_filter_reply (xcb_connection_t *c, 8818 xcb_glx_get_convolution_filter_cookie_t cookie /**< */, 8819 xcb_generic_error_t **e) 8820{ 8821 return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8822} 8823 8824int 8825xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer) 8826{ 8827 char *xcb_tmp = (char *)_buffer; 8828 const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer; 8829 unsigned int xcb_buffer_len = 0; 8830 unsigned int xcb_block_len = 0; 8831 unsigned int xcb_pad = 0; 8832 unsigned int xcb_align_to = 0; 8833 8834 8835 xcb_block_len += sizeof(xcb_glx_get_convolution_parameterfv_reply_t); 8836 xcb_tmp += xcb_block_len; 8837 xcb_buffer_len += xcb_block_len; 8838 xcb_block_len = 0; 8839 /* data */ 8840 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8841 xcb_tmp += xcb_block_len; 8842 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8843 /* insert padding */ 8844 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8845 xcb_buffer_len += xcb_block_len + xcb_pad; 8846 if (0 != xcb_pad) { 8847 xcb_tmp += xcb_pad; 8848 xcb_pad = 0; 8849 } 8850 xcb_block_len = 0; 8851 8852 return xcb_buffer_len; 8853} 8854 8855xcb_glx_get_convolution_parameterfv_cookie_t 8856xcb_glx_get_convolution_parameterfv (xcb_connection_t *c, 8857 xcb_glx_context_tag_t context_tag, 8858 uint32_t target, 8859 uint32_t pname) 8860{ 8861 static const xcb_protocol_request_t xcb_req = { 8862 .count = 2, 8863 .ext = &xcb_glx_id, 8864 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 8865 .isvoid = 0 8866 }; 8867 8868 struct iovec xcb_parts[4]; 8869 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 8870 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 8871 8872 xcb_out.context_tag = context_tag; 8873 xcb_out.target = target; 8874 xcb_out.pname = pname; 8875 8876 xcb_parts[2].iov_base = (char *) &xcb_out; 8877 xcb_parts[2].iov_len = sizeof(xcb_out); 8878 xcb_parts[3].iov_base = 0; 8879 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8880 8881 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8882 return xcb_ret; 8883} 8884 8885xcb_glx_get_convolution_parameterfv_cookie_t 8886xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c, 8887 xcb_glx_context_tag_t context_tag, 8888 uint32_t target, 8889 uint32_t pname) 8890{ 8891 static const xcb_protocol_request_t xcb_req = { 8892 .count = 2, 8893 .ext = &xcb_glx_id, 8894 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 8895 .isvoid = 0 8896 }; 8897 8898 struct iovec xcb_parts[4]; 8899 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 8900 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 8901 8902 xcb_out.context_tag = context_tag; 8903 xcb_out.target = target; 8904 xcb_out.pname = pname; 8905 8906 xcb_parts[2].iov_base = (char *) &xcb_out; 8907 xcb_parts[2].iov_len = sizeof(xcb_out); 8908 xcb_parts[3].iov_base = 0; 8909 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8910 8911 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8912 return xcb_ret; 8913} 8914 8915xcb_glx_float32_t * 8916xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8917{ 8918 return (xcb_glx_float32_t *) (R + 1); 8919} 8920 8921int 8922xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8923{ 8924 return R->n; 8925} 8926 8927xcb_generic_iterator_t 8928xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8929{ 8930 xcb_generic_iterator_t i; 8931 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8932 i.rem = 0; 8933 i.index = (char *) i.data - (char *) R; 8934 return i; 8935} 8936 8937xcb_glx_get_convolution_parameterfv_reply_t * 8938xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c, 8939 xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, 8940 xcb_generic_error_t **e) 8941{ 8942 return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8943} 8944 8945int 8946xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer) 8947{ 8948 char *xcb_tmp = (char *)_buffer; 8949 const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer; 8950 unsigned int xcb_buffer_len = 0; 8951 unsigned int xcb_block_len = 0; 8952 unsigned int xcb_pad = 0; 8953 unsigned int xcb_align_to = 0; 8954 8955 8956 xcb_block_len += sizeof(xcb_glx_get_convolution_parameteriv_reply_t); 8957 xcb_tmp += xcb_block_len; 8958 xcb_buffer_len += xcb_block_len; 8959 xcb_block_len = 0; 8960 /* data */ 8961 xcb_block_len += _aux->n * sizeof(int32_t); 8962 xcb_tmp += xcb_block_len; 8963 xcb_align_to = ALIGNOF(int32_t); 8964 /* insert padding */ 8965 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8966 xcb_buffer_len += xcb_block_len + xcb_pad; 8967 if (0 != xcb_pad) { 8968 xcb_tmp += xcb_pad; 8969 xcb_pad = 0; 8970 } 8971 xcb_block_len = 0; 8972 8973 return xcb_buffer_len; 8974} 8975 8976xcb_glx_get_convolution_parameteriv_cookie_t 8977xcb_glx_get_convolution_parameteriv (xcb_connection_t *c, 8978 xcb_glx_context_tag_t context_tag, 8979 uint32_t target, 8980 uint32_t pname) 8981{ 8982 static const xcb_protocol_request_t xcb_req = { 8983 .count = 2, 8984 .ext = &xcb_glx_id, 8985 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 8986 .isvoid = 0 8987 }; 8988 8989 struct iovec xcb_parts[4]; 8990 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 8991 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 8992 8993 xcb_out.context_tag = context_tag; 8994 xcb_out.target = target; 8995 xcb_out.pname = pname; 8996 8997 xcb_parts[2].iov_base = (char *) &xcb_out; 8998 xcb_parts[2].iov_len = sizeof(xcb_out); 8999 xcb_parts[3].iov_base = 0; 9000 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9001 9002 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9003 return xcb_ret; 9004} 9005 9006xcb_glx_get_convolution_parameteriv_cookie_t 9007xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c, 9008 xcb_glx_context_tag_t context_tag, 9009 uint32_t target, 9010 uint32_t pname) 9011{ 9012 static const xcb_protocol_request_t xcb_req = { 9013 .count = 2, 9014 .ext = &xcb_glx_id, 9015 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 9016 .isvoid = 0 9017 }; 9018 9019 struct iovec xcb_parts[4]; 9020 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 9021 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 9022 9023 xcb_out.context_tag = context_tag; 9024 xcb_out.target = target; 9025 xcb_out.pname = pname; 9026 9027 xcb_parts[2].iov_base = (char *) &xcb_out; 9028 xcb_parts[2].iov_len = sizeof(xcb_out); 9029 xcb_parts[3].iov_base = 0; 9030 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9031 9032 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9033 return xcb_ret; 9034} 9035 9036int32_t * 9037xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9038{ 9039 return (int32_t *) (R + 1); 9040} 9041 9042int 9043xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9044{ 9045 return R->n; 9046} 9047 9048xcb_generic_iterator_t 9049xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9050{ 9051 xcb_generic_iterator_t i; 9052 i.data = ((int32_t *) (R + 1)) + (R->n); 9053 i.rem = 0; 9054 i.index = (char *) i.data - (char *) R; 9055 return i; 9056} 9057 9058xcb_glx_get_convolution_parameteriv_reply_t * 9059xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c, 9060 xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, 9061 xcb_generic_error_t **e) 9062{ 9063 return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9064} 9065 9066int 9067xcb_glx_get_separable_filter_sizeof (const void *_buffer) 9068{ 9069 char *xcb_tmp = (char *)_buffer; 9070 const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer; 9071 unsigned int xcb_buffer_len = 0; 9072 unsigned int xcb_block_len = 0; 9073 unsigned int xcb_pad = 0; 9074 unsigned int xcb_align_to = 0; 9075 9076 9077 xcb_block_len += sizeof(xcb_glx_get_separable_filter_reply_t); 9078 xcb_tmp += xcb_block_len; 9079 xcb_buffer_len += xcb_block_len; 9080 xcb_block_len = 0; 9081 /* rows_and_cols */ 9082 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9083 xcb_tmp += xcb_block_len; 9084 xcb_align_to = ALIGNOF(uint8_t); 9085 /* insert padding */ 9086 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9087 xcb_buffer_len += xcb_block_len + xcb_pad; 9088 if (0 != xcb_pad) { 9089 xcb_tmp += xcb_pad; 9090 xcb_pad = 0; 9091 } 9092 xcb_block_len = 0; 9093 9094 return xcb_buffer_len; 9095} 9096 9097xcb_glx_get_separable_filter_cookie_t 9098xcb_glx_get_separable_filter (xcb_connection_t *c, 9099 xcb_glx_context_tag_t context_tag, 9100 uint32_t target, 9101 uint32_t format, 9102 uint32_t type, 9103 uint8_t swap_bytes) 9104{ 9105 static const xcb_protocol_request_t xcb_req = { 9106 .count = 2, 9107 .ext = &xcb_glx_id, 9108 .opcode = XCB_GLX_GET_SEPARABLE_FILTER, 9109 .isvoid = 0 9110 }; 9111 9112 struct iovec xcb_parts[4]; 9113 xcb_glx_get_separable_filter_cookie_t xcb_ret; 9114 xcb_glx_get_separable_filter_request_t xcb_out; 9115 9116 xcb_out.context_tag = context_tag; 9117 xcb_out.target = target; 9118 xcb_out.format = format; 9119 xcb_out.type = type; 9120 xcb_out.swap_bytes = swap_bytes; 9121 9122 xcb_parts[2].iov_base = (char *) &xcb_out; 9123 xcb_parts[2].iov_len = sizeof(xcb_out); 9124 xcb_parts[3].iov_base = 0; 9125 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9126 9127 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9128 return xcb_ret; 9129} 9130 9131xcb_glx_get_separable_filter_cookie_t 9132xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c, 9133 xcb_glx_context_tag_t context_tag, 9134 uint32_t target, 9135 uint32_t format, 9136 uint32_t type, 9137 uint8_t swap_bytes) 9138{ 9139 static const xcb_protocol_request_t xcb_req = { 9140 .count = 2, 9141 .ext = &xcb_glx_id, 9142 .opcode = XCB_GLX_GET_SEPARABLE_FILTER, 9143 .isvoid = 0 9144 }; 9145 9146 struct iovec xcb_parts[4]; 9147 xcb_glx_get_separable_filter_cookie_t xcb_ret; 9148 xcb_glx_get_separable_filter_request_t xcb_out; 9149 9150 xcb_out.context_tag = context_tag; 9151 xcb_out.target = target; 9152 xcb_out.format = format; 9153 xcb_out.type = type; 9154 xcb_out.swap_bytes = swap_bytes; 9155 9156 xcb_parts[2].iov_base = (char *) &xcb_out; 9157 xcb_parts[2].iov_len = sizeof(xcb_out); 9158 xcb_parts[3].iov_base = 0; 9159 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9160 9161 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9162 return xcb_ret; 9163} 9164 9165uint8_t * 9166xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R) 9167{ 9168 return (uint8_t *) (R + 1); 9169} 9170 9171int 9172xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R) 9173{ 9174 return (R->length * 4); 9175} 9176 9177xcb_generic_iterator_t 9178xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R) 9179{ 9180 xcb_generic_iterator_t i; 9181 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9182 i.rem = 0; 9183 i.index = (char *) i.data - (char *) R; 9184 return i; 9185} 9186 9187xcb_glx_get_separable_filter_reply_t * 9188xcb_glx_get_separable_filter_reply (xcb_connection_t *c, 9189 xcb_glx_get_separable_filter_cookie_t cookie /**< */, 9190 xcb_generic_error_t **e) 9191{ 9192 return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9193} 9194 9195int 9196xcb_glx_get_histogram_sizeof (const void *_buffer) 9197{ 9198 char *xcb_tmp = (char *)_buffer; 9199 const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer; 9200 unsigned int xcb_buffer_len = 0; 9201 unsigned int xcb_block_len = 0; 9202 unsigned int xcb_pad = 0; 9203 unsigned int xcb_align_to = 0; 9204 9205 9206 xcb_block_len += sizeof(xcb_glx_get_histogram_reply_t); 9207 xcb_tmp += xcb_block_len; 9208 xcb_buffer_len += xcb_block_len; 9209 xcb_block_len = 0; 9210 /* data */ 9211 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9212 xcb_tmp += xcb_block_len; 9213 xcb_align_to = ALIGNOF(uint8_t); 9214 /* insert padding */ 9215 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9216 xcb_buffer_len += xcb_block_len + xcb_pad; 9217 if (0 != xcb_pad) { 9218 xcb_tmp += xcb_pad; 9219 xcb_pad = 0; 9220 } 9221 xcb_block_len = 0; 9222 9223 return xcb_buffer_len; 9224} 9225 9226xcb_glx_get_histogram_cookie_t 9227xcb_glx_get_histogram (xcb_connection_t *c, 9228 xcb_glx_context_tag_t context_tag, 9229 uint32_t target, 9230 uint32_t format, 9231 uint32_t type, 9232 uint8_t swap_bytes, 9233 uint8_t reset) 9234{ 9235 static const xcb_protocol_request_t xcb_req = { 9236 .count = 2, 9237 .ext = &xcb_glx_id, 9238 .opcode = XCB_GLX_GET_HISTOGRAM, 9239 .isvoid = 0 9240 }; 9241 9242 struct iovec xcb_parts[4]; 9243 xcb_glx_get_histogram_cookie_t xcb_ret; 9244 xcb_glx_get_histogram_request_t xcb_out; 9245 9246 xcb_out.context_tag = context_tag; 9247 xcb_out.target = target; 9248 xcb_out.format = format; 9249 xcb_out.type = type; 9250 xcb_out.swap_bytes = swap_bytes; 9251 xcb_out.reset = reset; 9252 9253 xcb_parts[2].iov_base = (char *) &xcb_out; 9254 xcb_parts[2].iov_len = sizeof(xcb_out); 9255 xcb_parts[3].iov_base = 0; 9256 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9257 9258 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9259 return xcb_ret; 9260} 9261 9262xcb_glx_get_histogram_cookie_t 9263xcb_glx_get_histogram_unchecked (xcb_connection_t *c, 9264 xcb_glx_context_tag_t context_tag, 9265 uint32_t target, 9266 uint32_t format, 9267 uint32_t type, 9268 uint8_t swap_bytes, 9269 uint8_t reset) 9270{ 9271 static const xcb_protocol_request_t xcb_req = { 9272 .count = 2, 9273 .ext = &xcb_glx_id, 9274 .opcode = XCB_GLX_GET_HISTOGRAM, 9275 .isvoid = 0 9276 }; 9277 9278 struct iovec xcb_parts[4]; 9279 xcb_glx_get_histogram_cookie_t xcb_ret; 9280 xcb_glx_get_histogram_request_t xcb_out; 9281 9282 xcb_out.context_tag = context_tag; 9283 xcb_out.target = target; 9284 xcb_out.format = format; 9285 xcb_out.type = type; 9286 xcb_out.swap_bytes = swap_bytes; 9287 xcb_out.reset = reset; 9288 9289 xcb_parts[2].iov_base = (char *) &xcb_out; 9290 xcb_parts[2].iov_len = sizeof(xcb_out); 9291 xcb_parts[3].iov_base = 0; 9292 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9293 9294 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9295 return xcb_ret; 9296} 9297 9298uint8_t * 9299xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R) 9300{ 9301 return (uint8_t *) (R + 1); 9302} 9303 9304int 9305xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R) 9306{ 9307 return (R->length * 4); 9308} 9309 9310xcb_generic_iterator_t 9311xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R) 9312{ 9313 xcb_generic_iterator_t i; 9314 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9315 i.rem = 0; 9316 i.index = (char *) i.data - (char *) R; 9317 return i; 9318} 9319 9320xcb_glx_get_histogram_reply_t * 9321xcb_glx_get_histogram_reply (xcb_connection_t *c, 9322 xcb_glx_get_histogram_cookie_t cookie /**< */, 9323 xcb_generic_error_t **e) 9324{ 9325 return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9326} 9327 9328int 9329xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer) 9330{ 9331 char *xcb_tmp = (char *)_buffer; 9332 const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer; 9333 unsigned int xcb_buffer_len = 0; 9334 unsigned int xcb_block_len = 0; 9335 unsigned int xcb_pad = 0; 9336 unsigned int xcb_align_to = 0; 9337 9338 9339 xcb_block_len += sizeof(xcb_glx_get_histogram_parameterfv_reply_t); 9340 xcb_tmp += xcb_block_len; 9341 xcb_buffer_len += xcb_block_len; 9342 xcb_block_len = 0; 9343 /* data */ 9344 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9345 xcb_tmp += xcb_block_len; 9346 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9347 /* insert padding */ 9348 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9349 xcb_buffer_len += xcb_block_len + xcb_pad; 9350 if (0 != xcb_pad) { 9351 xcb_tmp += xcb_pad; 9352 xcb_pad = 0; 9353 } 9354 xcb_block_len = 0; 9355 9356 return xcb_buffer_len; 9357} 9358 9359xcb_glx_get_histogram_parameterfv_cookie_t 9360xcb_glx_get_histogram_parameterfv (xcb_connection_t *c, 9361 xcb_glx_context_tag_t context_tag, 9362 uint32_t target, 9363 uint32_t pname) 9364{ 9365 static const xcb_protocol_request_t xcb_req = { 9366 .count = 2, 9367 .ext = &xcb_glx_id, 9368 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 9369 .isvoid = 0 9370 }; 9371 9372 struct iovec xcb_parts[4]; 9373 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 9374 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 9375 9376 xcb_out.context_tag = context_tag; 9377 xcb_out.target = target; 9378 xcb_out.pname = pname; 9379 9380 xcb_parts[2].iov_base = (char *) &xcb_out; 9381 xcb_parts[2].iov_len = sizeof(xcb_out); 9382 xcb_parts[3].iov_base = 0; 9383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9384 9385 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9386 return xcb_ret; 9387} 9388 9389xcb_glx_get_histogram_parameterfv_cookie_t 9390xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c, 9391 xcb_glx_context_tag_t context_tag, 9392 uint32_t target, 9393 uint32_t pname) 9394{ 9395 static const xcb_protocol_request_t xcb_req = { 9396 .count = 2, 9397 .ext = &xcb_glx_id, 9398 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 9399 .isvoid = 0 9400 }; 9401 9402 struct iovec xcb_parts[4]; 9403 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 9404 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 9405 9406 xcb_out.context_tag = context_tag; 9407 xcb_out.target = target; 9408 xcb_out.pname = pname; 9409 9410 xcb_parts[2].iov_base = (char *) &xcb_out; 9411 xcb_parts[2].iov_len = sizeof(xcb_out); 9412 xcb_parts[3].iov_base = 0; 9413 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9414 9415 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9416 return xcb_ret; 9417} 9418 9419xcb_glx_float32_t * 9420xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9421{ 9422 return (xcb_glx_float32_t *) (R + 1); 9423} 9424 9425int 9426xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9427{ 9428 return R->n; 9429} 9430 9431xcb_generic_iterator_t 9432xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9433{ 9434 xcb_generic_iterator_t i; 9435 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9436 i.rem = 0; 9437 i.index = (char *) i.data - (char *) R; 9438 return i; 9439} 9440 9441xcb_glx_get_histogram_parameterfv_reply_t * 9442xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c, 9443 xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, 9444 xcb_generic_error_t **e) 9445{ 9446 return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9447} 9448 9449int 9450xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer) 9451{ 9452 char *xcb_tmp = (char *)_buffer; 9453 const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer; 9454 unsigned int xcb_buffer_len = 0; 9455 unsigned int xcb_block_len = 0; 9456 unsigned int xcb_pad = 0; 9457 unsigned int xcb_align_to = 0; 9458 9459 9460 xcb_block_len += sizeof(xcb_glx_get_histogram_parameteriv_reply_t); 9461 xcb_tmp += xcb_block_len; 9462 xcb_buffer_len += xcb_block_len; 9463 xcb_block_len = 0; 9464 /* data */ 9465 xcb_block_len += _aux->n * sizeof(int32_t); 9466 xcb_tmp += xcb_block_len; 9467 xcb_align_to = ALIGNOF(int32_t); 9468 /* insert padding */ 9469 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9470 xcb_buffer_len += xcb_block_len + xcb_pad; 9471 if (0 != xcb_pad) { 9472 xcb_tmp += xcb_pad; 9473 xcb_pad = 0; 9474 } 9475 xcb_block_len = 0; 9476 9477 return xcb_buffer_len; 9478} 9479 9480xcb_glx_get_histogram_parameteriv_cookie_t 9481xcb_glx_get_histogram_parameteriv (xcb_connection_t *c, 9482 xcb_glx_context_tag_t context_tag, 9483 uint32_t target, 9484 uint32_t pname) 9485{ 9486 static const xcb_protocol_request_t xcb_req = { 9487 .count = 2, 9488 .ext = &xcb_glx_id, 9489 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 9490 .isvoid = 0 9491 }; 9492 9493 struct iovec xcb_parts[4]; 9494 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 9495 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 9496 9497 xcb_out.context_tag = context_tag; 9498 xcb_out.target = target; 9499 xcb_out.pname = pname; 9500 9501 xcb_parts[2].iov_base = (char *) &xcb_out; 9502 xcb_parts[2].iov_len = sizeof(xcb_out); 9503 xcb_parts[3].iov_base = 0; 9504 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9505 9506 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9507 return xcb_ret; 9508} 9509 9510xcb_glx_get_histogram_parameteriv_cookie_t 9511xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c, 9512 xcb_glx_context_tag_t context_tag, 9513 uint32_t target, 9514 uint32_t pname) 9515{ 9516 static const xcb_protocol_request_t xcb_req = { 9517 .count = 2, 9518 .ext = &xcb_glx_id, 9519 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 9520 .isvoid = 0 9521 }; 9522 9523 struct iovec xcb_parts[4]; 9524 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 9525 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 9526 9527 xcb_out.context_tag = context_tag; 9528 xcb_out.target = target; 9529 xcb_out.pname = pname; 9530 9531 xcb_parts[2].iov_base = (char *) &xcb_out; 9532 xcb_parts[2].iov_len = sizeof(xcb_out); 9533 xcb_parts[3].iov_base = 0; 9534 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9535 9536 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9537 return xcb_ret; 9538} 9539 9540int32_t * 9541xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9542{ 9543 return (int32_t *) (R + 1); 9544} 9545 9546int 9547xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9548{ 9549 return R->n; 9550} 9551 9552xcb_generic_iterator_t 9553xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9554{ 9555 xcb_generic_iterator_t i; 9556 i.data = ((int32_t *) (R + 1)) + (R->n); 9557 i.rem = 0; 9558 i.index = (char *) i.data - (char *) R; 9559 return i; 9560} 9561 9562xcb_glx_get_histogram_parameteriv_reply_t * 9563xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c, 9564 xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, 9565 xcb_generic_error_t **e) 9566{ 9567 return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9568} 9569 9570int 9571xcb_glx_get_minmax_sizeof (const void *_buffer) 9572{ 9573 char *xcb_tmp = (char *)_buffer; 9574 const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer; 9575 unsigned int xcb_buffer_len = 0; 9576 unsigned int xcb_block_len = 0; 9577 unsigned int xcb_pad = 0; 9578 unsigned int xcb_align_to = 0; 9579 9580 9581 xcb_block_len += sizeof(xcb_glx_get_minmax_reply_t); 9582 xcb_tmp += xcb_block_len; 9583 xcb_buffer_len += xcb_block_len; 9584 xcb_block_len = 0; 9585 /* data */ 9586 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9587 xcb_tmp += xcb_block_len; 9588 xcb_align_to = ALIGNOF(uint8_t); 9589 /* insert padding */ 9590 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9591 xcb_buffer_len += xcb_block_len + xcb_pad; 9592 if (0 != xcb_pad) { 9593 xcb_tmp += xcb_pad; 9594 xcb_pad = 0; 9595 } 9596 xcb_block_len = 0; 9597 9598 return xcb_buffer_len; 9599} 9600 9601xcb_glx_get_minmax_cookie_t 9602xcb_glx_get_minmax (xcb_connection_t *c, 9603 xcb_glx_context_tag_t context_tag, 9604 uint32_t target, 9605 uint32_t format, 9606 uint32_t type, 9607 uint8_t swap_bytes, 9608 uint8_t reset) 9609{ 9610 static const xcb_protocol_request_t xcb_req = { 9611 .count = 2, 9612 .ext = &xcb_glx_id, 9613 .opcode = XCB_GLX_GET_MINMAX, 9614 .isvoid = 0 9615 }; 9616 9617 struct iovec xcb_parts[4]; 9618 xcb_glx_get_minmax_cookie_t xcb_ret; 9619 xcb_glx_get_minmax_request_t xcb_out; 9620 9621 xcb_out.context_tag = context_tag; 9622 xcb_out.target = target; 9623 xcb_out.format = format; 9624 xcb_out.type = type; 9625 xcb_out.swap_bytes = swap_bytes; 9626 xcb_out.reset = reset; 9627 9628 xcb_parts[2].iov_base = (char *) &xcb_out; 9629 xcb_parts[2].iov_len = sizeof(xcb_out); 9630 xcb_parts[3].iov_base = 0; 9631 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9632 9633 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9634 return xcb_ret; 9635} 9636 9637xcb_glx_get_minmax_cookie_t 9638xcb_glx_get_minmax_unchecked (xcb_connection_t *c, 9639 xcb_glx_context_tag_t context_tag, 9640 uint32_t target, 9641 uint32_t format, 9642 uint32_t type, 9643 uint8_t swap_bytes, 9644 uint8_t reset) 9645{ 9646 static const xcb_protocol_request_t xcb_req = { 9647 .count = 2, 9648 .ext = &xcb_glx_id, 9649 .opcode = XCB_GLX_GET_MINMAX, 9650 .isvoid = 0 9651 }; 9652 9653 struct iovec xcb_parts[4]; 9654 xcb_glx_get_minmax_cookie_t xcb_ret; 9655 xcb_glx_get_minmax_request_t xcb_out; 9656 9657 xcb_out.context_tag = context_tag; 9658 xcb_out.target = target; 9659 xcb_out.format = format; 9660 xcb_out.type = type; 9661 xcb_out.swap_bytes = swap_bytes; 9662 xcb_out.reset = reset; 9663 9664 xcb_parts[2].iov_base = (char *) &xcb_out; 9665 xcb_parts[2].iov_len = sizeof(xcb_out); 9666 xcb_parts[3].iov_base = 0; 9667 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9668 9669 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9670 return xcb_ret; 9671} 9672 9673uint8_t * 9674xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R) 9675{ 9676 return (uint8_t *) (R + 1); 9677} 9678 9679int 9680xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R) 9681{ 9682 return (R->length * 4); 9683} 9684 9685xcb_generic_iterator_t 9686xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R) 9687{ 9688 xcb_generic_iterator_t i; 9689 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9690 i.rem = 0; 9691 i.index = (char *) i.data - (char *) R; 9692 return i; 9693} 9694 9695xcb_glx_get_minmax_reply_t * 9696xcb_glx_get_minmax_reply (xcb_connection_t *c, 9697 xcb_glx_get_minmax_cookie_t cookie /**< */, 9698 xcb_generic_error_t **e) 9699{ 9700 return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9701} 9702 9703int 9704xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer) 9705{ 9706 char *xcb_tmp = (char *)_buffer; 9707 const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer; 9708 unsigned int xcb_buffer_len = 0; 9709 unsigned int xcb_block_len = 0; 9710 unsigned int xcb_pad = 0; 9711 unsigned int xcb_align_to = 0; 9712 9713 9714 xcb_block_len += sizeof(xcb_glx_get_minmax_parameterfv_reply_t); 9715 xcb_tmp += xcb_block_len; 9716 xcb_buffer_len += xcb_block_len; 9717 xcb_block_len = 0; 9718 /* data */ 9719 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9720 xcb_tmp += xcb_block_len; 9721 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9722 /* insert padding */ 9723 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9724 xcb_buffer_len += xcb_block_len + xcb_pad; 9725 if (0 != xcb_pad) { 9726 xcb_tmp += xcb_pad; 9727 xcb_pad = 0; 9728 } 9729 xcb_block_len = 0; 9730 9731 return xcb_buffer_len; 9732} 9733 9734xcb_glx_get_minmax_parameterfv_cookie_t 9735xcb_glx_get_minmax_parameterfv (xcb_connection_t *c, 9736 xcb_glx_context_tag_t context_tag, 9737 uint32_t target, 9738 uint32_t pname) 9739{ 9740 static const xcb_protocol_request_t xcb_req = { 9741 .count = 2, 9742 .ext = &xcb_glx_id, 9743 .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, 9744 .isvoid = 0 9745 }; 9746 9747 struct iovec xcb_parts[4]; 9748 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 9749 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 9750 9751 xcb_out.context_tag = context_tag; 9752 xcb_out.target = target; 9753 xcb_out.pname = pname; 9754 9755 xcb_parts[2].iov_base = (char *) &xcb_out; 9756 xcb_parts[2].iov_len = sizeof(xcb_out); 9757 xcb_parts[3].iov_base = 0; 9758 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9759 9760 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9761 return xcb_ret; 9762} 9763 9764xcb_glx_get_minmax_parameterfv_cookie_t 9765xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c, 9766 xcb_glx_context_tag_t context_tag, 9767 uint32_t target, 9768 uint32_t pname) 9769{ 9770 static const xcb_protocol_request_t xcb_req = { 9771 .count = 2, 9772 .ext = &xcb_glx_id, 9773 .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, 9774 .isvoid = 0 9775 }; 9776 9777 struct iovec xcb_parts[4]; 9778 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 9779 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 9780 9781 xcb_out.context_tag = context_tag; 9782 xcb_out.target = target; 9783 xcb_out.pname = pname; 9784 9785 xcb_parts[2].iov_base = (char *) &xcb_out; 9786 xcb_parts[2].iov_len = sizeof(xcb_out); 9787 xcb_parts[3].iov_base = 0; 9788 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9789 9790 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9791 return xcb_ret; 9792} 9793 9794xcb_glx_float32_t * 9795xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9796{ 9797 return (xcb_glx_float32_t *) (R + 1); 9798} 9799 9800int 9801xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9802{ 9803 return R->n; 9804} 9805 9806xcb_generic_iterator_t 9807xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9808{ 9809 xcb_generic_iterator_t i; 9810 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9811 i.rem = 0; 9812 i.index = (char *) i.data - (char *) R; 9813 return i; 9814} 9815 9816xcb_glx_get_minmax_parameterfv_reply_t * 9817xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c, 9818 xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, 9819 xcb_generic_error_t **e) 9820{ 9821 return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9822} 9823 9824int 9825xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer) 9826{ 9827 char *xcb_tmp = (char *)_buffer; 9828 const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer; 9829 unsigned int xcb_buffer_len = 0; 9830 unsigned int xcb_block_len = 0; 9831 unsigned int xcb_pad = 0; 9832 unsigned int xcb_align_to = 0; 9833 9834 9835 xcb_block_len += sizeof(xcb_glx_get_minmax_parameteriv_reply_t); 9836 xcb_tmp += xcb_block_len; 9837 xcb_buffer_len += xcb_block_len; 9838 xcb_block_len = 0; 9839 /* data */ 9840 xcb_block_len += _aux->n * sizeof(int32_t); 9841 xcb_tmp += xcb_block_len; 9842 xcb_align_to = ALIGNOF(int32_t); 9843 /* insert padding */ 9844 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9845 xcb_buffer_len += xcb_block_len + xcb_pad; 9846 if (0 != xcb_pad) { 9847 xcb_tmp += xcb_pad; 9848 xcb_pad = 0; 9849 } 9850 xcb_block_len = 0; 9851 9852 return xcb_buffer_len; 9853} 9854 9855xcb_glx_get_minmax_parameteriv_cookie_t 9856xcb_glx_get_minmax_parameteriv (xcb_connection_t *c, 9857 xcb_glx_context_tag_t context_tag, 9858 uint32_t target, 9859 uint32_t pname) 9860{ 9861 static const xcb_protocol_request_t xcb_req = { 9862 .count = 2, 9863 .ext = &xcb_glx_id, 9864 .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, 9865 .isvoid = 0 9866 }; 9867 9868 struct iovec xcb_parts[4]; 9869 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 9870 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 9871 9872 xcb_out.context_tag = context_tag; 9873 xcb_out.target = target; 9874 xcb_out.pname = pname; 9875 9876 xcb_parts[2].iov_base = (char *) &xcb_out; 9877 xcb_parts[2].iov_len = sizeof(xcb_out); 9878 xcb_parts[3].iov_base = 0; 9879 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9880 9881 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9882 return xcb_ret; 9883} 9884 9885xcb_glx_get_minmax_parameteriv_cookie_t 9886xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c, 9887 xcb_glx_context_tag_t context_tag, 9888 uint32_t target, 9889 uint32_t pname) 9890{ 9891 static const xcb_protocol_request_t xcb_req = { 9892 .count = 2, 9893 .ext = &xcb_glx_id, 9894 .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, 9895 .isvoid = 0 9896 }; 9897 9898 struct iovec xcb_parts[4]; 9899 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 9900 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 9901 9902 xcb_out.context_tag = context_tag; 9903 xcb_out.target = target; 9904 xcb_out.pname = pname; 9905 9906 xcb_parts[2].iov_base = (char *) &xcb_out; 9907 xcb_parts[2].iov_len = sizeof(xcb_out); 9908 xcb_parts[3].iov_base = 0; 9909 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9910 9911 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9912 return xcb_ret; 9913} 9914 9915int32_t * 9916xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9917{ 9918 return (int32_t *) (R + 1); 9919} 9920 9921int 9922xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9923{ 9924 return R->n; 9925} 9926 9927xcb_generic_iterator_t 9928xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9929{ 9930 xcb_generic_iterator_t i; 9931 i.data = ((int32_t *) (R + 1)) + (R->n); 9932 i.rem = 0; 9933 i.index = (char *) i.data - (char *) R; 9934 return i; 9935} 9936 9937xcb_glx_get_minmax_parameteriv_reply_t * 9938xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c, 9939 xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, 9940 xcb_generic_error_t **e) 9941{ 9942 return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9943} 9944 9945int 9946xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer) 9947{ 9948 char *xcb_tmp = (char *)_buffer; 9949 const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer; 9950 unsigned int xcb_buffer_len = 0; 9951 unsigned int xcb_block_len = 0; 9952 unsigned int xcb_pad = 0; 9953 unsigned int xcb_align_to = 0; 9954 9955 9956 xcb_block_len += sizeof(xcb_glx_get_compressed_tex_image_arb_reply_t); 9957 xcb_tmp += xcb_block_len; 9958 xcb_buffer_len += xcb_block_len; 9959 xcb_block_len = 0; 9960 /* data */ 9961 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9962 xcb_tmp += xcb_block_len; 9963 xcb_align_to = ALIGNOF(uint8_t); 9964 /* insert padding */ 9965 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9966 xcb_buffer_len += xcb_block_len + xcb_pad; 9967 if (0 != xcb_pad) { 9968 xcb_tmp += xcb_pad; 9969 xcb_pad = 0; 9970 } 9971 xcb_block_len = 0; 9972 9973 return xcb_buffer_len; 9974} 9975 9976xcb_glx_get_compressed_tex_image_arb_cookie_t 9977xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c, 9978 xcb_glx_context_tag_t context_tag, 9979 uint32_t target, 9980 int32_t level) 9981{ 9982 static const xcb_protocol_request_t xcb_req = { 9983 .count = 2, 9984 .ext = &xcb_glx_id, 9985 .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 9986 .isvoid = 0 9987 }; 9988 9989 struct iovec xcb_parts[4]; 9990 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 9991 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 9992 9993 xcb_out.context_tag = context_tag; 9994 xcb_out.target = target; 9995 xcb_out.level = level; 9996 9997 xcb_parts[2].iov_base = (char *) &xcb_out; 9998 xcb_parts[2].iov_len = sizeof(xcb_out); 9999 xcb_parts[3].iov_base = 0; 10000 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10001 10002 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10003 return xcb_ret; 10004} 10005 10006xcb_glx_get_compressed_tex_image_arb_cookie_t 10007xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c, 10008 xcb_glx_context_tag_t context_tag, 10009 uint32_t target, 10010 int32_t level) 10011{ 10012 static const xcb_protocol_request_t xcb_req = { 10013 .count = 2, 10014 .ext = &xcb_glx_id, 10015 .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 10016 .isvoid = 0 10017 }; 10018 10019 struct iovec xcb_parts[4]; 10020 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 10021 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 10022 10023 xcb_out.context_tag = context_tag; 10024 xcb_out.target = target; 10025 xcb_out.level = level; 10026 10027 xcb_parts[2].iov_base = (char *) &xcb_out; 10028 xcb_parts[2].iov_len = sizeof(xcb_out); 10029 xcb_parts[3].iov_base = 0; 10030 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10031 10032 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10033 return xcb_ret; 10034} 10035 10036uint8_t * 10037xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10038{ 10039 return (uint8_t *) (R + 1); 10040} 10041 10042int 10043xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10044{ 10045 return (R->length * 4); 10046} 10047 10048xcb_generic_iterator_t 10049xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10050{ 10051 xcb_generic_iterator_t i; 10052 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 10053 i.rem = 0; 10054 i.index = (char *) i.data - (char *) R; 10055 return i; 10056} 10057 10058xcb_glx_get_compressed_tex_image_arb_reply_t * 10059xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c, 10060 xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, 10061 xcb_generic_error_t **e) 10062{ 10063 return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10064} 10065 10066int 10067xcb_glx_delete_queries_arb_sizeof (const void *_buffer) 10068{ 10069 char *xcb_tmp = (char *)_buffer; 10070 const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer; 10071 unsigned int xcb_buffer_len = 0; 10072 unsigned int xcb_block_len = 0; 10073 unsigned int xcb_pad = 0; 10074 unsigned int xcb_align_to = 0; 10075 10076 10077 xcb_block_len += sizeof(xcb_glx_delete_queries_arb_request_t); 10078 xcb_tmp += xcb_block_len; 10079 xcb_buffer_len += xcb_block_len; 10080 xcb_block_len = 0; 10081 /* ids */ 10082 xcb_block_len += _aux->n * sizeof(uint32_t); 10083 xcb_tmp += xcb_block_len; 10084 xcb_align_to = ALIGNOF(uint32_t); 10085 /* insert padding */ 10086 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10087 xcb_buffer_len += xcb_block_len + xcb_pad; 10088 if (0 != xcb_pad) { 10089 xcb_tmp += xcb_pad; 10090 xcb_pad = 0; 10091 } 10092 xcb_block_len = 0; 10093 10094 return xcb_buffer_len; 10095} 10096 10097xcb_void_cookie_t 10098xcb_glx_delete_queries_arb_checked (xcb_connection_t *c, 10099 xcb_glx_context_tag_t context_tag, 10100 int32_t n, 10101 const uint32_t *ids) 10102{ 10103 static const xcb_protocol_request_t xcb_req = { 10104 .count = 4, 10105 .ext = &xcb_glx_id, 10106 .opcode = XCB_GLX_DELETE_QUERIES_ARB, 10107 .isvoid = 1 10108 }; 10109 10110 struct iovec xcb_parts[6]; 10111 xcb_void_cookie_t xcb_ret; 10112 xcb_glx_delete_queries_arb_request_t xcb_out; 10113 10114 xcb_out.context_tag = context_tag; 10115 xcb_out.n = n; 10116 10117 xcb_parts[2].iov_base = (char *) &xcb_out; 10118 xcb_parts[2].iov_len = sizeof(xcb_out); 10119 xcb_parts[3].iov_base = 0; 10120 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10121 /* uint32_t ids */ 10122 xcb_parts[4].iov_base = (char *) ids; 10123 xcb_parts[4].iov_len = n * sizeof(uint32_t); 10124 xcb_parts[5].iov_base = 0; 10125 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10126 10127 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10128 return xcb_ret; 10129} 10130 10131xcb_void_cookie_t 10132xcb_glx_delete_queries_arb (xcb_connection_t *c, 10133 xcb_glx_context_tag_t context_tag, 10134 int32_t n, 10135 const uint32_t *ids) 10136{ 10137 static const xcb_protocol_request_t xcb_req = { 10138 .count = 4, 10139 .ext = &xcb_glx_id, 10140 .opcode = XCB_GLX_DELETE_QUERIES_ARB, 10141 .isvoid = 1 10142 }; 10143 10144 struct iovec xcb_parts[6]; 10145 xcb_void_cookie_t xcb_ret; 10146 xcb_glx_delete_queries_arb_request_t xcb_out; 10147 10148 xcb_out.context_tag = context_tag; 10149 xcb_out.n = n; 10150 10151 xcb_parts[2].iov_base = (char *) &xcb_out; 10152 xcb_parts[2].iov_len = sizeof(xcb_out); 10153 xcb_parts[3].iov_base = 0; 10154 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10155 /* uint32_t ids */ 10156 xcb_parts[4].iov_base = (char *) ids; 10157 xcb_parts[4].iov_len = n * sizeof(uint32_t); 10158 xcb_parts[5].iov_base = 0; 10159 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10160 10161 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10162 return xcb_ret; 10163} 10164 10165uint32_t * 10166xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R) 10167{ 10168 return (uint32_t *) (R + 1); 10169} 10170 10171int 10172xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R) 10173{ 10174 return R->n; 10175} 10176 10177xcb_generic_iterator_t 10178xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R) 10179{ 10180 xcb_generic_iterator_t i; 10181 i.data = ((uint32_t *) (R + 1)) + (R->n); 10182 i.rem = 0; 10183 i.index = (char *) i.data - (char *) R; 10184 return i; 10185} 10186 10187int 10188xcb_glx_gen_queries_arb_sizeof (const void *_buffer) 10189{ 10190 char *xcb_tmp = (char *)_buffer; 10191 const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer; 10192 unsigned int xcb_buffer_len = 0; 10193 unsigned int xcb_block_len = 0; 10194 unsigned int xcb_pad = 0; 10195 unsigned int xcb_align_to = 0; 10196 10197 10198 xcb_block_len += sizeof(xcb_glx_gen_queries_arb_reply_t); 10199 xcb_tmp += xcb_block_len; 10200 xcb_buffer_len += xcb_block_len; 10201 xcb_block_len = 0; 10202 /* data */ 10203 xcb_block_len += _aux->length * sizeof(uint32_t); 10204 xcb_tmp += xcb_block_len; 10205 xcb_align_to = ALIGNOF(uint32_t); 10206 /* insert padding */ 10207 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10208 xcb_buffer_len += xcb_block_len + xcb_pad; 10209 if (0 != xcb_pad) { 10210 xcb_tmp += xcb_pad; 10211 xcb_pad = 0; 10212 } 10213 xcb_block_len = 0; 10214 10215 return xcb_buffer_len; 10216} 10217 10218xcb_glx_gen_queries_arb_cookie_t 10219xcb_glx_gen_queries_arb (xcb_connection_t *c, 10220 xcb_glx_context_tag_t context_tag, 10221 int32_t n) 10222{ 10223 static const xcb_protocol_request_t xcb_req = { 10224 .count = 2, 10225 .ext = &xcb_glx_id, 10226 .opcode = XCB_GLX_GEN_QUERIES_ARB, 10227 .isvoid = 0 10228 }; 10229 10230 struct iovec xcb_parts[4]; 10231 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 10232 xcb_glx_gen_queries_arb_request_t xcb_out; 10233 10234 xcb_out.context_tag = context_tag; 10235 xcb_out.n = n; 10236 10237 xcb_parts[2].iov_base = (char *) &xcb_out; 10238 xcb_parts[2].iov_len = sizeof(xcb_out); 10239 xcb_parts[3].iov_base = 0; 10240 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10241 10242 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10243 return xcb_ret; 10244} 10245 10246xcb_glx_gen_queries_arb_cookie_t 10247xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c, 10248 xcb_glx_context_tag_t context_tag, 10249 int32_t n) 10250{ 10251 static const xcb_protocol_request_t xcb_req = { 10252 .count = 2, 10253 .ext = &xcb_glx_id, 10254 .opcode = XCB_GLX_GEN_QUERIES_ARB, 10255 .isvoid = 0 10256 }; 10257 10258 struct iovec xcb_parts[4]; 10259 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 10260 xcb_glx_gen_queries_arb_request_t xcb_out; 10261 10262 xcb_out.context_tag = context_tag; 10263 xcb_out.n = n; 10264 10265 xcb_parts[2].iov_base = (char *) &xcb_out; 10266 xcb_parts[2].iov_len = sizeof(xcb_out); 10267 xcb_parts[3].iov_base = 0; 10268 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10269 10270 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10271 return xcb_ret; 10272} 10273 10274uint32_t * 10275xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R) 10276{ 10277 return (uint32_t *) (R + 1); 10278} 10279 10280int 10281xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R) 10282{ 10283 return R->length; 10284} 10285 10286xcb_generic_iterator_t 10287xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R) 10288{ 10289 xcb_generic_iterator_t i; 10290 i.data = ((uint32_t *) (R + 1)) + (R->length); 10291 i.rem = 0; 10292 i.index = (char *) i.data - (char *) R; 10293 return i; 10294} 10295 10296xcb_glx_gen_queries_arb_reply_t * 10297xcb_glx_gen_queries_arb_reply (xcb_connection_t *c, 10298 xcb_glx_gen_queries_arb_cookie_t cookie /**< */, 10299 xcb_generic_error_t **e) 10300{ 10301 return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10302} 10303 10304xcb_glx_is_query_arb_cookie_t 10305xcb_glx_is_query_arb (xcb_connection_t *c, 10306 xcb_glx_context_tag_t context_tag, 10307 uint32_t id) 10308{ 10309 static const xcb_protocol_request_t xcb_req = { 10310 .count = 2, 10311 .ext = &xcb_glx_id, 10312 .opcode = XCB_GLX_IS_QUERY_ARB, 10313 .isvoid = 0 10314 }; 10315 10316 struct iovec xcb_parts[4]; 10317 xcb_glx_is_query_arb_cookie_t xcb_ret; 10318 xcb_glx_is_query_arb_request_t xcb_out; 10319 10320 xcb_out.context_tag = context_tag; 10321 xcb_out.id = id; 10322 10323 xcb_parts[2].iov_base = (char *) &xcb_out; 10324 xcb_parts[2].iov_len = sizeof(xcb_out); 10325 xcb_parts[3].iov_base = 0; 10326 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10327 10328 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10329 return xcb_ret; 10330} 10331 10332xcb_glx_is_query_arb_cookie_t 10333xcb_glx_is_query_arb_unchecked (xcb_connection_t *c, 10334 xcb_glx_context_tag_t context_tag, 10335 uint32_t id) 10336{ 10337 static const xcb_protocol_request_t xcb_req = { 10338 .count = 2, 10339 .ext = &xcb_glx_id, 10340 .opcode = XCB_GLX_IS_QUERY_ARB, 10341 .isvoid = 0 10342 }; 10343 10344 struct iovec xcb_parts[4]; 10345 xcb_glx_is_query_arb_cookie_t xcb_ret; 10346 xcb_glx_is_query_arb_request_t xcb_out; 10347 10348 xcb_out.context_tag = context_tag; 10349 xcb_out.id = id; 10350 10351 xcb_parts[2].iov_base = (char *) &xcb_out; 10352 xcb_parts[2].iov_len = sizeof(xcb_out); 10353 xcb_parts[3].iov_base = 0; 10354 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10355 10356 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10357 return xcb_ret; 10358} 10359 10360xcb_glx_is_query_arb_reply_t * 10361xcb_glx_is_query_arb_reply (xcb_connection_t *c, 10362 xcb_glx_is_query_arb_cookie_t cookie /**< */, 10363 xcb_generic_error_t **e) 10364{ 10365 return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10366} 10367 10368int 10369xcb_glx_get_queryiv_arb_sizeof (const void *_buffer) 10370{ 10371 char *xcb_tmp = (char *)_buffer; 10372 const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer; 10373 unsigned int xcb_buffer_len = 0; 10374 unsigned int xcb_block_len = 0; 10375 unsigned int xcb_pad = 0; 10376 unsigned int xcb_align_to = 0; 10377 10378 10379 xcb_block_len += sizeof(xcb_glx_get_queryiv_arb_reply_t); 10380 xcb_tmp += xcb_block_len; 10381 xcb_buffer_len += xcb_block_len; 10382 xcb_block_len = 0; 10383 /* data */ 10384 xcb_block_len += _aux->n * sizeof(int32_t); 10385 xcb_tmp += xcb_block_len; 10386 xcb_align_to = ALIGNOF(int32_t); 10387 /* insert padding */ 10388 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10389 xcb_buffer_len += xcb_block_len + xcb_pad; 10390 if (0 != xcb_pad) { 10391 xcb_tmp += xcb_pad; 10392 xcb_pad = 0; 10393 } 10394 xcb_block_len = 0; 10395 10396 return xcb_buffer_len; 10397} 10398 10399xcb_glx_get_queryiv_arb_cookie_t 10400xcb_glx_get_queryiv_arb (xcb_connection_t *c, 10401 xcb_glx_context_tag_t context_tag, 10402 uint32_t target, 10403 uint32_t pname) 10404{ 10405 static const xcb_protocol_request_t xcb_req = { 10406 .count = 2, 10407 .ext = &xcb_glx_id, 10408 .opcode = XCB_GLX_GET_QUERYIV_ARB, 10409 .isvoid = 0 10410 }; 10411 10412 struct iovec xcb_parts[4]; 10413 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 10414 xcb_glx_get_queryiv_arb_request_t xcb_out; 10415 10416 xcb_out.context_tag = context_tag; 10417 xcb_out.target = target; 10418 xcb_out.pname = pname; 10419 10420 xcb_parts[2].iov_base = (char *) &xcb_out; 10421 xcb_parts[2].iov_len = sizeof(xcb_out); 10422 xcb_parts[3].iov_base = 0; 10423 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10424 10425 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10426 return xcb_ret; 10427} 10428 10429xcb_glx_get_queryiv_arb_cookie_t 10430xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c, 10431 xcb_glx_context_tag_t context_tag, 10432 uint32_t target, 10433 uint32_t pname) 10434{ 10435 static const xcb_protocol_request_t xcb_req = { 10436 .count = 2, 10437 .ext = &xcb_glx_id, 10438 .opcode = XCB_GLX_GET_QUERYIV_ARB, 10439 .isvoid = 0 10440 }; 10441 10442 struct iovec xcb_parts[4]; 10443 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 10444 xcb_glx_get_queryiv_arb_request_t xcb_out; 10445 10446 xcb_out.context_tag = context_tag; 10447 xcb_out.target = target; 10448 xcb_out.pname = pname; 10449 10450 xcb_parts[2].iov_base = (char *) &xcb_out; 10451 xcb_parts[2].iov_len = sizeof(xcb_out); 10452 xcb_parts[3].iov_base = 0; 10453 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10454 10455 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10456 return xcb_ret; 10457} 10458 10459int32_t * 10460xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R) 10461{ 10462 return (int32_t *) (R + 1); 10463} 10464 10465int 10466xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R) 10467{ 10468 return R->n; 10469} 10470 10471xcb_generic_iterator_t 10472xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R) 10473{ 10474 xcb_generic_iterator_t i; 10475 i.data = ((int32_t *) (R + 1)) + (R->n); 10476 i.rem = 0; 10477 i.index = (char *) i.data - (char *) R; 10478 return i; 10479} 10480 10481xcb_glx_get_queryiv_arb_reply_t * 10482xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c, 10483 xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, 10484 xcb_generic_error_t **e) 10485{ 10486 return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10487} 10488 10489int 10490xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer) 10491{ 10492 char *xcb_tmp = (char *)_buffer; 10493 const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer; 10494 unsigned int xcb_buffer_len = 0; 10495 unsigned int xcb_block_len = 0; 10496 unsigned int xcb_pad = 0; 10497 unsigned int xcb_align_to = 0; 10498 10499 10500 xcb_block_len += sizeof(xcb_glx_get_query_objectiv_arb_reply_t); 10501 xcb_tmp += xcb_block_len; 10502 xcb_buffer_len += xcb_block_len; 10503 xcb_block_len = 0; 10504 /* data */ 10505 xcb_block_len += _aux->n * sizeof(int32_t); 10506 xcb_tmp += xcb_block_len; 10507 xcb_align_to = ALIGNOF(int32_t); 10508 /* insert padding */ 10509 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10510 xcb_buffer_len += xcb_block_len + xcb_pad; 10511 if (0 != xcb_pad) { 10512 xcb_tmp += xcb_pad; 10513 xcb_pad = 0; 10514 } 10515 xcb_block_len = 0; 10516 10517 return xcb_buffer_len; 10518} 10519 10520xcb_glx_get_query_objectiv_arb_cookie_t 10521xcb_glx_get_query_objectiv_arb (xcb_connection_t *c, 10522 xcb_glx_context_tag_t context_tag, 10523 uint32_t id, 10524 uint32_t pname) 10525{ 10526 static const xcb_protocol_request_t xcb_req = { 10527 .count = 2, 10528 .ext = &xcb_glx_id, 10529 .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, 10530 .isvoid = 0 10531 }; 10532 10533 struct iovec xcb_parts[4]; 10534 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 10535 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 10536 10537 xcb_out.context_tag = context_tag; 10538 xcb_out.id = id; 10539 xcb_out.pname = pname; 10540 10541 xcb_parts[2].iov_base = (char *) &xcb_out; 10542 xcb_parts[2].iov_len = sizeof(xcb_out); 10543 xcb_parts[3].iov_base = 0; 10544 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10545 10546 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10547 return xcb_ret; 10548} 10549 10550xcb_glx_get_query_objectiv_arb_cookie_t 10551xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c, 10552 xcb_glx_context_tag_t context_tag, 10553 uint32_t id, 10554 uint32_t pname) 10555{ 10556 static const xcb_protocol_request_t xcb_req = { 10557 .count = 2, 10558 .ext = &xcb_glx_id, 10559 .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, 10560 .isvoid = 0 10561 }; 10562 10563 struct iovec xcb_parts[4]; 10564 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 10565 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 10566 10567 xcb_out.context_tag = context_tag; 10568 xcb_out.id = id; 10569 xcb_out.pname = pname; 10570 10571 xcb_parts[2].iov_base = (char *) &xcb_out; 10572 xcb_parts[2].iov_len = sizeof(xcb_out); 10573 xcb_parts[3].iov_base = 0; 10574 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10575 10576 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10577 return xcb_ret; 10578} 10579 10580int32_t * 10581xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10582{ 10583 return (int32_t *) (R + 1); 10584} 10585 10586int 10587xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10588{ 10589 return R->n; 10590} 10591 10592xcb_generic_iterator_t 10593xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10594{ 10595 xcb_generic_iterator_t i; 10596 i.data = ((int32_t *) (R + 1)) + (R->n); 10597 i.rem = 0; 10598 i.index = (char *) i.data - (char *) R; 10599 return i; 10600} 10601 10602xcb_glx_get_query_objectiv_arb_reply_t * 10603xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c, 10604 xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, 10605 xcb_generic_error_t **e) 10606{ 10607 return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10608} 10609 10610int 10611xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer) 10612{ 10613 char *xcb_tmp = (char *)_buffer; 10614 const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer; 10615 unsigned int xcb_buffer_len = 0; 10616 unsigned int xcb_block_len = 0; 10617 unsigned int xcb_pad = 0; 10618 unsigned int xcb_align_to = 0; 10619 10620 10621 xcb_block_len += sizeof(xcb_glx_get_query_objectuiv_arb_reply_t); 10622 xcb_tmp += xcb_block_len; 10623 xcb_buffer_len += xcb_block_len; 10624 xcb_block_len = 0; 10625 /* data */ 10626 xcb_block_len += _aux->n * sizeof(uint32_t); 10627 xcb_tmp += xcb_block_len; 10628 xcb_align_to = ALIGNOF(uint32_t); 10629 /* insert padding */ 10630 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10631 xcb_buffer_len += xcb_block_len + xcb_pad; 10632 if (0 != xcb_pad) { 10633 xcb_tmp += xcb_pad; 10634 xcb_pad = 0; 10635 } 10636 xcb_block_len = 0; 10637 10638 return xcb_buffer_len; 10639} 10640 10641xcb_glx_get_query_objectuiv_arb_cookie_t 10642xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c, 10643 xcb_glx_context_tag_t context_tag, 10644 uint32_t id, 10645 uint32_t pname) 10646{ 10647 static const xcb_protocol_request_t xcb_req = { 10648 .count = 2, 10649 .ext = &xcb_glx_id, 10650 .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 10651 .isvoid = 0 10652 }; 10653 10654 struct iovec xcb_parts[4]; 10655 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 10656 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 10657 10658 xcb_out.context_tag = context_tag; 10659 xcb_out.id = id; 10660 xcb_out.pname = pname; 10661 10662 xcb_parts[2].iov_base = (char *) &xcb_out; 10663 xcb_parts[2].iov_len = sizeof(xcb_out); 10664 xcb_parts[3].iov_base = 0; 10665 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10666 10667 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10668 return xcb_ret; 10669} 10670 10671xcb_glx_get_query_objectuiv_arb_cookie_t 10672xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c, 10673 xcb_glx_context_tag_t context_tag, 10674 uint32_t id, 10675 uint32_t pname) 10676{ 10677 static const xcb_protocol_request_t xcb_req = { 10678 .count = 2, 10679 .ext = &xcb_glx_id, 10680 .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 10681 .isvoid = 0 10682 }; 10683 10684 struct iovec xcb_parts[4]; 10685 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 10686 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 10687 10688 xcb_out.context_tag = context_tag; 10689 xcb_out.id = id; 10690 xcb_out.pname = pname; 10691 10692 xcb_parts[2].iov_base = (char *) &xcb_out; 10693 xcb_parts[2].iov_len = sizeof(xcb_out); 10694 xcb_parts[3].iov_base = 0; 10695 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10696 10697 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10698 return xcb_ret; 10699} 10700 10701uint32_t * 10702xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10703{ 10704 return (uint32_t *) (R + 1); 10705} 10706 10707int 10708xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10709{ 10710 return R->n; 10711} 10712 10713xcb_generic_iterator_t 10714xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10715{ 10716 xcb_generic_iterator_t i; 10717 i.data = ((uint32_t *) (R + 1)) + (R->n); 10718 i.rem = 0; 10719 i.index = (char *) i.data - (char *) R; 10720 return i; 10721} 10722 10723xcb_glx_get_query_objectuiv_arb_reply_t * 10724xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c, 10725 xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, 10726 xcb_generic_error_t **e) 10727{ 10728 return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10729} 10730 10731