1 /* 2 * This file generated automatically from glx.xml by c_client.py. 3 * Edit at your peril. 4 */ 5 6 #ifdef HAVE_CONFIG_H 7 #include "config.h" 8 #endif 9 #include <stdlib.h> 10 #include <string.h> 11 #include <assert.h> 12 #include <stddef.h> /* for offsetof() */ 13 #include "xcbext.h" 14 #include "glx.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_glx_id = { "GLX", 0 }; 20 21 void 22 xcb_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 29 xcb_generic_iterator_t 30 xcb_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 39 void 40 xcb_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 47 xcb_generic_iterator_t 48 xcb_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 57 void 58 xcb_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 65 xcb_generic_iterator_t 66 xcb_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 75 void 76 xcb_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 83 xcb_generic_iterator_t 84 xcb_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 93 void 94 xcb_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 101 xcb_generic_iterator_t 102 xcb_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 111 void 112 xcb_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 119 xcb_generic_iterator_t 120 xcb_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 129 void 130 xcb_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 137 xcb_generic_iterator_t 138 xcb_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 147 void 148 xcb_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 155 xcb_generic_iterator_t 156 xcb_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 165 void 166 xcb_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 173 xcb_generic_iterator_t 174 xcb_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 183 void 184 xcb_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 191 xcb_generic_iterator_t 192 xcb_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 201 int 202 xcb_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 232 xcb_void_cookie_t 233 xcb_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 265 xcb_void_cookie_t 266 xcb_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 298 uint8_t * 299 xcb_glx_render_data (const xcb_glx_render_request_t *R) 300 { 301 return (uint8_t *) (R + 1); 302 } 303 304 int 305 xcb_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 310 xcb_generic_iterator_t 311 xcb_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 320 int 321 xcb_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 351 xcb_void_cookie_t 352 xcb_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 389 xcb_void_cookie_t 390 xcb_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 427 uint8_t * 428 xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R) 429 { 430 return (uint8_t *) (R + 1); 431 } 432 433 int 434 xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R) 435 { 436 return R->data_len; 437 } 438 439 xcb_generic_iterator_t 440 xcb_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 449 xcb_void_cookie_t 450 xcb_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 484 xcb_void_cookie_t 485 xcb_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 519 xcb_void_cookie_t 520 xcb_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 545 xcb_void_cookie_t 546 xcb_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 571 xcb_glx_make_current_cookie_t 572 xcb_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 601 xcb_glx_make_current_cookie_t 602 xcb_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 631 xcb_glx_make_current_reply_t * 632 xcb_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 639 xcb_glx_is_direct_cookie_t 640 xcb_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 665 xcb_glx_is_direct_cookie_t 666 xcb_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 691 xcb_glx_is_direct_reply_t * 692 xcb_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 699 xcb_glx_query_version_cookie_t 700 xcb_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 727 xcb_glx_query_version_cookie_t 728 xcb_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 755 xcb_glx_query_version_reply_t * 756 xcb_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 763 xcb_void_cookie_t 764 xcb_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 789 xcb_void_cookie_t 790 xcb_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 815 xcb_void_cookie_t 816 xcb_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 841 xcb_void_cookie_t 842 xcb_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 867 xcb_void_cookie_t 868 xcb_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 899 xcb_void_cookie_t 900 xcb_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 931 xcb_void_cookie_t 932 xcb_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 959 xcb_void_cookie_t 960 xcb_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 987 xcb_void_cookie_t 988 xcb_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 1021 xcb_void_cookie_t 1022 xcb_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 1055 xcb_void_cookie_t 1056 xcb_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 1087 xcb_void_cookie_t 1088 xcb_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 1119 int 1120 xcb_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 1150 xcb_glx_get_visual_configs_cookie_t 1151 xcb_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 1176 xcb_glx_get_visual_configs_cookie_t 1177 xcb_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 1202 uint32_t * 1203 xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R) 1204 { 1205 return (uint32_t *) (R + 1); 1206 } 1207 1208 int 1209 xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R) 1210 { 1211 return R->length; 1212 } 1213 1214 xcb_generic_iterator_t 1215 xcb_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 1224 xcb_glx_get_visual_configs_reply_t * 1225 xcb_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 1232 xcb_void_cookie_t 1233 xcb_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 1258 xcb_void_cookie_t 1259 xcb_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 1284 int 1285 xcb_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 1315 xcb_void_cookie_t 1316 xcb_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 1350 xcb_void_cookie_t 1351 xcb_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 1385 uint8_t * 1386 xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R) 1387 { 1388 return (uint8_t *) (R + 1); 1389 } 1390 1391 int 1392 xcb_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 1397 xcb_generic_iterator_t 1398 xcb_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 1407 int 1408 xcb_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 1438 xcb_glx_vendor_private_with_reply_cookie_t 1439 xcb_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 1473 xcb_glx_vendor_private_with_reply_cookie_t 1474 xcb_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 1508 uint8_t * 1509 xcb_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 1514 int 1515 xcb_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 1520 xcb_generic_iterator_t 1521 xcb_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 1530 xcb_glx_vendor_private_with_reply_reply_t * 1531 xcb_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 1538 xcb_glx_query_extensions_string_cookie_t 1539 xcb_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 1564 xcb_glx_query_extensions_string_cookie_t 1565 xcb_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 1590 xcb_glx_query_extensions_string_reply_t * 1591 xcb_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 1598 int 1599 xcb_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 1629 xcb_glx_query_server_string_cookie_t 1630 xcb_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 1657 xcb_glx_query_server_string_cookie_t 1658 xcb_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 1685 char * 1686 xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R) 1687 { 1688 return (char *) (R + 1); 1689 } 1690 1691 int 1692 xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R) 1693 { 1694 return R->str_len; 1695 } 1696 1697 xcb_generic_iterator_t 1698 xcb_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 1707 xcb_glx_query_server_string_reply_t * 1708 xcb_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 1715 int 1716 xcb_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 1746 xcb_void_cookie_t 1747 xcb_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 1782 xcb_void_cookie_t 1783 xcb_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 1818 char * 1819 xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R) 1820 { 1821 return (char *) (R + 1); 1822 } 1823 1824 int 1825 xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R) 1826 { 1827 return R->str_len; 1828 } 1829 1830 xcb_generic_iterator_t 1831 xcb_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 1840 int 1841 xcb_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 1871 xcb_glx_get_fb_configs_cookie_t 1872 xcb_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 1897 xcb_glx_get_fb_configs_cookie_t 1898 xcb_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 1923 uint32_t * 1924 xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R) 1925 { 1926 return (uint32_t *) (R + 1); 1927 } 1928 1929 int 1930 xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R) 1931 { 1932 return R->length; 1933 } 1934 1935 xcb_generic_iterator_t 1936 xcb_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 1945 xcb_glx_get_fb_configs_reply_t * 1946 xcb_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 1953 int 1954 xcb_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 1984 xcb_void_cookie_t 1985 xcb_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 2024 xcb_void_cookie_t 2025 xcb_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 2064 uint32_t * 2065 xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R) 2066 { 2067 return (uint32_t *) (R + 1); 2068 } 2069 2070 int 2071 xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R) 2072 { 2073 return (R->num_attribs * 2); 2074 } 2075 2076 xcb_generic_iterator_t 2077 xcb_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 2086 xcb_void_cookie_t 2087 xcb_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 2112 xcb_void_cookie_t 2113 xcb_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 2138 xcb_void_cookie_t 2139 xcb_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 2175 xcb_void_cookie_t 2176 xcb_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 2212 int 2213 xcb_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 2243 xcb_glx_query_context_cookie_t 2244 xcb_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 2269 xcb_glx_query_context_cookie_t 2270 xcb_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 2295 uint32_t * 2296 xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R) 2297 { 2298 return (uint32_t *) (R + 1); 2299 } 2300 2301 int 2302 xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R) 2303 { 2304 return (R->num_attribs * 2); 2305 } 2306 2307 xcb_generic_iterator_t 2308 xcb_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 2317 xcb_glx_query_context_reply_t * 2318 xcb_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 2325 xcb_glx_make_context_current_cookie_t 2326 xcb_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 2357 xcb_glx_make_context_current_cookie_t 2358 xcb_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 2389 xcb_glx_make_context_current_reply_t * 2390 xcb_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 2397 int 2398 xcb_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 2428 xcb_void_cookie_t 2429 xcb_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 2466 xcb_void_cookie_t 2467 xcb_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 2504 uint32_t * 2505 xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R) 2506 { 2507 return (uint32_t *) (R + 1); 2508 } 2509 2510 int 2511 xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R) 2512 { 2513 return (R->num_attribs * 2); 2514 } 2515 2516 xcb_generic_iterator_t 2517 xcb_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 2526 xcb_void_cookie_t 2527 xcb_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 2552 xcb_void_cookie_t 2553 xcb_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 2578 int 2579 xcb_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 2609 xcb_glx_get_drawable_attributes_cookie_t 2610 xcb_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 2635 xcb_glx_get_drawable_attributes_cookie_t 2636 xcb_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 2661 uint32_t * 2662 xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R) 2663 { 2664 return (uint32_t *) (R + 1); 2665 } 2666 2667 int 2668 xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R) 2669 { 2670 return (R->num_attribs * 2); 2671 } 2672 2673 xcb_generic_iterator_t 2674 xcb_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 2683 xcb_glx_get_drawable_attributes_reply_t * 2684 xcb_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 2691 int 2692 xcb_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 2722 xcb_void_cookie_t 2723 xcb_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 2756 xcb_void_cookie_t 2757 xcb_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 2790 uint32_t * 2791 xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R) 2792 { 2793 return (uint32_t *) (R + 1); 2794 } 2795 2796 int 2797 xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R) 2798 { 2799 return (R->num_attribs * 2); 2800 } 2801 2802 xcb_generic_iterator_t 2803 xcb_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 2812 int 2813 xcb_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 2843 xcb_void_cookie_t 2844 xcb_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 2883 xcb_void_cookie_t 2884 xcb_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 2923 uint32_t * 2924 xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R) 2925 { 2926 return (uint32_t *) (R + 1); 2927 } 2928 2929 int 2930 xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R) 2931 { 2932 return (R->num_attribs * 2); 2933 } 2934 2935 xcb_generic_iterator_t 2936 xcb_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 2945 xcb_void_cookie_t 2946 xcb_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 2971 xcb_void_cookie_t 2972 xcb_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 2997 int 2998 xcb_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 /* insert padding */ 3029 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3030 xcb_buffer_len += xcb_block_len + xcb_pad; 3031 if (0 != xcb_pad) { 3032 xcb_tmp += xcb_pad; 3033 xcb_pad = 0; 3034 } 3035 xcb_block_len = 0; 3036 /* glx_extension_string */ 3037 xcb_block_len += _aux->glx_str_len * sizeof(char); 3038 xcb_tmp += xcb_block_len; 3039 xcb_align_to = ALIGNOF(char); 3040 /* insert padding */ 3041 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3042 xcb_buffer_len += xcb_block_len + xcb_pad; 3043 if (0 != xcb_pad) { 3044 xcb_tmp += xcb_pad; 3045 xcb_pad = 0; 3046 } 3047 xcb_block_len = 0; 3048 3049 return xcb_buffer_len; 3050 } 3051 3052 xcb_void_cookie_t 3053 xcb_glx_set_client_info_arb_checked (xcb_connection_t *c, 3054 uint32_t major_version, 3055 uint32_t minor_version, 3056 uint32_t num_versions, 3057 uint32_t gl_str_len, 3058 uint32_t glx_str_len, 3059 const uint32_t *gl_versions, 3060 const char *gl_extension_string, 3061 const char *glx_extension_string) 3062 { 3063 static const xcb_protocol_request_t xcb_req = { 3064 .count = 8, 3065 .ext = &xcb_glx_id, 3066 .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, 3067 .isvoid = 1 3068 }; 3069 3070 struct iovec xcb_parts[10]; 3071 xcb_void_cookie_t xcb_ret; 3072 xcb_glx_set_client_info_arb_request_t xcb_out; 3073 3074 xcb_out.major_version = major_version; 3075 xcb_out.minor_version = minor_version; 3076 xcb_out.num_versions = num_versions; 3077 xcb_out.gl_str_len = gl_str_len; 3078 xcb_out.glx_str_len = glx_str_len; 3079 3080 xcb_parts[2].iov_base = (char *) &xcb_out; 3081 xcb_parts[2].iov_len = sizeof(xcb_out); 3082 xcb_parts[3].iov_base = 0; 3083 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3084 /* uint32_t gl_versions */ 3085 xcb_parts[4].iov_base = (char *) gl_versions; 3086 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 3087 xcb_parts[5].iov_base = 0; 3088 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3089 /* char gl_extension_string */ 3090 xcb_parts[6].iov_base = (char *) gl_extension_string; 3091 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3092 xcb_parts[7].iov_base = 0; 3093 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3094 /* char glx_extension_string */ 3095 xcb_parts[8].iov_base = (char *) glx_extension_string; 3096 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3097 xcb_parts[9].iov_base = 0; 3098 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3099 3100 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3101 return xcb_ret; 3102 } 3103 3104 xcb_void_cookie_t 3105 xcb_glx_set_client_info_arb (xcb_connection_t *c, 3106 uint32_t major_version, 3107 uint32_t minor_version, 3108 uint32_t num_versions, 3109 uint32_t gl_str_len, 3110 uint32_t glx_str_len, 3111 const uint32_t *gl_versions, 3112 const char *gl_extension_string, 3113 const char *glx_extension_string) 3114 { 3115 static const xcb_protocol_request_t xcb_req = { 3116 .count = 8, 3117 .ext = &xcb_glx_id, 3118 .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, 3119 .isvoid = 1 3120 }; 3121 3122 struct iovec xcb_parts[10]; 3123 xcb_void_cookie_t xcb_ret; 3124 xcb_glx_set_client_info_arb_request_t xcb_out; 3125 3126 xcb_out.major_version = major_version; 3127 xcb_out.minor_version = minor_version; 3128 xcb_out.num_versions = num_versions; 3129 xcb_out.gl_str_len = gl_str_len; 3130 xcb_out.glx_str_len = glx_str_len; 3131 3132 xcb_parts[2].iov_base = (char *) &xcb_out; 3133 xcb_parts[2].iov_len = sizeof(xcb_out); 3134 xcb_parts[3].iov_base = 0; 3135 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3136 /* uint32_t gl_versions */ 3137 xcb_parts[4].iov_base = (char *) gl_versions; 3138 xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t); 3139 xcb_parts[5].iov_base = 0; 3140 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3141 /* char gl_extension_string */ 3142 xcb_parts[6].iov_base = (char *) gl_extension_string; 3143 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3144 xcb_parts[7].iov_base = 0; 3145 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3146 /* char glx_extension_string */ 3147 xcb_parts[8].iov_base = (char *) glx_extension_string; 3148 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3149 xcb_parts[9].iov_base = 0; 3150 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3151 3152 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3153 return xcb_ret; 3154 } 3155 3156 uint32_t * 3157 xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R) 3158 { 3159 return (uint32_t *) (R + 1); 3160 } 3161 3162 int 3163 xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R) 3164 { 3165 return (R->num_versions * 2); 3166 } 3167 3168 xcb_generic_iterator_t 3169 xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R) 3170 { 3171 xcb_generic_iterator_t i; 3172 i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 2)); 3173 i.rem = 0; 3174 i.index = (char *) i.data - (char *) R; 3175 return i; 3176 } 3177 3178 char * 3179 xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R) 3180 { 3181 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); 3182 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3183 } 3184 3185 int 3186 xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) 3187 { 3188 return R->gl_str_len; 3189 } 3190 3191 xcb_generic_iterator_t 3192 xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) 3193 { 3194 xcb_generic_iterator_t i; 3195 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); 3196 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); 3197 i.rem = 0; 3198 i.index = (char *) i.data - (char *) R; 3199 return i; 3200 } 3201 3202 char * 3203 xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R) 3204 { 3205 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); 3206 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3207 } 3208 3209 int 3210 xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) 3211 { 3212 return R->glx_str_len; 3213 } 3214 3215 xcb_generic_iterator_t 3216 xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) 3217 { 3218 xcb_generic_iterator_t i; 3219 xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); 3220 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->glx_str_len); 3221 i.rem = 0; 3222 i.index = (char *) i.data - (char *) R; 3223 return i; 3224 } 3225 3226 int 3227 xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer) 3228 { 3229 char *xcb_tmp = (char *)_buffer; 3230 const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer; 3231 unsigned int xcb_buffer_len = 0; 3232 unsigned int xcb_block_len = 0; 3233 unsigned int xcb_pad = 0; 3234 unsigned int xcb_align_to = 0; 3235 3236 3237 xcb_block_len += sizeof(xcb_glx_create_context_attribs_arb_request_t); 3238 xcb_tmp += xcb_block_len; 3239 xcb_buffer_len += xcb_block_len; 3240 xcb_block_len = 0; 3241 /* attribs */ 3242 xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t); 3243 xcb_tmp += xcb_block_len; 3244 xcb_align_to = ALIGNOF(uint32_t); 3245 /* insert padding */ 3246 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3247 xcb_buffer_len += xcb_block_len + xcb_pad; 3248 if (0 != xcb_pad) { 3249 xcb_tmp += xcb_pad; 3250 xcb_pad = 0; 3251 } 3252 xcb_block_len = 0; 3253 3254 return xcb_buffer_len; 3255 } 3256 3257 xcb_void_cookie_t 3258 xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c, 3259 xcb_glx_context_t context, 3260 xcb_glx_fbconfig_t fbconfig, 3261 uint32_t screen, 3262 xcb_glx_context_t share_list, 3263 uint8_t is_direct, 3264 uint32_t num_attribs, 3265 const uint32_t *attribs) 3266 { 3267 static const xcb_protocol_request_t xcb_req = { 3268 .count = 4, 3269 .ext = &xcb_glx_id, 3270 .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 3271 .isvoid = 1 3272 }; 3273 3274 struct iovec xcb_parts[6]; 3275 xcb_void_cookie_t xcb_ret; 3276 xcb_glx_create_context_attribs_arb_request_t xcb_out; 3277 3278 xcb_out.context = context; 3279 xcb_out.fbconfig = fbconfig; 3280 xcb_out.screen = screen; 3281 xcb_out.share_list = share_list; 3282 xcb_out.is_direct = is_direct; 3283 memset(xcb_out.pad0, 0, 3); 3284 xcb_out.num_attribs = num_attribs; 3285 3286 xcb_parts[2].iov_base = (char *) &xcb_out; 3287 xcb_parts[2].iov_len = sizeof(xcb_out); 3288 xcb_parts[3].iov_base = 0; 3289 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3290 /* uint32_t attribs */ 3291 xcb_parts[4].iov_base = (char *) attribs; 3292 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3293 xcb_parts[5].iov_base = 0; 3294 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3295 3296 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3297 return xcb_ret; 3298 } 3299 3300 xcb_void_cookie_t 3301 xcb_glx_create_context_attribs_arb (xcb_connection_t *c, 3302 xcb_glx_context_t context, 3303 xcb_glx_fbconfig_t fbconfig, 3304 uint32_t screen, 3305 xcb_glx_context_t share_list, 3306 uint8_t is_direct, 3307 uint32_t num_attribs, 3308 const uint32_t *attribs) 3309 { 3310 static const xcb_protocol_request_t xcb_req = { 3311 .count = 4, 3312 .ext = &xcb_glx_id, 3313 .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, 3314 .isvoid = 1 3315 }; 3316 3317 struct iovec xcb_parts[6]; 3318 xcb_void_cookie_t xcb_ret; 3319 xcb_glx_create_context_attribs_arb_request_t xcb_out; 3320 3321 xcb_out.context = context; 3322 xcb_out.fbconfig = fbconfig; 3323 xcb_out.screen = screen; 3324 xcb_out.share_list = share_list; 3325 xcb_out.is_direct = is_direct; 3326 memset(xcb_out.pad0, 0, 3); 3327 xcb_out.num_attribs = num_attribs; 3328 3329 xcb_parts[2].iov_base = (char *) &xcb_out; 3330 xcb_parts[2].iov_len = sizeof(xcb_out); 3331 xcb_parts[3].iov_base = 0; 3332 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3333 /* uint32_t attribs */ 3334 xcb_parts[4].iov_base = (char *) attribs; 3335 xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t); 3336 xcb_parts[5].iov_base = 0; 3337 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3338 3339 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3340 return xcb_ret; 3341 } 3342 3343 uint32_t * 3344 xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R) 3345 { 3346 return (uint32_t *) (R + 1); 3347 } 3348 3349 int 3350 xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R) 3351 { 3352 return (R->num_attribs * 2); 3353 } 3354 3355 xcb_generic_iterator_t 3356 xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R) 3357 { 3358 xcb_generic_iterator_t i; 3359 i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); 3360 i.rem = 0; 3361 i.index = (char *) i.data - (char *) R; 3362 return i; 3363 } 3364 3365 int 3366 xcb_glx_set_client_info_2arb_sizeof (const void *_buffer) 3367 { 3368 char *xcb_tmp = (char *)_buffer; 3369 const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer; 3370 unsigned int xcb_buffer_len = 0; 3371 unsigned int xcb_block_len = 0; 3372 unsigned int xcb_pad = 0; 3373 unsigned int xcb_align_to = 0; 3374 3375 3376 xcb_block_len += sizeof(xcb_glx_set_client_info_2arb_request_t); 3377 xcb_tmp += xcb_block_len; 3378 xcb_buffer_len += xcb_block_len; 3379 xcb_block_len = 0; 3380 /* gl_versions */ 3381 xcb_block_len += (_aux->num_versions * 3) * sizeof(uint32_t); 3382 xcb_tmp += xcb_block_len; 3383 xcb_align_to = ALIGNOF(uint32_t); 3384 /* insert padding */ 3385 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3386 xcb_buffer_len += xcb_block_len + xcb_pad; 3387 if (0 != xcb_pad) { 3388 xcb_tmp += xcb_pad; 3389 xcb_pad = 0; 3390 } 3391 xcb_block_len = 0; 3392 /* gl_extension_string */ 3393 xcb_block_len += _aux->gl_str_len * sizeof(char); 3394 xcb_tmp += xcb_block_len; 3395 xcb_align_to = ALIGNOF(char); 3396 /* insert padding */ 3397 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3398 xcb_buffer_len += xcb_block_len + xcb_pad; 3399 if (0 != xcb_pad) { 3400 xcb_tmp += xcb_pad; 3401 xcb_pad = 0; 3402 } 3403 xcb_block_len = 0; 3404 /* glx_extension_string */ 3405 xcb_block_len += _aux->glx_str_len * sizeof(char); 3406 xcb_tmp += xcb_block_len; 3407 xcb_align_to = ALIGNOF(char); 3408 /* insert padding */ 3409 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3410 xcb_buffer_len += xcb_block_len + xcb_pad; 3411 if (0 != xcb_pad) { 3412 xcb_tmp += xcb_pad; 3413 xcb_pad = 0; 3414 } 3415 xcb_block_len = 0; 3416 3417 return xcb_buffer_len; 3418 } 3419 3420 xcb_void_cookie_t 3421 xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c, 3422 uint32_t major_version, 3423 uint32_t minor_version, 3424 uint32_t num_versions, 3425 uint32_t gl_str_len, 3426 uint32_t glx_str_len, 3427 const uint32_t *gl_versions, 3428 const char *gl_extension_string, 3429 const char *glx_extension_string) 3430 { 3431 static const xcb_protocol_request_t xcb_req = { 3432 .count = 8, 3433 .ext = &xcb_glx_id, 3434 .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, 3435 .isvoid = 1 3436 }; 3437 3438 struct iovec xcb_parts[10]; 3439 xcb_void_cookie_t xcb_ret; 3440 xcb_glx_set_client_info_2arb_request_t xcb_out; 3441 3442 xcb_out.major_version = major_version; 3443 xcb_out.minor_version = minor_version; 3444 xcb_out.num_versions = num_versions; 3445 xcb_out.gl_str_len = gl_str_len; 3446 xcb_out.glx_str_len = glx_str_len; 3447 3448 xcb_parts[2].iov_base = (char *) &xcb_out; 3449 xcb_parts[2].iov_len = sizeof(xcb_out); 3450 xcb_parts[3].iov_base = 0; 3451 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3452 /* uint32_t gl_versions */ 3453 xcb_parts[4].iov_base = (char *) gl_versions; 3454 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 3455 xcb_parts[5].iov_base = 0; 3456 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3457 /* char gl_extension_string */ 3458 xcb_parts[6].iov_base = (char *) gl_extension_string; 3459 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3460 xcb_parts[7].iov_base = 0; 3461 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3462 /* char glx_extension_string */ 3463 xcb_parts[8].iov_base = (char *) glx_extension_string; 3464 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3465 xcb_parts[9].iov_base = 0; 3466 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3467 3468 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3469 return xcb_ret; 3470 } 3471 3472 xcb_void_cookie_t 3473 xcb_glx_set_client_info_2arb (xcb_connection_t *c, 3474 uint32_t major_version, 3475 uint32_t minor_version, 3476 uint32_t num_versions, 3477 uint32_t gl_str_len, 3478 uint32_t glx_str_len, 3479 const uint32_t *gl_versions, 3480 const char *gl_extension_string, 3481 const char *glx_extension_string) 3482 { 3483 static const xcb_protocol_request_t xcb_req = { 3484 .count = 8, 3485 .ext = &xcb_glx_id, 3486 .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, 3487 .isvoid = 1 3488 }; 3489 3490 struct iovec xcb_parts[10]; 3491 xcb_void_cookie_t xcb_ret; 3492 xcb_glx_set_client_info_2arb_request_t xcb_out; 3493 3494 xcb_out.major_version = major_version; 3495 xcb_out.minor_version = minor_version; 3496 xcb_out.num_versions = num_versions; 3497 xcb_out.gl_str_len = gl_str_len; 3498 xcb_out.glx_str_len = glx_str_len; 3499 3500 xcb_parts[2].iov_base = (char *) &xcb_out; 3501 xcb_parts[2].iov_len = sizeof(xcb_out); 3502 xcb_parts[3].iov_base = 0; 3503 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3504 /* uint32_t gl_versions */ 3505 xcb_parts[4].iov_base = (char *) gl_versions; 3506 xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t); 3507 xcb_parts[5].iov_base = 0; 3508 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3509 /* char gl_extension_string */ 3510 xcb_parts[6].iov_base = (char *) gl_extension_string; 3511 xcb_parts[6].iov_len = gl_str_len * sizeof(char); 3512 xcb_parts[7].iov_base = 0; 3513 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 3514 /* char glx_extension_string */ 3515 xcb_parts[8].iov_base = (char *) glx_extension_string; 3516 xcb_parts[8].iov_len = glx_str_len * sizeof(char); 3517 xcb_parts[9].iov_base = 0; 3518 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 3519 3520 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3521 return xcb_ret; 3522 } 3523 3524 uint32_t * 3525 xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R) 3526 { 3527 return (uint32_t *) (R + 1); 3528 } 3529 3530 int 3531 xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R) 3532 { 3533 return (R->num_versions * 3); 3534 } 3535 3536 xcb_generic_iterator_t 3537 xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R) 3538 { 3539 xcb_generic_iterator_t i; 3540 i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 3)); 3541 i.rem = 0; 3542 i.index = (char *) i.data - (char *) R; 3543 return i; 3544 } 3545 3546 char * 3547 xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) 3548 { 3549 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); 3550 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3551 } 3552 3553 int 3554 xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) 3555 { 3556 return R->gl_str_len; 3557 } 3558 3559 xcb_generic_iterator_t 3560 xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) 3561 { 3562 xcb_generic_iterator_t i; 3563 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); 3564 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); 3565 i.rem = 0; 3566 i.index = (char *) i.data - (char *) R; 3567 return i; 3568 } 3569 3570 char * 3571 xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) 3572 { 3573 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); 3574 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 3575 } 3576 3577 int 3578 xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) 3579 { 3580 return R->glx_str_len; 3581 } 3582 3583 xcb_generic_iterator_t 3584 xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) 3585 { 3586 xcb_generic_iterator_t i; 3587 xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); 3588 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->glx_str_len); 3589 i.rem = 0; 3590 i.index = (char *) i.data - (char *) R; 3591 return i; 3592 } 3593 3594 xcb_void_cookie_t 3595 xcb_glx_new_list_checked (xcb_connection_t *c, 3596 xcb_glx_context_tag_t context_tag, 3597 uint32_t list, 3598 uint32_t mode) 3599 { 3600 static const xcb_protocol_request_t xcb_req = { 3601 .count = 2, 3602 .ext = &xcb_glx_id, 3603 .opcode = XCB_GLX_NEW_LIST, 3604 .isvoid = 1 3605 }; 3606 3607 struct iovec xcb_parts[4]; 3608 xcb_void_cookie_t xcb_ret; 3609 xcb_glx_new_list_request_t xcb_out; 3610 3611 xcb_out.context_tag = context_tag; 3612 xcb_out.list = list; 3613 xcb_out.mode = mode; 3614 3615 xcb_parts[2].iov_base = (char *) &xcb_out; 3616 xcb_parts[2].iov_len = sizeof(xcb_out); 3617 xcb_parts[3].iov_base = 0; 3618 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3619 3620 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3621 return xcb_ret; 3622 } 3623 3624 xcb_void_cookie_t 3625 xcb_glx_new_list (xcb_connection_t *c, 3626 xcb_glx_context_tag_t context_tag, 3627 uint32_t list, 3628 uint32_t mode) 3629 { 3630 static const xcb_protocol_request_t xcb_req = { 3631 .count = 2, 3632 .ext = &xcb_glx_id, 3633 .opcode = XCB_GLX_NEW_LIST, 3634 .isvoid = 1 3635 }; 3636 3637 struct iovec xcb_parts[4]; 3638 xcb_void_cookie_t xcb_ret; 3639 xcb_glx_new_list_request_t xcb_out; 3640 3641 xcb_out.context_tag = context_tag; 3642 xcb_out.list = list; 3643 xcb_out.mode = mode; 3644 3645 xcb_parts[2].iov_base = (char *) &xcb_out; 3646 xcb_parts[2].iov_len = sizeof(xcb_out); 3647 xcb_parts[3].iov_base = 0; 3648 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3649 3650 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3651 return xcb_ret; 3652 } 3653 3654 xcb_void_cookie_t 3655 xcb_glx_end_list_checked (xcb_connection_t *c, 3656 xcb_glx_context_tag_t context_tag) 3657 { 3658 static const xcb_protocol_request_t xcb_req = { 3659 .count = 2, 3660 .ext = &xcb_glx_id, 3661 .opcode = XCB_GLX_END_LIST, 3662 .isvoid = 1 3663 }; 3664 3665 struct iovec xcb_parts[4]; 3666 xcb_void_cookie_t xcb_ret; 3667 xcb_glx_end_list_request_t xcb_out; 3668 3669 xcb_out.context_tag = context_tag; 3670 3671 xcb_parts[2].iov_base = (char *) &xcb_out; 3672 xcb_parts[2].iov_len = sizeof(xcb_out); 3673 xcb_parts[3].iov_base = 0; 3674 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3675 3676 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3677 return xcb_ret; 3678 } 3679 3680 xcb_void_cookie_t 3681 xcb_glx_end_list (xcb_connection_t *c, 3682 xcb_glx_context_tag_t context_tag) 3683 { 3684 static const xcb_protocol_request_t xcb_req = { 3685 .count = 2, 3686 .ext = &xcb_glx_id, 3687 .opcode = XCB_GLX_END_LIST, 3688 .isvoid = 1 3689 }; 3690 3691 struct iovec xcb_parts[4]; 3692 xcb_void_cookie_t xcb_ret; 3693 xcb_glx_end_list_request_t xcb_out; 3694 3695 xcb_out.context_tag = context_tag; 3696 3697 xcb_parts[2].iov_base = (char *) &xcb_out; 3698 xcb_parts[2].iov_len = sizeof(xcb_out); 3699 xcb_parts[3].iov_base = 0; 3700 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3701 3702 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3703 return xcb_ret; 3704 } 3705 3706 xcb_void_cookie_t 3707 xcb_glx_delete_lists_checked (xcb_connection_t *c, 3708 xcb_glx_context_tag_t context_tag, 3709 uint32_t list, 3710 int32_t range) 3711 { 3712 static const xcb_protocol_request_t xcb_req = { 3713 .count = 2, 3714 .ext = &xcb_glx_id, 3715 .opcode = XCB_GLX_DELETE_LISTS, 3716 .isvoid = 1 3717 }; 3718 3719 struct iovec xcb_parts[4]; 3720 xcb_void_cookie_t xcb_ret; 3721 xcb_glx_delete_lists_request_t xcb_out; 3722 3723 xcb_out.context_tag = context_tag; 3724 xcb_out.list = list; 3725 xcb_out.range = range; 3726 3727 xcb_parts[2].iov_base = (char *) &xcb_out; 3728 xcb_parts[2].iov_len = sizeof(xcb_out); 3729 xcb_parts[3].iov_base = 0; 3730 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3731 3732 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3733 return xcb_ret; 3734 } 3735 3736 xcb_void_cookie_t 3737 xcb_glx_delete_lists (xcb_connection_t *c, 3738 xcb_glx_context_tag_t context_tag, 3739 uint32_t list, 3740 int32_t range) 3741 { 3742 static const xcb_protocol_request_t xcb_req = { 3743 .count = 2, 3744 .ext = &xcb_glx_id, 3745 .opcode = XCB_GLX_DELETE_LISTS, 3746 .isvoid = 1 3747 }; 3748 3749 struct iovec xcb_parts[4]; 3750 xcb_void_cookie_t xcb_ret; 3751 xcb_glx_delete_lists_request_t xcb_out; 3752 3753 xcb_out.context_tag = context_tag; 3754 xcb_out.list = list; 3755 xcb_out.range = range; 3756 3757 xcb_parts[2].iov_base = (char *) &xcb_out; 3758 xcb_parts[2].iov_len = sizeof(xcb_out); 3759 xcb_parts[3].iov_base = 0; 3760 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3761 3762 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3763 return xcb_ret; 3764 } 3765 3766 xcb_glx_gen_lists_cookie_t 3767 xcb_glx_gen_lists (xcb_connection_t *c, 3768 xcb_glx_context_tag_t context_tag, 3769 int32_t range) 3770 { 3771 static const xcb_protocol_request_t xcb_req = { 3772 .count = 2, 3773 .ext = &xcb_glx_id, 3774 .opcode = XCB_GLX_GEN_LISTS, 3775 .isvoid = 0 3776 }; 3777 3778 struct iovec xcb_parts[4]; 3779 xcb_glx_gen_lists_cookie_t xcb_ret; 3780 xcb_glx_gen_lists_request_t xcb_out; 3781 3782 xcb_out.context_tag = context_tag; 3783 xcb_out.range = range; 3784 3785 xcb_parts[2].iov_base = (char *) &xcb_out; 3786 xcb_parts[2].iov_len = sizeof(xcb_out); 3787 xcb_parts[3].iov_base = 0; 3788 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3789 3790 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3791 return xcb_ret; 3792 } 3793 3794 xcb_glx_gen_lists_cookie_t 3795 xcb_glx_gen_lists_unchecked (xcb_connection_t *c, 3796 xcb_glx_context_tag_t context_tag, 3797 int32_t range) 3798 { 3799 static const xcb_protocol_request_t xcb_req = { 3800 .count = 2, 3801 .ext = &xcb_glx_id, 3802 .opcode = XCB_GLX_GEN_LISTS, 3803 .isvoid = 0 3804 }; 3805 3806 struct iovec xcb_parts[4]; 3807 xcb_glx_gen_lists_cookie_t xcb_ret; 3808 xcb_glx_gen_lists_request_t xcb_out; 3809 3810 xcb_out.context_tag = context_tag; 3811 xcb_out.range = range; 3812 3813 xcb_parts[2].iov_base = (char *) &xcb_out; 3814 xcb_parts[2].iov_len = sizeof(xcb_out); 3815 xcb_parts[3].iov_base = 0; 3816 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3817 3818 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3819 return xcb_ret; 3820 } 3821 3822 xcb_glx_gen_lists_reply_t * 3823 xcb_glx_gen_lists_reply (xcb_connection_t *c, 3824 xcb_glx_gen_lists_cookie_t cookie /**< */, 3825 xcb_generic_error_t **e) 3826 { 3827 return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3828 } 3829 3830 xcb_void_cookie_t 3831 xcb_glx_feedback_buffer_checked (xcb_connection_t *c, 3832 xcb_glx_context_tag_t context_tag, 3833 int32_t size, 3834 int32_t type) 3835 { 3836 static const xcb_protocol_request_t xcb_req = { 3837 .count = 2, 3838 .ext = &xcb_glx_id, 3839 .opcode = XCB_GLX_FEEDBACK_BUFFER, 3840 .isvoid = 1 3841 }; 3842 3843 struct iovec xcb_parts[4]; 3844 xcb_void_cookie_t xcb_ret; 3845 xcb_glx_feedback_buffer_request_t xcb_out; 3846 3847 xcb_out.context_tag = context_tag; 3848 xcb_out.size = size; 3849 xcb_out.type = type; 3850 3851 xcb_parts[2].iov_base = (char *) &xcb_out; 3852 xcb_parts[2].iov_len = sizeof(xcb_out); 3853 xcb_parts[3].iov_base = 0; 3854 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3855 3856 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3857 return xcb_ret; 3858 } 3859 3860 xcb_void_cookie_t 3861 xcb_glx_feedback_buffer (xcb_connection_t *c, 3862 xcb_glx_context_tag_t context_tag, 3863 int32_t size, 3864 int32_t type) 3865 { 3866 static const xcb_protocol_request_t xcb_req = { 3867 .count = 2, 3868 .ext = &xcb_glx_id, 3869 .opcode = XCB_GLX_FEEDBACK_BUFFER, 3870 .isvoid = 1 3871 }; 3872 3873 struct iovec xcb_parts[4]; 3874 xcb_void_cookie_t xcb_ret; 3875 xcb_glx_feedback_buffer_request_t xcb_out; 3876 3877 xcb_out.context_tag = context_tag; 3878 xcb_out.size = size; 3879 xcb_out.type = type; 3880 3881 xcb_parts[2].iov_base = (char *) &xcb_out; 3882 xcb_parts[2].iov_len = sizeof(xcb_out); 3883 xcb_parts[3].iov_base = 0; 3884 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3885 3886 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3887 return xcb_ret; 3888 } 3889 3890 xcb_void_cookie_t 3891 xcb_glx_select_buffer_checked (xcb_connection_t *c, 3892 xcb_glx_context_tag_t context_tag, 3893 int32_t size) 3894 { 3895 static const xcb_protocol_request_t xcb_req = { 3896 .count = 2, 3897 .ext = &xcb_glx_id, 3898 .opcode = XCB_GLX_SELECT_BUFFER, 3899 .isvoid = 1 3900 }; 3901 3902 struct iovec xcb_parts[4]; 3903 xcb_void_cookie_t xcb_ret; 3904 xcb_glx_select_buffer_request_t xcb_out; 3905 3906 xcb_out.context_tag = context_tag; 3907 xcb_out.size = size; 3908 3909 xcb_parts[2].iov_base = (char *) &xcb_out; 3910 xcb_parts[2].iov_len = sizeof(xcb_out); 3911 xcb_parts[3].iov_base = 0; 3912 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3913 3914 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3915 return xcb_ret; 3916 } 3917 3918 xcb_void_cookie_t 3919 xcb_glx_select_buffer (xcb_connection_t *c, 3920 xcb_glx_context_tag_t context_tag, 3921 int32_t size) 3922 { 3923 static const xcb_protocol_request_t xcb_req = { 3924 .count = 2, 3925 .ext = &xcb_glx_id, 3926 .opcode = XCB_GLX_SELECT_BUFFER, 3927 .isvoid = 1 3928 }; 3929 3930 struct iovec xcb_parts[4]; 3931 xcb_void_cookie_t xcb_ret; 3932 xcb_glx_select_buffer_request_t xcb_out; 3933 3934 xcb_out.context_tag = context_tag; 3935 xcb_out.size = size; 3936 3937 xcb_parts[2].iov_base = (char *) &xcb_out; 3938 xcb_parts[2].iov_len = sizeof(xcb_out); 3939 xcb_parts[3].iov_base = 0; 3940 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3941 3942 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3943 return xcb_ret; 3944 } 3945 3946 int 3947 xcb_glx_render_mode_sizeof (const void *_buffer) 3948 { 3949 char *xcb_tmp = (char *)_buffer; 3950 const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer; 3951 unsigned int xcb_buffer_len = 0; 3952 unsigned int xcb_block_len = 0; 3953 unsigned int xcb_pad = 0; 3954 unsigned int xcb_align_to = 0; 3955 3956 3957 xcb_block_len += sizeof(xcb_glx_render_mode_reply_t); 3958 xcb_tmp += xcb_block_len; 3959 xcb_buffer_len += xcb_block_len; 3960 xcb_block_len = 0; 3961 /* data */ 3962 xcb_block_len += _aux->n * sizeof(uint32_t); 3963 xcb_tmp += xcb_block_len; 3964 xcb_align_to = ALIGNOF(uint32_t); 3965 /* insert padding */ 3966 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3967 xcb_buffer_len += xcb_block_len + xcb_pad; 3968 if (0 != xcb_pad) { 3969 xcb_tmp += xcb_pad; 3970 xcb_pad = 0; 3971 } 3972 xcb_block_len = 0; 3973 3974 return xcb_buffer_len; 3975 } 3976 3977 xcb_glx_render_mode_cookie_t 3978 xcb_glx_render_mode (xcb_connection_t *c, 3979 xcb_glx_context_tag_t context_tag, 3980 uint32_t mode) 3981 { 3982 static const xcb_protocol_request_t xcb_req = { 3983 .count = 2, 3984 .ext = &xcb_glx_id, 3985 .opcode = XCB_GLX_RENDER_MODE, 3986 .isvoid = 0 3987 }; 3988 3989 struct iovec xcb_parts[4]; 3990 xcb_glx_render_mode_cookie_t xcb_ret; 3991 xcb_glx_render_mode_request_t xcb_out; 3992 3993 xcb_out.context_tag = context_tag; 3994 xcb_out.mode = mode; 3995 3996 xcb_parts[2].iov_base = (char *) &xcb_out; 3997 xcb_parts[2].iov_len = sizeof(xcb_out); 3998 xcb_parts[3].iov_base = 0; 3999 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4000 4001 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4002 return xcb_ret; 4003 } 4004 4005 xcb_glx_render_mode_cookie_t 4006 xcb_glx_render_mode_unchecked (xcb_connection_t *c, 4007 xcb_glx_context_tag_t context_tag, 4008 uint32_t mode) 4009 { 4010 static const xcb_protocol_request_t xcb_req = { 4011 .count = 2, 4012 .ext = &xcb_glx_id, 4013 .opcode = XCB_GLX_RENDER_MODE, 4014 .isvoid = 0 4015 }; 4016 4017 struct iovec xcb_parts[4]; 4018 xcb_glx_render_mode_cookie_t xcb_ret; 4019 xcb_glx_render_mode_request_t xcb_out; 4020 4021 xcb_out.context_tag = context_tag; 4022 xcb_out.mode = mode; 4023 4024 xcb_parts[2].iov_base = (char *) &xcb_out; 4025 xcb_parts[2].iov_len = sizeof(xcb_out); 4026 xcb_parts[3].iov_base = 0; 4027 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4028 4029 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4030 return xcb_ret; 4031 } 4032 4033 uint32_t * 4034 xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R) 4035 { 4036 return (uint32_t *) (R + 1); 4037 } 4038 4039 int 4040 xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R) 4041 { 4042 return R->n; 4043 } 4044 4045 xcb_generic_iterator_t 4046 xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R) 4047 { 4048 xcb_generic_iterator_t i; 4049 i.data = ((uint32_t *) (R + 1)) + (R->n); 4050 i.rem = 0; 4051 i.index = (char *) i.data - (char *) R; 4052 return i; 4053 } 4054 4055 xcb_glx_render_mode_reply_t * 4056 xcb_glx_render_mode_reply (xcb_connection_t *c, 4057 xcb_glx_render_mode_cookie_t cookie /**< */, 4058 xcb_generic_error_t **e) 4059 { 4060 return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4061 } 4062 4063 xcb_glx_finish_cookie_t 4064 xcb_glx_finish (xcb_connection_t *c, 4065 xcb_glx_context_tag_t context_tag) 4066 { 4067 static const xcb_protocol_request_t xcb_req = { 4068 .count = 2, 4069 .ext = &xcb_glx_id, 4070 .opcode = XCB_GLX_FINISH, 4071 .isvoid = 0 4072 }; 4073 4074 struct iovec xcb_parts[4]; 4075 xcb_glx_finish_cookie_t xcb_ret; 4076 xcb_glx_finish_request_t xcb_out; 4077 4078 xcb_out.context_tag = context_tag; 4079 4080 xcb_parts[2].iov_base = (char *) &xcb_out; 4081 xcb_parts[2].iov_len = sizeof(xcb_out); 4082 xcb_parts[3].iov_base = 0; 4083 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4084 4085 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4086 return xcb_ret; 4087 } 4088 4089 xcb_glx_finish_cookie_t 4090 xcb_glx_finish_unchecked (xcb_connection_t *c, 4091 xcb_glx_context_tag_t context_tag) 4092 { 4093 static const xcb_protocol_request_t xcb_req = { 4094 .count = 2, 4095 .ext = &xcb_glx_id, 4096 .opcode = XCB_GLX_FINISH, 4097 .isvoid = 0 4098 }; 4099 4100 struct iovec xcb_parts[4]; 4101 xcb_glx_finish_cookie_t xcb_ret; 4102 xcb_glx_finish_request_t xcb_out; 4103 4104 xcb_out.context_tag = context_tag; 4105 4106 xcb_parts[2].iov_base = (char *) &xcb_out; 4107 xcb_parts[2].iov_len = sizeof(xcb_out); 4108 xcb_parts[3].iov_base = 0; 4109 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4110 4111 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4112 return xcb_ret; 4113 } 4114 4115 xcb_glx_finish_reply_t * 4116 xcb_glx_finish_reply (xcb_connection_t *c, 4117 xcb_glx_finish_cookie_t cookie /**< */, 4118 xcb_generic_error_t **e) 4119 { 4120 return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4121 } 4122 4123 xcb_void_cookie_t 4124 xcb_glx_pixel_storef_checked (xcb_connection_t *c, 4125 xcb_glx_context_tag_t context_tag, 4126 uint32_t pname, 4127 xcb_glx_float32_t datum) 4128 { 4129 static const xcb_protocol_request_t xcb_req = { 4130 .count = 2, 4131 .ext = &xcb_glx_id, 4132 .opcode = XCB_GLX_PIXEL_STOREF, 4133 .isvoid = 1 4134 }; 4135 4136 struct iovec xcb_parts[4]; 4137 xcb_void_cookie_t xcb_ret; 4138 xcb_glx_pixel_storef_request_t xcb_out; 4139 4140 xcb_out.context_tag = context_tag; 4141 xcb_out.pname = pname; 4142 xcb_out.datum = datum; 4143 4144 xcb_parts[2].iov_base = (char *) &xcb_out; 4145 xcb_parts[2].iov_len = sizeof(xcb_out); 4146 xcb_parts[3].iov_base = 0; 4147 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4148 4149 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4150 return xcb_ret; 4151 } 4152 4153 xcb_void_cookie_t 4154 xcb_glx_pixel_storef (xcb_connection_t *c, 4155 xcb_glx_context_tag_t context_tag, 4156 uint32_t pname, 4157 xcb_glx_float32_t datum) 4158 { 4159 static const xcb_protocol_request_t xcb_req = { 4160 .count = 2, 4161 .ext = &xcb_glx_id, 4162 .opcode = XCB_GLX_PIXEL_STOREF, 4163 .isvoid = 1 4164 }; 4165 4166 struct iovec xcb_parts[4]; 4167 xcb_void_cookie_t xcb_ret; 4168 xcb_glx_pixel_storef_request_t xcb_out; 4169 4170 xcb_out.context_tag = context_tag; 4171 xcb_out.pname = pname; 4172 xcb_out.datum = datum; 4173 4174 xcb_parts[2].iov_base = (char *) &xcb_out; 4175 xcb_parts[2].iov_len = sizeof(xcb_out); 4176 xcb_parts[3].iov_base = 0; 4177 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4178 4179 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4180 return xcb_ret; 4181 } 4182 4183 xcb_void_cookie_t 4184 xcb_glx_pixel_storei_checked (xcb_connection_t *c, 4185 xcb_glx_context_tag_t context_tag, 4186 uint32_t pname, 4187 int32_t datum) 4188 { 4189 static const xcb_protocol_request_t xcb_req = { 4190 .count = 2, 4191 .ext = &xcb_glx_id, 4192 .opcode = XCB_GLX_PIXEL_STOREI, 4193 .isvoid = 1 4194 }; 4195 4196 struct iovec xcb_parts[4]; 4197 xcb_void_cookie_t xcb_ret; 4198 xcb_glx_pixel_storei_request_t xcb_out; 4199 4200 xcb_out.context_tag = context_tag; 4201 xcb_out.pname = pname; 4202 xcb_out.datum = datum; 4203 4204 xcb_parts[2].iov_base = (char *) &xcb_out; 4205 xcb_parts[2].iov_len = sizeof(xcb_out); 4206 xcb_parts[3].iov_base = 0; 4207 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4208 4209 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4210 return xcb_ret; 4211 } 4212 4213 xcb_void_cookie_t 4214 xcb_glx_pixel_storei (xcb_connection_t *c, 4215 xcb_glx_context_tag_t context_tag, 4216 uint32_t pname, 4217 int32_t datum) 4218 { 4219 static const xcb_protocol_request_t xcb_req = { 4220 .count = 2, 4221 .ext = &xcb_glx_id, 4222 .opcode = XCB_GLX_PIXEL_STOREI, 4223 .isvoid = 1 4224 }; 4225 4226 struct iovec xcb_parts[4]; 4227 xcb_void_cookie_t xcb_ret; 4228 xcb_glx_pixel_storei_request_t xcb_out; 4229 4230 xcb_out.context_tag = context_tag; 4231 xcb_out.pname = pname; 4232 xcb_out.datum = datum; 4233 4234 xcb_parts[2].iov_base = (char *) &xcb_out; 4235 xcb_parts[2].iov_len = sizeof(xcb_out); 4236 xcb_parts[3].iov_base = 0; 4237 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4238 4239 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4240 return xcb_ret; 4241 } 4242 4243 int 4244 xcb_glx_read_pixels_sizeof (const void *_buffer) 4245 { 4246 char *xcb_tmp = (char *)_buffer; 4247 const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer; 4248 unsigned int xcb_buffer_len = 0; 4249 unsigned int xcb_block_len = 0; 4250 unsigned int xcb_pad = 0; 4251 unsigned int xcb_align_to = 0; 4252 4253 4254 xcb_block_len += sizeof(xcb_glx_read_pixels_reply_t); 4255 xcb_tmp += xcb_block_len; 4256 xcb_buffer_len += xcb_block_len; 4257 xcb_block_len = 0; 4258 /* data */ 4259 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 4260 xcb_tmp += xcb_block_len; 4261 xcb_align_to = ALIGNOF(uint8_t); 4262 /* insert padding */ 4263 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4264 xcb_buffer_len += xcb_block_len + xcb_pad; 4265 if (0 != xcb_pad) { 4266 xcb_tmp += xcb_pad; 4267 xcb_pad = 0; 4268 } 4269 xcb_block_len = 0; 4270 4271 return xcb_buffer_len; 4272 } 4273 4274 xcb_glx_read_pixels_cookie_t 4275 xcb_glx_read_pixels (xcb_connection_t *c, 4276 xcb_glx_context_tag_t context_tag, 4277 int32_t x, 4278 int32_t y, 4279 int32_t width, 4280 int32_t height, 4281 uint32_t format, 4282 uint32_t type, 4283 uint8_t swap_bytes, 4284 uint8_t lsb_first) 4285 { 4286 static const xcb_protocol_request_t xcb_req = { 4287 .count = 2, 4288 .ext = &xcb_glx_id, 4289 .opcode = XCB_GLX_READ_PIXELS, 4290 .isvoid = 0 4291 }; 4292 4293 struct iovec xcb_parts[4]; 4294 xcb_glx_read_pixels_cookie_t xcb_ret; 4295 xcb_glx_read_pixels_request_t xcb_out; 4296 4297 xcb_out.context_tag = context_tag; 4298 xcb_out.x = x; 4299 xcb_out.y = y; 4300 xcb_out.width = width; 4301 xcb_out.height = height; 4302 xcb_out.format = format; 4303 xcb_out.type = type; 4304 xcb_out.swap_bytes = swap_bytes; 4305 xcb_out.lsb_first = lsb_first; 4306 4307 xcb_parts[2].iov_base = (char *) &xcb_out; 4308 xcb_parts[2].iov_len = sizeof(xcb_out); 4309 xcb_parts[3].iov_base = 0; 4310 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4311 4312 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4313 return xcb_ret; 4314 } 4315 4316 xcb_glx_read_pixels_cookie_t 4317 xcb_glx_read_pixels_unchecked (xcb_connection_t *c, 4318 xcb_glx_context_tag_t context_tag, 4319 int32_t x, 4320 int32_t y, 4321 int32_t width, 4322 int32_t height, 4323 uint32_t format, 4324 uint32_t type, 4325 uint8_t swap_bytes, 4326 uint8_t lsb_first) 4327 { 4328 static const xcb_protocol_request_t xcb_req = { 4329 .count = 2, 4330 .ext = &xcb_glx_id, 4331 .opcode = XCB_GLX_READ_PIXELS, 4332 .isvoid = 0 4333 }; 4334 4335 struct iovec xcb_parts[4]; 4336 xcb_glx_read_pixels_cookie_t xcb_ret; 4337 xcb_glx_read_pixels_request_t xcb_out; 4338 4339 xcb_out.context_tag = context_tag; 4340 xcb_out.x = x; 4341 xcb_out.y = y; 4342 xcb_out.width = width; 4343 xcb_out.height = height; 4344 xcb_out.format = format; 4345 xcb_out.type = type; 4346 xcb_out.swap_bytes = swap_bytes; 4347 xcb_out.lsb_first = lsb_first; 4348 4349 xcb_parts[2].iov_base = (char *) &xcb_out; 4350 xcb_parts[2].iov_len = sizeof(xcb_out); 4351 xcb_parts[3].iov_base = 0; 4352 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4353 4354 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4355 return xcb_ret; 4356 } 4357 4358 uint8_t * 4359 xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R) 4360 { 4361 return (uint8_t *) (R + 1); 4362 } 4363 4364 int 4365 xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R) 4366 { 4367 return (R->length * 4); 4368 } 4369 4370 xcb_generic_iterator_t 4371 xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R) 4372 { 4373 xcb_generic_iterator_t i; 4374 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 4375 i.rem = 0; 4376 i.index = (char *) i.data - (char *) R; 4377 return i; 4378 } 4379 4380 xcb_glx_read_pixels_reply_t * 4381 xcb_glx_read_pixels_reply (xcb_connection_t *c, 4382 xcb_glx_read_pixels_cookie_t cookie /**< */, 4383 xcb_generic_error_t **e) 4384 { 4385 return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4386 } 4387 4388 int 4389 xcb_glx_get_booleanv_sizeof (const void *_buffer) 4390 { 4391 char *xcb_tmp = (char *)_buffer; 4392 const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer; 4393 unsigned int xcb_buffer_len = 0; 4394 unsigned int xcb_block_len = 0; 4395 unsigned int xcb_pad = 0; 4396 unsigned int xcb_align_to = 0; 4397 4398 4399 xcb_block_len += sizeof(xcb_glx_get_booleanv_reply_t); 4400 xcb_tmp += xcb_block_len; 4401 xcb_buffer_len += xcb_block_len; 4402 xcb_block_len = 0; 4403 /* data */ 4404 xcb_block_len += _aux->n * sizeof(uint8_t); 4405 xcb_tmp += xcb_block_len; 4406 xcb_align_to = ALIGNOF(uint8_t); 4407 /* insert padding */ 4408 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4409 xcb_buffer_len += xcb_block_len + xcb_pad; 4410 if (0 != xcb_pad) { 4411 xcb_tmp += xcb_pad; 4412 xcb_pad = 0; 4413 } 4414 xcb_block_len = 0; 4415 4416 return xcb_buffer_len; 4417 } 4418 4419 xcb_glx_get_booleanv_cookie_t 4420 xcb_glx_get_booleanv (xcb_connection_t *c, 4421 xcb_glx_context_tag_t context_tag, 4422 int32_t pname) 4423 { 4424 static const xcb_protocol_request_t xcb_req = { 4425 .count = 2, 4426 .ext = &xcb_glx_id, 4427 .opcode = XCB_GLX_GET_BOOLEANV, 4428 .isvoid = 0 4429 }; 4430 4431 struct iovec xcb_parts[4]; 4432 xcb_glx_get_booleanv_cookie_t xcb_ret; 4433 xcb_glx_get_booleanv_request_t xcb_out; 4434 4435 xcb_out.context_tag = context_tag; 4436 xcb_out.pname = pname; 4437 4438 xcb_parts[2].iov_base = (char *) &xcb_out; 4439 xcb_parts[2].iov_len = sizeof(xcb_out); 4440 xcb_parts[3].iov_base = 0; 4441 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4442 4443 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4444 return xcb_ret; 4445 } 4446 4447 xcb_glx_get_booleanv_cookie_t 4448 xcb_glx_get_booleanv_unchecked (xcb_connection_t *c, 4449 xcb_glx_context_tag_t context_tag, 4450 int32_t pname) 4451 { 4452 static const xcb_protocol_request_t xcb_req = { 4453 .count = 2, 4454 .ext = &xcb_glx_id, 4455 .opcode = XCB_GLX_GET_BOOLEANV, 4456 .isvoid = 0 4457 }; 4458 4459 struct iovec xcb_parts[4]; 4460 xcb_glx_get_booleanv_cookie_t xcb_ret; 4461 xcb_glx_get_booleanv_request_t xcb_out; 4462 4463 xcb_out.context_tag = context_tag; 4464 xcb_out.pname = pname; 4465 4466 xcb_parts[2].iov_base = (char *) &xcb_out; 4467 xcb_parts[2].iov_len = sizeof(xcb_out); 4468 xcb_parts[3].iov_base = 0; 4469 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4470 4471 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4472 return xcb_ret; 4473 } 4474 4475 uint8_t * 4476 xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R) 4477 { 4478 return (uint8_t *) (R + 1); 4479 } 4480 4481 int 4482 xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R) 4483 { 4484 return R->n; 4485 } 4486 4487 xcb_generic_iterator_t 4488 xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R) 4489 { 4490 xcb_generic_iterator_t i; 4491 i.data = ((uint8_t *) (R + 1)) + (R->n); 4492 i.rem = 0; 4493 i.index = (char *) i.data - (char *) R; 4494 return i; 4495 } 4496 4497 xcb_glx_get_booleanv_reply_t * 4498 xcb_glx_get_booleanv_reply (xcb_connection_t *c, 4499 xcb_glx_get_booleanv_cookie_t cookie /**< */, 4500 xcb_generic_error_t **e) 4501 { 4502 return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4503 } 4504 4505 int 4506 xcb_glx_get_clip_plane_sizeof (const void *_buffer) 4507 { 4508 char *xcb_tmp = (char *)_buffer; 4509 const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer; 4510 unsigned int xcb_buffer_len = 0; 4511 unsigned int xcb_block_len = 0; 4512 unsigned int xcb_pad = 0; 4513 unsigned int xcb_align_to = 0; 4514 4515 4516 xcb_block_len += sizeof(xcb_glx_get_clip_plane_reply_t); 4517 xcb_tmp += xcb_block_len; 4518 xcb_buffer_len += xcb_block_len; 4519 xcb_block_len = 0; 4520 /* data */ 4521 xcb_block_len += (_aux->length / 2) * sizeof(xcb_glx_float64_t); 4522 xcb_tmp += xcb_block_len; 4523 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 4524 /* insert padding */ 4525 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4526 xcb_buffer_len += xcb_block_len + xcb_pad; 4527 if (0 != xcb_pad) { 4528 xcb_tmp += xcb_pad; 4529 xcb_pad = 0; 4530 } 4531 xcb_block_len = 0; 4532 4533 return xcb_buffer_len; 4534 } 4535 4536 xcb_glx_get_clip_plane_cookie_t 4537 xcb_glx_get_clip_plane (xcb_connection_t *c, 4538 xcb_glx_context_tag_t context_tag, 4539 int32_t plane) 4540 { 4541 static const xcb_protocol_request_t xcb_req = { 4542 .count = 2, 4543 .ext = &xcb_glx_id, 4544 .opcode = XCB_GLX_GET_CLIP_PLANE, 4545 .isvoid = 0 4546 }; 4547 4548 struct iovec xcb_parts[4]; 4549 xcb_glx_get_clip_plane_cookie_t xcb_ret; 4550 xcb_glx_get_clip_plane_request_t xcb_out; 4551 4552 xcb_out.context_tag = context_tag; 4553 xcb_out.plane = plane; 4554 4555 xcb_parts[2].iov_base = (char *) &xcb_out; 4556 xcb_parts[2].iov_len = sizeof(xcb_out); 4557 xcb_parts[3].iov_base = 0; 4558 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4559 4560 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4561 return xcb_ret; 4562 } 4563 4564 xcb_glx_get_clip_plane_cookie_t 4565 xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c, 4566 xcb_glx_context_tag_t context_tag, 4567 int32_t plane) 4568 { 4569 static const xcb_protocol_request_t xcb_req = { 4570 .count = 2, 4571 .ext = &xcb_glx_id, 4572 .opcode = XCB_GLX_GET_CLIP_PLANE, 4573 .isvoid = 0 4574 }; 4575 4576 struct iovec xcb_parts[4]; 4577 xcb_glx_get_clip_plane_cookie_t xcb_ret; 4578 xcb_glx_get_clip_plane_request_t xcb_out; 4579 4580 xcb_out.context_tag = context_tag; 4581 xcb_out.plane = plane; 4582 4583 xcb_parts[2].iov_base = (char *) &xcb_out; 4584 xcb_parts[2].iov_len = sizeof(xcb_out); 4585 xcb_parts[3].iov_base = 0; 4586 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4587 4588 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4589 return xcb_ret; 4590 } 4591 4592 xcb_glx_float64_t * 4593 xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R) 4594 { 4595 return (xcb_glx_float64_t *) (R + 1); 4596 } 4597 4598 int 4599 xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R) 4600 { 4601 return (R->length / 2); 4602 } 4603 4604 xcb_generic_iterator_t 4605 xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R) 4606 { 4607 xcb_generic_iterator_t i; 4608 i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2)); 4609 i.rem = 0; 4610 i.index = (char *) i.data - (char *) R; 4611 return i; 4612 } 4613 4614 xcb_glx_get_clip_plane_reply_t * 4615 xcb_glx_get_clip_plane_reply (xcb_connection_t *c, 4616 xcb_glx_get_clip_plane_cookie_t cookie /**< */, 4617 xcb_generic_error_t **e) 4618 { 4619 return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4620 } 4621 4622 int 4623 xcb_glx_get_doublev_sizeof (const void *_buffer) 4624 { 4625 char *xcb_tmp = (char *)_buffer; 4626 const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer; 4627 unsigned int xcb_buffer_len = 0; 4628 unsigned int xcb_block_len = 0; 4629 unsigned int xcb_pad = 0; 4630 unsigned int xcb_align_to = 0; 4631 4632 4633 xcb_block_len += sizeof(xcb_glx_get_doublev_reply_t); 4634 xcb_tmp += xcb_block_len; 4635 xcb_buffer_len += xcb_block_len; 4636 xcb_block_len = 0; 4637 /* data */ 4638 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 4639 xcb_tmp += xcb_block_len; 4640 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 4641 /* insert padding */ 4642 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4643 xcb_buffer_len += xcb_block_len + xcb_pad; 4644 if (0 != xcb_pad) { 4645 xcb_tmp += xcb_pad; 4646 xcb_pad = 0; 4647 } 4648 xcb_block_len = 0; 4649 4650 return xcb_buffer_len; 4651 } 4652 4653 xcb_glx_get_doublev_cookie_t 4654 xcb_glx_get_doublev (xcb_connection_t *c, 4655 xcb_glx_context_tag_t context_tag, 4656 uint32_t pname) 4657 { 4658 static const xcb_protocol_request_t xcb_req = { 4659 .count = 2, 4660 .ext = &xcb_glx_id, 4661 .opcode = XCB_GLX_GET_DOUBLEV, 4662 .isvoid = 0 4663 }; 4664 4665 struct iovec xcb_parts[4]; 4666 xcb_glx_get_doublev_cookie_t xcb_ret; 4667 xcb_glx_get_doublev_request_t xcb_out; 4668 4669 xcb_out.context_tag = context_tag; 4670 xcb_out.pname = pname; 4671 4672 xcb_parts[2].iov_base = (char *) &xcb_out; 4673 xcb_parts[2].iov_len = sizeof(xcb_out); 4674 xcb_parts[3].iov_base = 0; 4675 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4676 4677 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4678 return xcb_ret; 4679 } 4680 4681 xcb_glx_get_doublev_cookie_t 4682 xcb_glx_get_doublev_unchecked (xcb_connection_t *c, 4683 xcb_glx_context_tag_t context_tag, 4684 uint32_t pname) 4685 { 4686 static const xcb_protocol_request_t xcb_req = { 4687 .count = 2, 4688 .ext = &xcb_glx_id, 4689 .opcode = XCB_GLX_GET_DOUBLEV, 4690 .isvoid = 0 4691 }; 4692 4693 struct iovec xcb_parts[4]; 4694 xcb_glx_get_doublev_cookie_t xcb_ret; 4695 xcb_glx_get_doublev_request_t xcb_out; 4696 4697 xcb_out.context_tag = context_tag; 4698 xcb_out.pname = pname; 4699 4700 xcb_parts[2].iov_base = (char *) &xcb_out; 4701 xcb_parts[2].iov_len = sizeof(xcb_out); 4702 xcb_parts[3].iov_base = 0; 4703 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4704 4705 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4706 return xcb_ret; 4707 } 4708 4709 xcb_glx_float64_t * 4710 xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R) 4711 { 4712 return (xcb_glx_float64_t *) (R + 1); 4713 } 4714 4715 int 4716 xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R) 4717 { 4718 return R->n; 4719 } 4720 4721 xcb_generic_iterator_t 4722 xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R) 4723 { 4724 xcb_generic_iterator_t i; 4725 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 4726 i.rem = 0; 4727 i.index = (char *) i.data - (char *) R; 4728 return i; 4729 } 4730 4731 xcb_glx_get_doublev_reply_t * 4732 xcb_glx_get_doublev_reply (xcb_connection_t *c, 4733 xcb_glx_get_doublev_cookie_t cookie /**< */, 4734 xcb_generic_error_t **e) 4735 { 4736 return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4737 } 4738 4739 xcb_glx_get_error_cookie_t 4740 xcb_glx_get_error (xcb_connection_t *c, 4741 xcb_glx_context_tag_t context_tag) 4742 { 4743 static const xcb_protocol_request_t xcb_req = { 4744 .count = 2, 4745 .ext = &xcb_glx_id, 4746 .opcode = XCB_GLX_GET_ERROR, 4747 .isvoid = 0 4748 }; 4749 4750 struct iovec xcb_parts[4]; 4751 xcb_glx_get_error_cookie_t xcb_ret; 4752 xcb_glx_get_error_request_t xcb_out; 4753 4754 xcb_out.context_tag = context_tag; 4755 4756 xcb_parts[2].iov_base = (char *) &xcb_out; 4757 xcb_parts[2].iov_len = sizeof(xcb_out); 4758 xcb_parts[3].iov_base = 0; 4759 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4760 4761 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4762 return xcb_ret; 4763 } 4764 4765 xcb_glx_get_error_cookie_t 4766 xcb_glx_get_error_unchecked (xcb_connection_t *c, 4767 xcb_glx_context_tag_t context_tag) 4768 { 4769 static const xcb_protocol_request_t xcb_req = { 4770 .count = 2, 4771 .ext = &xcb_glx_id, 4772 .opcode = XCB_GLX_GET_ERROR, 4773 .isvoid = 0 4774 }; 4775 4776 struct iovec xcb_parts[4]; 4777 xcb_glx_get_error_cookie_t xcb_ret; 4778 xcb_glx_get_error_request_t xcb_out; 4779 4780 xcb_out.context_tag = context_tag; 4781 4782 xcb_parts[2].iov_base = (char *) &xcb_out; 4783 xcb_parts[2].iov_len = sizeof(xcb_out); 4784 xcb_parts[3].iov_base = 0; 4785 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4786 4787 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4788 return xcb_ret; 4789 } 4790 4791 xcb_glx_get_error_reply_t * 4792 xcb_glx_get_error_reply (xcb_connection_t *c, 4793 xcb_glx_get_error_cookie_t cookie /**< */, 4794 xcb_generic_error_t **e) 4795 { 4796 return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4797 } 4798 4799 int 4800 xcb_glx_get_floatv_sizeof (const void *_buffer) 4801 { 4802 char *xcb_tmp = (char *)_buffer; 4803 const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer; 4804 unsigned int xcb_buffer_len = 0; 4805 unsigned int xcb_block_len = 0; 4806 unsigned int xcb_pad = 0; 4807 unsigned int xcb_align_to = 0; 4808 4809 4810 xcb_block_len += sizeof(xcb_glx_get_floatv_reply_t); 4811 xcb_tmp += xcb_block_len; 4812 xcb_buffer_len += xcb_block_len; 4813 xcb_block_len = 0; 4814 /* data */ 4815 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 4816 xcb_tmp += xcb_block_len; 4817 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 4818 /* insert padding */ 4819 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4820 xcb_buffer_len += xcb_block_len + xcb_pad; 4821 if (0 != xcb_pad) { 4822 xcb_tmp += xcb_pad; 4823 xcb_pad = 0; 4824 } 4825 xcb_block_len = 0; 4826 4827 return xcb_buffer_len; 4828 } 4829 4830 xcb_glx_get_floatv_cookie_t 4831 xcb_glx_get_floatv (xcb_connection_t *c, 4832 xcb_glx_context_tag_t context_tag, 4833 uint32_t pname) 4834 { 4835 static const xcb_protocol_request_t xcb_req = { 4836 .count = 2, 4837 .ext = &xcb_glx_id, 4838 .opcode = XCB_GLX_GET_FLOATV, 4839 .isvoid = 0 4840 }; 4841 4842 struct iovec xcb_parts[4]; 4843 xcb_glx_get_floatv_cookie_t xcb_ret; 4844 xcb_glx_get_floatv_request_t xcb_out; 4845 4846 xcb_out.context_tag = context_tag; 4847 xcb_out.pname = pname; 4848 4849 xcb_parts[2].iov_base = (char *) &xcb_out; 4850 xcb_parts[2].iov_len = sizeof(xcb_out); 4851 xcb_parts[3].iov_base = 0; 4852 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4853 4854 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4855 return xcb_ret; 4856 } 4857 4858 xcb_glx_get_floatv_cookie_t 4859 xcb_glx_get_floatv_unchecked (xcb_connection_t *c, 4860 xcb_glx_context_tag_t context_tag, 4861 uint32_t pname) 4862 { 4863 static const xcb_protocol_request_t xcb_req = { 4864 .count = 2, 4865 .ext = &xcb_glx_id, 4866 .opcode = XCB_GLX_GET_FLOATV, 4867 .isvoid = 0 4868 }; 4869 4870 struct iovec xcb_parts[4]; 4871 xcb_glx_get_floatv_cookie_t xcb_ret; 4872 xcb_glx_get_floatv_request_t xcb_out; 4873 4874 xcb_out.context_tag = context_tag; 4875 xcb_out.pname = pname; 4876 4877 xcb_parts[2].iov_base = (char *) &xcb_out; 4878 xcb_parts[2].iov_len = sizeof(xcb_out); 4879 xcb_parts[3].iov_base = 0; 4880 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4881 4882 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4883 return xcb_ret; 4884 } 4885 4886 xcb_glx_float32_t * 4887 xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R) 4888 { 4889 return (xcb_glx_float32_t *) (R + 1); 4890 } 4891 4892 int 4893 xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R) 4894 { 4895 return R->n; 4896 } 4897 4898 xcb_generic_iterator_t 4899 xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R) 4900 { 4901 xcb_generic_iterator_t i; 4902 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 4903 i.rem = 0; 4904 i.index = (char *) i.data - (char *) R; 4905 return i; 4906 } 4907 4908 xcb_glx_get_floatv_reply_t * 4909 xcb_glx_get_floatv_reply (xcb_connection_t *c, 4910 xcb_glx_get_floatv_cookie_t cookie /**< */, 4911 xcb_generic_error_t **e) 4912 { 4913 return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4914 } 4915 4916 int 4917 xcb_glx_get_integerv_sizeof (const void *_buffer) 4918 { 4919 char *xcb_tmp = (char *)_buffer; 4920 const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer; 4921 unsigned int xcb_buffer_len = 0; 4922 unsigned int xcb_block_len = 0; 4923 unsigned int xcb_pad = 0; 4924 unsigned int xcb_align_to = 0; 4925 4926 4927 xcb_block_len += sizeof(xcb_glx_get_integerv_reply_t); 4928 xcb_tmp += xcb_block_len; 4929 xcb_buffer_len += xcb_block_len; 4930 xcb_block_len = 0; 4931 /* data */ 4932 xcb_block_len += _aux->n * sizeof(int32_t); 4933 xcb_tmp += xcb_block_len; 4934 xcb_align_to = ALIGNOF(int32_t); 4935 /* insert padding */ 4936 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4937 xcb_buffer_len += xcb_block_len + xcb_pad; 4938 if (0 != xcb_pad) { 4939 xcb_tmp += xcb_pad; 4940 xcb_pad = 0; 4941 } 4942 xcb_block_len = 0; 4943 4944 return xcb_buffer_len; 4945 } 4946 4947 xcb_glx_get_integerv_cookie_t 4948 xcb_glx_get_integerv (xcb_connection_t *c, 4949 xcb_glx_context_tag_t context_tag, 4950 uint32_t pname) 4951 { 4952 static const xcb_protocol_request_t xcb_req = { 4953 .count = 2, 4954 .ext = &xcb_glx_id, 4955 .opcode = XCB_GLX_GET_INTEGERV, 4956 .isvoid = 0 4957 }; 4958 4959 struct iovec xcb_parts[4]; 4960 xcb_glx_get_integerv_cookie_t xcb_ret; 4961 xcb_glx_get_integerv_request_t xcb_out; 4962 4963 xcb_out.context_tag = context_tag; 4964 xcb_out.pname = pname; 4965 4966 xcb_parts[2].iov_base = (char *) &xcb_out; 4967 xcb_parts[2].iov_len = sizeof(xcb_out); 4968 xcb_parts[3].iov_base = 0; 4969 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4970 4971 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4972 return xcb_ret; 4973 } 4974 4975 xcb_glx_get_integerv_cookie_t 4976 xcb_glx_get_integerv_unchecked (xcb_connection_t *c, 4977 xcb_glx_context_tag_t context_tag, 4978 uint32_t pname) 4979 { 4980 static const xcb_protocol_request_t xcb_req = { 4981 .count = 2, 4982 .ext = &xcb_glx_id, 4983 .opcode = XCB_GLX_GET_INTEGERV, 4984 .isvoid = 0 4985 }; 4986 4987 struct iovec xcb_parts[4]; 4988 xcb_glx_get_integerv_cookie_t xcb_ret; 4989 xcb_glx_get_integerv_request_t xcb_out; 4990 4991 xcb_out.context_tag = context_tag; 4992 xcb_out.pname = pname; 4993 4994 xcb_parts[2].iov_base = (char *) &xcb_out; 4995 xcb_parts[2].iov_len = sizeof(xcb_out); 4996 xcb_parts[3].iov_base = 0; 4997 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4998 4999 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5000 return xcb_ret; 5001 } 5002 5003 int32_t * 5004 xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R) 5005 { 5006 return (int32_t *) (R + 1); 5007 } 5008 5009 int 5010 xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R) 5011 { 5012 return R->n; 5013 } 5014 5015 xcb_generic_iterator_t 5016 xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R) 5017 { 5018 xcb_generic_iterator_t i; 5019 i.data = ((int32_t *) (R + 1)) + (R->n); 5020 i.rem = 0; 5021 i.index = (char *) i.data - (char *) R; 5022 return i; 5023 } 5024 5025 xcb_glx_get_integerv_reply_t * 5026 xcb_glx_get_integerv_reply (xcb_connection_t *c, 5027 xcb_glx_get_integerv_cookie_t cookie /**< */, 5028 xcb_generic_error_t **e) 5029 { 5030 return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5031 } 5032 5033 int 5034 xcb_glx_get_lightfv_sizeof (const void *_buffer) 5035 { 5036 char *xcb_tmp = (char *)_buffer; 5037 const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer; 5038 unsigned int xcb_buffer_len = 0; 5039 unsigned int xcb_block_len = 0; 5040 unsigned int xcb_pad = 0; 5041 unsigned int xcb_align_to = 0; 5042 5043 5044 xcb_block_len += sizeof(xcb_glx_get_lightfv_reply_t); 5045 xcb_tmp += xcb_block_len; 5046 xcb_buffer_len += xcb_block_len; 5047 xcb_block_len = 0; 5048 /* data */ 5049 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5050 xcb_tmp += xcb_block_len; 5051 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5052 /* insert padding */ 5053 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5054 xcb_buffer_len += xcb_block_len + xcb_pad; 5055 if (0 != xcb_pad) { 5056 xcb_tmp += xcb_pad; 5057 xcb_pad = 0; 5058 } 5059 xcb_block_len = 0; 5060 5061 return xcb_buffer_len; 5062 } 5063 5064 xcb_glx_get_lightfv_cookie_t 5065 xcb_glx_get_lightfv (xcb_connection_t *c, 5066 xcb_glx_context_tag_t context_tag, 5067 uint32_t light, 5068 uint32_t pname) 5069 { 5070 static const xcb_protocol_request_t xcb_req = { 5071 .count = 2, 5072 .ext = &xcb_glx_id, 5073 .opcode = XCB_GLX_GET_LIGHTFV, 5074 .isvoid = 0 5075 }; 5076 5077 struct iovec xcb_parts[4]; 5078 xcb_glx_get_lightfv_cookie_t xcb_ret; 5079 xcb_glx_get_lightfv_request_t xcb_out; 5080 5081 xcb_out.context_tag = context_tag; 5082 xcb_out.light = light; 5083 xcb_out.pname = pname; 5084 5085 xcb_parts[2].iov_base = (char *) &xcb_out; 5086 xcb_parts[2].iov_len = sizeof(xcb_out); 5087 xcb_parts[3].iov_base = 0; 5088 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5089 5090 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5091 return xcb_ret; 5092 } 5093 5094 xcb_glx_get_lightfv_cookie_t 5095 xcb_glx_get_lightfv_unchecked (xcb_connection_t *c, 5096 xcb_glx_context_tag_t context_tag, 5097 uint32_t light, 5098 uint32_t pname) 5099 { 5100 static const xcb_protocol_request_t xcb_req = { 5101 .count = 2, 5102 .ext = &xcb_glx_id, 5103 .opcode = XCB_GLX_GET_LIGHTFV, 5104 .isvoid = 0 5105 }; 5106 5107 struct iovec xcb_parts[4]; 5108 xcb_glx_get_lightfv_cookie_t xcb_ret; 5109 xcb_glx_get_lightfv_request_t xcb_out; 5110 5111 xcb_out.context_tag = context_tag; 5112 xcb_out.light = light; 5113 xcb_out.pname = pname; 5114 5115 xcb_parts[2].iov_base = (char *) &xcb_out; 5116 xcb_parts[2].iov_len = sizeof(xcb_out); 5117 xcb_parts[3].iov_base = 0; 5118 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5119 5120 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5121 return xcb_ret; 5122 } 5123 5124 xcb_glx_float32_t * 5125 xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R) 5126 { 5127 return (xcb_glx_float32_t *) (R + 1); 5128 } 5129 5130 int 5131 xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R) 5132 { 5133 return R->n; 5134 } 5135 5136 xcb_generic_iterator_t 5137 xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R) 5138 { 5139 xcb_generic_iterator_t i; 5140 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5141 i.rem = 0; 5142 i.index = (char *) i.data - (char *) R; 5143 return i; 5144 } 5145 5146 xcb_glx_get_lightfv_reply_t * 5147 xcb_glx_get_lightfv_reply (xcb_connection_t *c, 5148 xcb_glx_get_lightfv_cookie_t cookie /**< */, 5149 xcb_generic_error_t **e) 5150 { 5151 return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5152 } 5153 5154 int 5155 xcb_glx_get_lightiv_sizeof (const void *_buffer) 5156 { 5157 char *xcb_tmp = (char *)_buffer; 5158 const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer; 5159 unsigned int xcb_buffer_len = 0; 5160 unsigned int xcb_block_len = 0; 5161 unsigned int xcb_pad = 0; 5162 unsigned int xcb_align_to = 0; 5163 5164 5165 xcb_block_len += sizeof(xcb_glx_get_lightiv_reply_t); 5166 xcb_tmp += xcb_block_len; 5167 xcb_buffer_len += xcb_block_len; 5168 xcb_block_len = 0; 5169 /* data */ 5170 xcb_block_len += _aux->n * sizeof(int32_t); 5171 xcb_tmp += xcb_block_len; 5172 xcb_align_to = ALIGNOF(int32_t); 5173 /* insert padding */ 5174 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5175 xcb_buffer_len += xcb_block_len + xcb_pad; 5176 if (0 != xcb_pad) { 5177 xcb_tmp += xcb_pad; 5178 xcb_pad = 0; 5179 } 5180 xcb_block_len = 0; 5181 5182 return xcb_buffer_len; 5183 } 5184 5185 xcb_glx_get_lightiv_cookie_t 5186 xcb_glx_get_lightiv (xcb_connection_t *c, 5187 xcb_glx_context_tag_t context_tag, 5188 uint32_t light, 5189 uint32_t pname) 5190 { 5191 static const xcb_protocol_request_t xcb_req = { 5192 .count = 2, 5193 .ext = &xcb_glx_id, 5194 .opcode = XCB_GLX_GET_LIGHTIV, 5195 .isvoid = 0 5196 }; 5197 5198 struct iovec xcb_parts[4]; 5199 xcb_glx_get_lightiv_cookie_t xcb_ret; 5200 xcb_glx_get_lightiv_request_t xcb_out; 5201 5202 xcb_out.context_tag = context_tag; 5203 xcb_out.light = light; 5204 xcb_out.pname = pname; 5205 5206 xcb_parts[2].iov_base = (char *) &xcb_out; 5207 xcb_parts[2].iov_len = sizeof(xcb_out); 5208 xcb_parts[3].iov_base = 0; 5209 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5210 5211 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5212 return xcb_ret; 5213 } 5214 5215 xcb_glx_get_lightiv_cookie_t 5216 xcb_glx_get_lightiv_unchecked (xcb_connection_t *c, 5217 xcb_glx_context_tag_t context_tag, 5218 uint32_t light, 5219 uint32_t pname) 5220 { 5221 static const xcb_protocol_request_t xcb_req = { 5222 .count = 2, 5223 .ext = &xcb_glx_id, 5224 .opcode = XCB_GLX_GET_LIGHTIV, 5225 .isvoid = 0 5226 }; 5227 5228 struct iovec xcb_parts[4]; 5229 xcb_glx_get_lightiv_cookie_t xcb_ret; 5230 xcb_glx_get_lightiv_request_t xcb_out; 5231 5232 xcb_out.context_tag = context_tag; 5233 xcb_out.light = light; 5234 xcb_out.pname = pname; 5235 5236 xcb_parts[2].iov_base = (char *) &xcb_out; 5237 xcb_parts[2].iov_len = sizeof(xcb_out); 5238 xcb_parts[3].iov_base = 0; 5239 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5240 5241 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5242 return xcb_ret; 5243 } 5244 5245 int32_t * 5246 xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R) 5247 { 5248 return (int32_t *) (R + 1); 5249 } 5250 5251 int 5252 xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R) 5253 { 5254 return R->n; 5255 } 5256 5257 xcb_generic_iterator_t 5258 xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R) 5259 { 5260 xcb_generic_iterator_t i; 5261 i.data = ((int32_t *) (R + 1)) + (R->n); 5262 i.rem = 0; 5263 i.index = (char *) i.data - (char *) R; 5264 return i; 5265 } 5266 5267 xcb_glx_get_lightiv_reply_t * 5268 xcb_glx_get_lightiv_reply (xcb_connection_t *c, 5269 xcb_glx_get_lightiv_cookie_t cookie /**< */, 5270 xcb_generic_error_t **e) 5271 { 5272 return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5273 } 5274 5275 int 5276 xcb_glx_get_mapdv_sizeof (const void *_buffer) 5277 { 5278 char *xcb_tmp = (char *)_buffer; 5279 const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer; 5280 unsigned int xcb_buffer_len = 0; 5281 unsigned int xcb_block_len = 0; 5282 unsigned int xcb_pad = 0; 5283 unsigned int xcb_align_to = 0; 5284 5285 5286 xcb_block_len += sizeof(xcb_glx_get_mapdv_reply_t); 5287 xcb_tmp += xcb_block_len; 5288 xcb_buffer_len += xcb_block_len; 5289 xcb_block_len = 0; 5290 /* data */ 5291 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 5292 xcb_tmp += xcb_block_len; 5293 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 5294 /* insert padding */ 5295 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5296 xcb_buffer_len += xcb_block_len + xcb_pad; 5297 if (0 != xcb_pad) { 5298 xcb_tmp += xcb_pad; 5299 xcb_pad = 0; 5300 } 5301 xcb_block_len = 0; 5302 5303 return xcb_buffer_len; 5304 } 5305 5306 xcb_glx_get_mapdv_cookie_t 5307 xcb_glx_get_mapdv (xcb_connection_t *c, 5308 xcb_glx_context_tag_t context_tag, 5309 uint32_t target, 5310 uint32_t query) 5311 { 5312 static const xcb_protocol_request_t xcb_req = { 5313 .count = 2, 5314 .ext = &xcb_glx_id, 5315 .opcode = XCB_GLX_GET_MAPDV, 5316 .isvoid = 0 5317 }; 5318 5319 struct iovec xcb_parts[4]; 5320 xcb_glx_get_mapdv_cookie_t xcb_ret; 5321 xcb_glx_get_mapdv_request_t xcb_out; 5322 5323 xcb_out.context_tag = context_tag; 5324 xcb_out.target = target; 5325 xcb_out.query = query; 5326 5327 xcb_parts[2].iov_base = (char *) &xcb_out; 5328 xcb_parts[2].iov_len = sizeof(xcb_out); 5329 xcb_parts[3].iov_base = 0; 5330 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5331 5332 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5333 return xcb_ret; 5334 } 5335 5336 xcb_glx_get_mapdv_cookie_t 5337 xcb_glx_get_mapdv_unchecked (xcb_connection_t *c, 5338 xcb_glx_context_tag_t context_tag, 5339 uint32_t target, 5340 uint32_t query) 5341 { 5342 static const xcb_protocol_request_t xcb_req = { 5343 .count = 2, 5344 .ext = &xcb_glx_id, 5345 .opcode = XCB_GLX_GET_MAPDV, 5346 .isvoid = 0 5347 }; 5348 5349 struct iovec xcb_parts[4]; 5350 xcb_glx_get_mapdv_cookie_t xcb_ret; 5351 xcb_glx_get_mapdv_request_t xcb_out; 5352 5353 xcb_out.context_tag = context_tag; 5354 xcb_out.target = target; 5355 xcb_out.query = query; 5356 5357 xcb_parts[2].iov_base = (char *) &xcb_out; 5358 xcb_parts[2].iov_len = sizeof(xcb_out); 5359 xcb_parts[3].iov_base = 0; 5360 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5361 5362 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5363 return xcb_ret; 5364 } 5365 5366 xcb_glx_float64_t * 5367 xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R) 5368 { 5369 return (xcb_glx_float64_t *) (R + 1); 5370 } 5371 5372 int 5373 xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R) 5374 { 5375 return R->n; 5376 } 5377 5378 xcb_generic_iterator_t 5379 xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R) 5380 { 5381 xcb_generic_iterator_t i; 5382 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 5383 i.rem = 0; 5384 i.index = (char *) i.data - (char *) R; 5385 return i; 5386 } 5387 5388 xcb_glx_get_mapdv_reply_t * 5389 xcb_glx_get_mapdv_reply (xcb_connection_t *c, 5390 xcb_glx_get_mapdv_cookie_t cookie /**< */, 5391 xcb_generic_error_t **e) 5392 { 5393 return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5394 } 5395 5396 int 5397 xcb_glx_get_mapfv_sizeof (const void *_buffer) 5398 { 5399 char *xcb_tmp = (char *)_buffer; 5400 const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer; 5401 unsigned int xcb_buffer_len = 0; 5402 unsigned int xcb_block_len = 0; 5403 unsigned int xcb_pad = 0; 5404 unsigned int xcb_align_to = 0; 5405 5406 5407 xcb_block_len += sizeof(xcb_glx_get_mapfv_reply_t); 5408 xcb_tmp += xcb_block_len; 5409 xcb_buffer_len += xcb_block_len; 5410 xcb_block_len = 0; 5411 /* data */ 5412 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5413 xcb_tmp += xcb_block_len; 5414 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5415 /* insert padding */ 5416 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5417 xcb_buffer_len += xcb_block_len + xcb_pad; 5418 if (0 != xcb_pad) { 5419 xcb_tmp += xcb_pad; 5420 xcb_pad = 0; 5421 } 5422 xcb_block_len = 0; 5423 5424 return xcb_buffer_len; 5425 } 5426 5427 xcb_glx_get_mapfv_cookie_t 5428 xcb_glx_get_mapfv (xcb_connection_t *c, 5429 xcb_glx_context_tag_t context_tag, 5430 uint32_t target, 5431 uint32_t query) 5432 { 5433 static const xcb_protocol_request_t xcb_req = { 5434 .count = 2, 5435 .ext = &xcb_glx_id, 5436 .opcode = XCB_GLX_GET_MAPFV, 5437 .isvoid = 0 5438 }; 5439 5440 struct iovec xcb_parts[4]; 5441 xcb_glx_get_mapfv_cookie_t xcb_ret; 5442 xcb_glx_get_mapfv_request_t xcb_out; 5443 5444 xcb_out.context_tag = context_tag; 5445 xcb_out.target = target; 5446 xcb_out.query = query; 5447 5448 xcb_parts[2].iov_base = (char *) &xcb_out; 5449 xcb_parts[2].iov_len = sizeof(xcb_out); 5450 xcb_parts[3].iov_base = 0; 5451 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5452 5453 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5454 return xcb_ret; 5455 } 5456 5457 xcb_glx_get_mapfv_cookie_t 5458 xcb_glx_get_mapfv_unchecked (xcb_connection_t *c, 5459 xcb_glx_context_tag_t context_tag, 5460 uint32_t target, 5461 uint32_t query) 5462 { 5463 static const xcb_protocol_request_t xcb_req = { 5464 .count = 2, 5465 .ext = &xcb_glx_id, 5466 .opcode = XCB_GLX_GET_MAPFV, 5467 .isvoid = 0 5468 }; 5469 5470 struct iovec xcb_parts[4]; 5471 xcb_glx_get_mapfv_cookie_t xcb_ret; 5472 xcb_glx_get_mapfv_request_t xcb_out; 5473 5474 xcb_out.context_tag = context_tag; 5475 xcb_out.target = target; 5476 xcb_out.query = query; 5477 5478 xcb_parts[2].iov_base = (char *) &xcb_out; 5479 xcb_parts[2].iov_len = sizeof(xcb_out); 5480 xcb_parts[3].iov_base = 0; 5481 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5482 5483 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5484 return xcb_ret; 5485 } 5486 5487 xcb_glx_float32_t * 5488 xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R) 5489 { 5490 return (xcb_glx_float32_t *) (R + 1); 5491 } 5492 5493 int 5494 xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R) 5495 { 5496 return R->n; 5497 } 5498 5499 xcb_generic_iterator_t 5500 xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R) 5501 { 5502 xcb_generic_iterator_t i; 5503 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5504 i.rem = 0; 5505 i.index = (char *) i.data - (char *) R; 5506 return i; 5507 } 5508 5509 xcb_glx_get_mapfv_reply_t * 5510 xcb_glx_get_mapfv_reply (xcb_connection_t *c, 5511 xcb_glx_get_mapfv_cookie_t cookie /**< */, 5512 xcb_generic_error_t **e) 5513 { 5514 return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5515 } 5516 5517 int 5518 xcb_glx_get_mapiv_sizeof (const void *_buffer) 5519 { 5520 char *xcb_tmp = (char *)_buffer; 5521 const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer; 5522 unsigned int xcb_buffer_len = 0; 5523 unsigned int xcb_block_len = 0; 5524 unsigned int xcb_pad = 0; 5525 unsigned int xcb_align_to = 0; 5526 5527 5528 xcb_block_len += sizeof(xcb_glx_get_mapiv_reply_t); 5529 xcb_tmp += xcb_block_len; 5530 xcb_buffer_len += xcb_block_len; 5531 xcb_block_len = 0; 5532 /* data */ 5533 xcb_block_len += _aux->n * sizeof(int32_t); 5534 xcb_tmp += xcb_block_len; 5535 xcb_align_to = ALIGNOF(int32_t); 5536 /* insert padding */ 5537 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5538 xcb_buffer_len += xcb_block_len + xcb_pad; 5539 if (0 != xcb_pad) { 5540 xcb_tmp += xcb_pad; 5541 xcb_pad = 0; 5542 } 5543 xcb_block_len = 0; 5544 5545 return xcb_buffer_len; 5546 } 5547 5548 xcb_glx_get_mapiv_cookie_t 5549 xcb_glx_get_mapiv (xcb_connection_t *c, 5550 xcb_glx_context_tag_t context_tag, 5551 uint32_t target, 5552 uint32_t query) 5553 { 5554 static const xcb_protocol_request_t xcb_req = { 5555 .count = 2, 5556 .ext = &xcb_glx_id, 5557 .opcode = XCB_GLX_GET_MAPIV, 5558 .isvoid = 0 5559 }; 5560 5561 struct iovec xcb_parts[4]; 5562 xcb_glx_get_mapiv_cookie_t xcb_ret; 5563 xcb_glx_get_mapiv_request_t xcb_out; 5564 5565 xcb_out.context_tag = context_tag; 5566 xcb_out.target = target; 5567 xcb_out.query = query; 5568 5569 xcb_parts[2].iov_base = (char *) &xcb_out; 5570 xcb_parts[2].iov_len = sizeof(xcb_out); 5571 xcb_parts[3].iov_base = 0; 5572 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5573 5574 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5575 return xcb_ret; 5576 } 5577 5578 xcb_glx_get_mapiv_cookie_t 5579 xcb_glx_get_mapiv_unchecked (xcb_connection_t *c, 5580 xcb_glx_context_tag_t context_tag, 5581 uint32_t target, 5582 uint32_t query) 5583 { 5584 static const xcb_protocol_request_t xcb_req = { 5585 .count = 2, 5586 .ext = &xcb_glx_id, 5587 .opcode = XCB_GLX_GET_MAPIV, 5588 .isvoid = 0 5589 }; 5590 5591 struct iovec xcb_parts[4]; 5592 xcb_glx_get_mapiv_cookie_t xcb_ret; 5593 xcb_glx_get_mapiv_request_t xcb_out; 5594 5595 xcb_out.context_tag = context_tag; 5596 xcb_out.target = target; 5597 xcb_out.query = query; 5598 5599 xcb_parts[2].iov_base = (char *) &xcb_out; 5600 xcb_parts[2].iov_len = sizeof(xcb_out); 5601 xcb_parts[3].iov_base = 0; 5602 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5603 5604 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5605 return xcb_ret; 5606 } 5607 5608 int32_t * 5609 xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R) 5610 { 5611 return (int32_t *) (R + 1); 5612 } 5613 5614 int 5615 xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R) 5616 { 5617 return R->n; 5618 } 5619 5620 xcb_generic_iterator_t 5621 xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R) 5622 { 5623 xcb_generic_iterator_t i; 5624 i.data = ((int32_t *) (R + 1)) + (R->n); 5625 i.rem = 0; 5626 i.index = (char *) i.data - (char *) R; 5627 return i; 5628 } 5629 5630 xcb_glx_get_mapiv_reply_t * 5631 xcb_glx_get_mapiv_reply (xcb_connection_t *c, 5632 xcb_glx_get_mapiv_cookie_t cookie /**< */, 5633 xcb_generic_error_t **e) 5634 { 5635 return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5636 } 5637 5638 int 5639 xcb_glx_get_materialfv_sizeof (const void *_buffer) 5640 { 5641 char *xcb_tmp = (char *)_buffer; 5642 const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer; 5643 unsigned int xcb_buffer_len = 0; 5644 unsigned int xcb_block_len = 0; 5645 unsigned int xcb_pad = 0; 5646 unsigned int xcb_align_to = 0; 5647 5648 5649 xcb_block_len += sizeof(xcb_glx_get_materialfv_reply_t); 5650 xcb_tmp += xcb_block_len; 5651 xcb_buffer_len += xcb_block_len; 5652 xcb_block_len = 0; 5653 /* data */ 5654 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5655 xcb_tmp += xcb_block_len; 5656 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5657 /* insert padding */ 5658 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5659 xcb_buffer_len += xcb_block_len + xcb_pad; 5660 if (0 != xcb_pad) { 5661 xcb_tmp += xcb_pad; 5662 xcb_pad = 0; 5663 } 5664 xcb_block_len = 0; 5665 5666 return xcb_buffer_len; 5667 } 5668 5669 xcb_glx_get_materialfv_cookie_t 5670 xcb_glx_get_materialfv (xcb_connection_t *c, 5671 xcb_glx_context_tag_t context_tag, 5672 uint32_t face, 5673 uint32_t pname) 5674 { 5675 static const xcb_protocol_request_t xcb_req = { 5676 .count = 2, 5677 .ext = &xcb_glx_id, 5678 .opcode = XCB_GLX_GET_MATERIALFV, 5679 .isvoid = 0 5680 }; 5681 5682 struct iovec xcb_parts[4]; 5683 xcb_glx_get_materialfv_cookie_t xcb_ret; 5684 xcb_glx_get_materialfv_request_t xcb_out; 5685 5686 xcb_out.context_tag = context_tag; 5687 xcb_out.face = face; 5688 xcb_out.pname = pname; 5689 5690 xcb_parts[2].iov_base = (char *) &xcb_out; 5691 xcb_parts[2].iov_len = sizeof(xcb_out); 5692 xcb_parts[3].iov_base = 0; 5693 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5694 5695 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5696 return xcb_ret; 5697 } 5698 5699 xcb_glx_get_materialfv_cookie_t 5700 xcb_glx_get_materialfv_unchecked (xcb_connection_t *c, 5701 xcb_glx_context_tag_t context_tag, 5702 uint32_t face, 5703 uint32_t pname) 5704 { 5705 static const xcb_protocol_request_t xcb_req = { 5706 .count = 2, 5707 .ext = &xcb_glx_id, 5708 .opcode = XCB_GLX_GET_MATERIALFV, 5709 .isvoid = 0 5710 }; 5711 5712 struct iovec xcb_parts[4]; 5713 xcb_glx_get_materialfv_cookie_t xcb_ret; 5714 xcb_glx_get_materialfv_request_t xcb_out; 5715 5716 xcb_out.context_tag = context_tag; 5717 xcb_out.face = face; 5718 xcb_out.pname = pname; 5719 5720 xcb_parts[2].iov_base = (char *) &xcb_out; 5721 xcb_parts[2].iov_len = sizeof(xcb_out); 5722 xcb_parts[3].iov_base = 0; 5723 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5724 5725 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5726 return xcb_ret; 5727 } 5728 5729 xcb_glx_float32_t * 5730 xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R) 5731 { 5732 return (xcb_glx_float32_t *) (R + 1); 5733 } 5734 5735 int 5736 xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R) 5737 { 5738 return R->n; 5739 } 5740 5741 xcb_generic_iterator_t 5742 xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R) 5743 { 5744 xcb_generic_iterator_t i; 5745 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5746 i.rem = 0; 5747 i.index = (char *) i.data - (char *) R; 5748 return i; 5749 } 5750 5751 xcb_glx_get_materialfv_reply_t * 5752 xcb_glx_get_materialfv_reply (xcb_connection_t *c, 5753 xcb_glx_get_materialfv_cookie_t cookie /**< */, 5754 xcb_generic_error_t **e) 5755 { 5756 return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5757 } 5758 5759 int 5760 xcb_glx_get_materialiv_sizeof (const void *_buffer) 5761 { 5762 char *xcb_tmp = (char *)_buffer; 5763 const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer; 5764 unsigned int xcb_buffer_len = 0; 5765 unsigned int xcb_block_len = 0; 5766 unsigned int xcb_pad = 0; 5767 unsigned int xcb_align_to = 0; 5768 5769 5770 xcb_block_len += sizeof(xcb_glx_get_materialiv_reply_t); 5771 xcb_tmp += xcb_block_len; 5772 xcb_buffer_len += xcb_block_len; 5773 xcb_block_len = 0; 5774 /* data */ 5775 xcb_block_len += _aux->n * sizeof(int32_t); 5776 xcb_tmp += xcb_block_len; 5777 xcb_align_to = ALIGNOF(int32_t); 5778 /* insert padding */ 5779 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5780 xcb_buffer_len += xcb_block_len + xcb_pad; 5781 if (0 != xcb_pad) { 5782 xcb_tmp += xcb_pad; 5783 xcb_pad = 0; 5784 } 5785 xcb_block_len = 0; 5786 5787 return xcb_buffer_len; 5788 } 5789 5790 xcb_glx_get_materialiv_cookie_t 5791 xcb_glx_get_materialiv (xcb_connection_t *c, 5792 xcb_glx_context_tag_t context_tag, 5793 uint32_t face, 5794 uint32_t pname) 5795 { 5796 static const xcb_protocol_request_t xcb_req = { 5797 .count = 2, 5798 .ext = &xcb_glx_id, 5799 .opcode = XCB_GLX_GET_MATERIALIV, 5800 .isvoid = 0 5801 }; 5802 5803 struct iovec xcb_parts[4]; 5804 xcb_glx_get_materialiv_cookie_t xcb_ret; 5805 xcb_glx_get_materialiv_request_t xcb_out; 5806 5807 xcb_out.context_tag = context_tag; 5808 xcb_out.face = face; 5809 xcb_out.pname = pname; 5810 5811 xcb_parts[2].iov_base = (char *) &xcb_out; 5812 xcb_parts[2].iov_len = sizeof(xcb_out); 5813 xcb_parts[3].iov_base = 0; 5814 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5815 5816 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5817 return xcb_ret; 5818 } 5819 5820 xcb_glx_get_materialiv_cookie_t 5821 xcb_glx_get_materialiv_unchecked (xcb_connection_t *c, 5822 xcb_glx_context_tag_t context_tag, 5823 uint32_t face, 5824 uint32_t pname) 5825 { 5826 static const xcb_protocol_request_t xcb_req = { 5827 .count = 2, 5828 .ext = &xcb_glx_id, 5829 .opcode = XCB_GLX_GET_MATERIALIV, 5830 .isvoid = 0 5831 }; 5832 5833 struct iovec xcb_parts[4]; 5834 xcb_glx_get_materialiv_cookie_t xcb_ret; 5835 xcb_glx_get_materialiv_request_t xcb_out; 5836 5837 xcb_out.context_tag = context_tag; 5838 xcb_out.face = face; 5839 xcb_out.pname = pname; 5840 5841 xcb_parts[2].iov_base = (char *) &xcb_out; 5842 xcb_parts[2].iov_len = sizeof(xcb_out); 5843 xcb_parts[3].iov_base = 0; 5844 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5845 5846 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5847 return xcb_ret; 5848 } 5849 5850 int32_t * 5851 xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R) 5852 { 5853 return (int32_t *) (R + 1); 5854 } 5855 5856 int 5857 xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R) 5858 { 5859 return R->n; 5860 } 5861 5862 xcb_generic_iterator_t 5863 xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R) 5864 { 5865 xcb_generic_iterator_t i; 5866 i.data = ((int32_t *) (R + 1)) + (R->n); 5867 i.rem = 0; 5868 i.index = (char *) i.data - (char *) R; 5869 return i; 5870 } 5871 5872 xcb_glx_get_materialiv_reply_t * 5873 xcb_glx_get_materialiv_reply (xcb_connection_t *c, 5874 xcb_glx_get_materialiv_cookie_t cookie /**< */, 5875 xcb_generic_error_t **e) 5876 { 5877 return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5878 } 5879 5880 int 5881 xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer) 5882 { 5883 char *xcb_tmp = (char *)_buffer; 5884 const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer; 5885 unsigned int xcb_buffer_len = 0; 5886 unsigned int xcb_block_len = 0; 5887 unsigned int xcb_pad = 0; 5888 unsigned int xcb_align_to = 0; 5889 5890 5891 xcb_block_len += sizeof(xcb_glx_get_pixel_mapfv_reply_t); 5892 xcb_tmp += xcb_block_len; 5893 xcb_buffer_len += xcb_block_len; 5894 xcb_block_len = 0; 5895 /* data */ 5896 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 5897 xcb_tmp += xcb_block_len; 5898 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 5899 /* insert padding */ 5900 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5901 xcb_buffer_len += xcb_block_len + xcb_pad; 5902 if (0 != xcb_pad) { 5903 xcb_tmp += xcb_pad; 5904 xcb_pad = 0; 5905 } 5906 xcb_block_len = 0; 5907 5908 return xcb_buffer_len; 5909 } 5910 5911 xcb_glx_get_pixel_mapfv_cookie_t 5912 xcb_glx_get_pixel_mapfv (xcb_connection_t *c, 5913 xcb_glx_context_tag_t context_tag, 5914 uint32_t map) 5915 { 5916 static const xcb_protocol_request_t xcb_req = { 5917 .count = 2, 5918 .ext = &xcb_glx_id, 5919 .opcode = XCB_GLX_GET_PIXEL_MAPFV, 5920 .isvoid = 0 5921 }; 5922 5923 struct iovec xcb_parts[4]; 5924 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 5925 xcb_glx_get_pixel_mapfv_request_t xcb_out; 5926 5927 xcb_out.context_tag = context_tag; 5928 xcb_out.map = map; 5929 5930 xcb_parts[2].iov_base = (char *) &xcb_out; 5931 xcb_parts[2].iov_len = sizeof(xcb_out); 5932 xcb_parts[3].iov_base = 0; 5933 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5934 5935 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5936 return xcb_ret; 5937 } 5938 5939 xcb_glx_get_pixel_mapfv_cookie_t 5940 xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c, 5941 xcb_glx_context_tag_t context_tag, 5942 uint32_t map) 5943 { 5944 static const xcb_protocol_request_t xcb_req = { 5945 .count = 2, 5946 .ext = &xcb_glx_id, 5947 .opcode = XCB_GLX_GET_PIXEL_MAPFV, 5948 .isvoid = 0 5949 }; 5950 5951 struct iovec xcb_parts[4]; 5952 xcb_glx_get_pixel_mapfv_cookie_t xcb_ret; 5953 xcb_glx_get_pixel_mapfv_request_t xcb_out; 5954 5955 xcb_out.context_tag = context_tag; 5956 xcb_out.map = map; 5957 5958 xcb_parts[2].iov_base = (char *) &xcb_out; 5959 xcb_parts[2].iov_len = sizeof(xcb_out); 5960 xcb_parts[3].iov_base = 0; 5961 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5962 5963 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5964 return xcb_ret; 5965 } 5966 5967 xcb_glx_float32_t * 5968 xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R) 5969 { 5970 return (xcb_glx_float32_t *) (R + 1); 5971 } 5972 5973 int 5974 xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R) 5975 { 5976 return R->n; 5977 } 5978 5979 xcb_generic_iterator_t 5980 xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R) 5981 { 5982 xcb_generic_iterator_t i; 5983 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 5984 i.rem = 0; 5985 i.index = (char *) i.data - (char *) R; 5986 return i; 5987 } 5988 5989 xcb_glx_get_pixel_mapfv_reply_t * 5990 xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c, 5991 xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, 5992 xcb_generic_error_t **e) 5993 { 5994 return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5995 } 5996 5997 int 5998 xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer) 5999 { 6000 char *xcb_tmp = (char *)_buffer; 6001 const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer; 6002 unsigned int xcb_buffer_len = 0; 6003 unsigned int xcb_block_len = 0; 6004 unsigned int xcb_pad = 0; 6005 unsigned int xcb_align_to = 0; 6006 6007 6008 xcb_block_len += sizeof(xcb_glx_get_pixel_mapuiv_reply_t); 6009 xcb_tmp += xcb_block_len; 6010 xcb_buffer_len += xcb_block_len; 6011 xcb_block_len = 0; 6012 /* data */ 6013 xcb_block_len += _aux->n * sizeof(uint32_t); 6014 xcb_tmp += xcb_block_len; 6015 xcb_align_to = ALIGNOF(uint32_t); 6016 /* insert padding */ 6017 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6018 xcb_buffer_len += xcb_block_len + xcb_pad; 6019 if (0 != xcb_pad) { 6020 xcb_tmp += xcb_pad; 6021 xcb_pad = 0; 6022 } 6023 xcb_block_len = 0; 6024 6025 return xcb_buffer_len; 6026 } 6027 6028 xcb_glx_get_pixel_mapuiv_cookie_t 6029 xcb_glx_get_pixel_mapuiv (xcb_connection_t *c, 6030 xcb_glx_context_tag_t context_tag, 6031 uint32_t map) 6032 { 6033 static const xcb_protocol_request_t xcb_req = { 6034 .count = 2, 6035 .ext = &xcb_glx_id, 6036 .opcode = XCB_GLX_GET_PIXEL_MAPUIV, 6037 .isvoid = 0 6038 }; 6039 6040 struct iovec xcb_parts[4]; 6041 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 6042 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 6043 6044 xcb_out.context_tag = context_tag; 6045 xcb_out.map = map; 6046 6047 xcb_parts[2].iov_base = (char *) &xcb_out; 6048 xcb_parts[2].iov_len = sizeof(xcb_out); 6049 xcb_parts[3].iov_base = 0; 6050 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6051 6052 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6053 return xcb_ret; 6054 } 6055 6056 xcb_glx_get_pixel_mapuiv_cookie_t 6057 xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c, 6058 xcb_glx_context_tag_t context_tag, 6059 uint32_t map) 6060 { 6061 static const xcb_protocol_request_t xcb_req = { 6062 .count = 2, 6063 .ext = &xcb_glx_id, 6064 .opcode = XCB_GLX_GET_PIXEL_MAPUIV, 6065 .isvoid = 0 6066 }; 6067 6068 struct iovec xcb_parts[4]; 6069 xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret; 6070 xcb_glx_get_pixel_mapuiv_request_t xcb_out; 6071 6072 xcb_out.context_tag = context_tag; 6073 xcb_out.map = map; 6074 6075 xcb_parts[2].iov_base = (char *) &xcb_out; 6076 xcb_parts[2].iov_len = sizeof(xcb_out); 6077 xcb_parts[3].iov_base = 0; 6078 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6079 6080 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6081 return xcb_ret; 6082 } 6083 6084 uint32_t * 6085 xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6086 { 6087 return (uint32_t *) (R + 1); 6088 } 6089 6090 int 6091 xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6092 { 6093 return R->n; 6094 } 6095 6096 xcb_generic_iterator_t 6097 xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R) 6098 { 6099 xcb_generic_iterator_t i; 6100 i.data = ((uint32_t *) (R + 1)) + (R->n); 6101 i.rem = 0; 6102 i.index = (char *) i.data - (char *) R; 6103 return i; 6104 } 6105 6106 xcb_glx_get_pixel_mapuiv_reply_t * 6107 xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c, 6108 xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, 6109 xcb_generic_error_t **e) 6110 { 6111 return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6112 } 6113 6114 int 6115 xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer) 6116 { 6117 char *xcb_tmp = (char *)_buffer; 6118 const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer; 6119 unsigned int xcb_buffer_len = 0; 6120 unsigned int xcb_block_len = 0; 6121 unsigned int xcb_pad = 0; 6122 unsigned int xcb_align_to = 0; 6123 6124 6125 xcb_block_len += sizeof(xcb_glx_get_pixel_mapusv_reply_t); 6126 xcb_tmp += xcb_block_len; 6127 xcb_buffer_len += xcb_block_len; 6128 xcb_block_len = 0; 6129 /* data */ 6130 xcb_block_len += _aux->n * sizeof(uint16_t); 6131 xcb_tmp += xcb_block_len; 6132 xcb_align_to = ALIGNOF(uint16_t); 6133 /* insert padding */ 6134 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6135 xcb_buffer_len += xcb_block_len + xcb_pad; 6136 if (0 != xcb_pad) { 6137 xcb_tmp += xcb_pad; 6138 xcb_pad = 0; 6139 } 6140 xcb_block_len = 0; 6141 6142 return xcb_buffer_len; 6143 } 6144 6145 xcb_glx_get_pixel_mapusv_cookie_t 6146 xcb_glx_get_pixel_mapusv (xcb_connection_t *c, 6147 xcb_glx_context_tag_t context_tag, 6148 uint32_t map) 6149 { 6150 static const xcb_protocol_request_t xcb_req = { 6151 .count = 2, 6152 .ext = &xcb_glx_id, 6153 .opcode = XCB_GLX_GET_PIXEL_MAPUSV, 6154 .isvoid = 0 6155 }; 6156 6157 struct iovec xcb_parts[4]; 6158 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 6159 xcb_glx_get_pixel_mapusv_request_t xcb_out; 6160 6161 xcb_out.context_tag = context_tag; 6162 xcb_out.map = map; 6163 6164 xcb_parts[2].iov_base = (char *) &xcb_out; 6165 xcb_parts[2].iov_len = sizeof(xcb_out); 6166 xcb_parts[3].iov_base = 0; 6167 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6168 6169 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6170 return xcb_ret; 6171 } 6172 6173 xcb_glx_get_pixel_mapusv_cookie_t 6174 xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c, 6175 xcb_glx_context_tag_t context_tag, 6176 uint32_t map) 6177 { 6178 static const xcb_protocol_request_t xcb_req = { 6179 .count = 2, 6180 .ext = &xcb_glx_id, 6181 .opcode = XCB_GLX_GET_PIXEL_MAPUSV, 6182 .isvoid = 0 6183 }; 6184 6185 struct iovec xcb_parts[4]; 6186 xcb_glx_get_pixel_mapusv_cookie_t xcb_ret; 6187 xcb_glx_get_pixel_mapusv_request_t xcb_out; 6188 6189 xcb_out.context_tag = context_tag; 6190 xcb_out.map = map; 6191 6192 xcb_parts[2].iov_base = (char *) &xcb_out; 6193 xcb_parts[2].iov_len = sizeof(xcb_out); 6194 xcb_parts[3].iov_base = 0; 6195 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6196 6197 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6198 return xcb_ret; 6199 } 6200 6201 uint16_t * 6202 xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R) 6203 { 6204 return (uint16_t *) (R + 1); 6205 } 6206 6207 int 6208 xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R) 6209 { 6210 return R->n; 6211 } 6212 6213 xcb_generic_iterator_t 6214 xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R) 6215 { 6216 xcb_generic_iterator_t i; 6217 i.data = ((uint16_t *) (R + 1)) + (R->n); 6218 i.rem = 0; 6219 i.index = (char *) i.data - (char *) R; 6220 return i; 6221 } 6222 6223 xcb_glx_get_pixel_mapusv_reply_t * 6224 xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c, 6225 xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, 6226 xcb_generic_error_t **e) 6227 { 6228 return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6229 } 6230 6231 int 6232 xcb_glx_get_polygon_stipple_sizeof (const void *_buffer) 6233 { 6234 char *xcb_tmp = (char *)_buffer; 6235 const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer; 6236 unsigned int xcb_buffer_len = 0; 6237 unsigned int xcb_block_len = 0; 6238 unsigned int xcb_pad = 0; 6239 unsigned int xcb_align_to = 0; 6240 6241 6242 xcb_block_len += sizeof(xcb_glx_get_polygon_stipple_reply_t); 6243 xcb_tmp += xcb_block_len; 6244 xcb_buffer_len += xcb_block_len; 6245 xcb_block_len = 0; 6246 /* data */ 6247 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 6248 xcb_tmp += xcb_block_len; 6249 xcb_align_to = ALIGNOF(uint8_t); 6250 /* insert padding */ 6251 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6252 xcb_buffer_len += xcb_block_len + xcb_pad; 6253 if (0 != xcb_pad) { 6254 xcb_tmp += xcb_pad; 6255 xcb_pad = 0; 6256 } 6257 xcb_block_len = 0; 6258 6259 return xcb_buffer_len; 6260 } 6261 6262 xcb_glx_get_polygon_stipple_cookie_t 6263 xcb_glx_get_polygon_stipple (xcb_connection_t *c, 6264 xcb_glx_context_tag_t context_tag, 6265 uint8_t lsb_first) 6266 { 6267 static const xcb_protocol_request_t xcb_req = { 6268 .count = 2, 6269 .ext = &xcb_glx_id, 6270 .opcode = XCB_GLX_GET_POLYGON_STIPPLE, 6271 .isvoid = 0 6272 }; 6273 6274 struct iovec xcb_parts[4]; 6275 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 6276 xcb_glx_get_polygon_stipple_request_t xcb_out; 6277 6278 xcb_out.context_tag = context_tag; 6279 xcb_out.lsb_first = lsb_first; 6280 6281 xcb_parts[2].iov_base = (char *) &xcb_out; 6282 xcb_parts[2].iov_len = sizeof(xcb_out); 6283 xcb_parts[3].iov_base = 0; 6284 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6285 6286 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6287 return xcb_ret; 6288 } 6289 6290 xcb_glx_get_polygon_stipple_cookie_t 6291 xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c, 6292 xcb_glx_context_tag_t context_tag, 6293 uint8_t lsb_first) 6294 { 6295 static const xcb_protocol_request_t xcb_req = { 6296 .count = 2, 6297 .ext = &xcb_glx_id, 6298 .opcode = XCB_GLX_GET_POLYGON_STIPPLE, 6299 .isvoid = 0 6300 }; 6301 6302 struct iovec xcb_parts[4]; 6303 xcb_glx_get_polygon_stipple_cookie_t xcb_ret; 6304 xcb_glx_get_polygon_stipple_request_t xcb_out; 6305 6306 xcb_out.context_tag = context_tag; 6307 xcb_out.lsb_first = lsb_first; 6308 6309 xcb_parts[2].iov_base = (char *) &xcb_out; 6310 xcb_parts[2].iov_len = sizeof(xcb_out); 6311 xcb_parts[3].iov_base = 0; 6312 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6313 6314 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6315 return xcb_ret; 6316 } 6317 6318 uint8_t * 6319 xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R) 6320 { 6321 return (uint8_t *) (R + 1); 6322 } 6323 6324 int 6325 xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R) 6326 { 6327 return (R->length * 4); 6328 } 6329 6330 xcb_generic_iterator_t 6331 xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R) 6332 { 6333 xcb_generic_iterator_t i; 6334 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 6335 i.rem = 0; 6336 i.index = (char *) i.data - (char *) R; 6337 return i; 6338 } 6339 6340 xcb_glx_get_polygon_stipple_reply_t * 6341 xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c, 6342 xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, 6343 xcb_generic_error_t **e) 6344 { 6345 return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6346 } 6347 6348 int 6349 xcb_glx_get_string_sizeof (const void *_buffer) 6350 { 6351 char *xcb_tmp = (char *)_buffer; 6352 const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer; 6353 unsigned int xcb_buffer_len = 0; 6354 unsigned int xcb_block_len = 0; 6355 unsigned int xcb_pad = 0; 6356 unsigned int xcb_align_to = 0; 6357 6358 6359 xcb_block_len += sizeof(xcb_glx_get_string_reply_t); 6360 xcb_tmp += xcb_block_len; 6361 xcb_buffer_len += xcb_block_len; 6362 xcb_block_len = 0; 6363 /* string */ 6364 xcb_block_len += _aux->n * sizeof(char); 6365 xcb_tmp += xcb_block_len; 6366 xcb_align_to = ALIGNOF(char); 6367 /* insert padding */ 6368 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6369 xcb_buffer_len += xcb_block_len + xcb_pad; 6370 if (0 != xcb_pad) { 6371 xcb_tmp += xcb_pad; 6372 xcb_pad = 0; 6373 } 6374 xcb_block_len = 0; 6375 6376 return xcb_buffer_len; 6377 } 6378 6379 xcb_glx_get_string_cookie_t 6380 xcb_glx_get_string (xcb_connection_t *c, 6381 xcb_glx_context_tag_t context_tag, 6382 uint32_t name) 6383 { 6384 static const xcb_protocol_request_t xcb_req = { 6385 .count = 2, 6386 .ext = &xcb_glx_id, 6387 .opcode = XCB_GLX_GET_STRING, 6388 .isvoid = 0 6389 }; 6390 6391 struct iovec xcb_parts[4]; 6392 xcb_glx_get_string_cookie_t xcb_ret; 6393 xcb_glx_get_string_request_t xcb_out; 6394 6395 xcb_out.context_tag = context_tag; 6396 xcb_out.name = name; 6397 6398 xcb_parts[2].iov_base = (char *) &xcb_out; 6399 xcb_parts[2].iov_len = sizeof(xcb_out); 6400 xcb_parts[3].iov_base = 0; 6401 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6402 6403 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6404 return xcb_ret; 6405 } 6406 6407 xcb_glx_get_string_cookie_t 6408 xcb_glx_get_string_unchecked (xcb_connection_t *c, 6409 xcb_glx_context_tag_t context_tag, 6410 uint32_t name) 6411 { 6412 static const xcb_protocol_request_t xcb_req = { 6413 .count = 2, 6414 .ext = &xcb_glx_id, 6415 .opcode = XCB_GLX_GET_STRING, 6416 .isvoid = 0 6417 }; 6418 6419 struct iovec xcb_parts[4]; 6420 xcb_glx_get_string_cookie_t xcb_ret; 6421 xcb_glx_get_string_request_t xcb_out; 6422 6423 xcb_out.context_tag = context_tag; 6424 xcb_out.name = name; 6425 6426 xcb_parts[2].iov_base = (char *) &xcb_out; 6427 xcb_parts[2].iov_len = sizeof(xcb_out); 6428 xcb_parts[3].iov_base = 0; 6429 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6430 6431 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6432 return xcb_ret; 6433 } 6434 6435 char * 6436 xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R) 6437 { 6438 return (char *) (R + 1); 6439 } 6440 6441 int 6442 xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R) 6443 { 6444 return R->n; 6445 } 6446 6447 xcb_generic_iterator_t 6448 xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R) 6449 { 6450 xcb_generic_iterator_t i; 6451 i.data = ((char *) (R + 1)) + (R->n); 6452 i.rem = 0; 6453 i.index = (char *) i.data - (char *) R; 6454 return i; 6455 } 6456 6457 xcb_glx_get_string_reply_t * 6458 xcb_glx_get_string_reply (xcb_connection_t *c, 6459 xcb_glx_get_string_cookie_t cookie /**< */, 6460 xcb_generic_error_t **e) 6461 { 6462 return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6463 } 6464 6465 int 6466 xcb_glx_get_tex_envfv_sizeof (const void *_buffer) 6467 { 6468 char *xcb_tmp = (char *)_buffer; 6469 const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer; 6470 unsigned int xcb_buffer_len = 0; 6471 unsigned int xcb_block_len = 0; 6472 unsigned int xcb_pad = 0; 6473 unsigned int xcb_align_to = 0; 6474 6475 6476 xcb_block_len += sizeof(xcb_glx_get_tex_envfv_reply_t); 6477 xcb_tmp += xcb_block_len; 6478 xcb_buffer_len += xcb_block_len; 6479 xcb_block_len = 0; 6480 /* data */ 6481 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6482 xcb_tmp += xcb_block_len; 6483 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6484 /* insert padding */ 6485 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6486 xcb_buffer_len += xcb_block_len + xcb_pad; 6487 if (0 != xcb_pad) { 6488 xcb_tmp += xcb_pad; 6489 xcb_pad = 0; 6490 } 6491 xcb_block_len = 0; 6492 6493 return xcb_buffer_len; 6494 } 6495 6496 xcb_glx_get_tex_envfv_cookie_t 6497 xcb_glx_get_tex_envfv (xcb_connection_t *c, 6498 xcb_glx_context_tag_t context_tag, 6499 uint32_t target, 6500 uint32_t pname) 6501 { 6502 static const xcb_protocol_request_t xcb_req = { 6503 .count = 2, 6504 .ext = &xcb_glx_id, 6505 .opcode = XCB_GLX_GET_TEX_ENVFV, 6506 .isvoid = 0 6507 }; 6508 6509 struct iovec xcb_parts[4]; 6510 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 6511 xcb_glx_get_tex_envfv_request_t xcb_out; 6512 6513 xcb_out.context_tag = context_tag; 6514 xcb_out.target = target; 6515 xcb_out.pname = pname; 6516 6517 xcb_parts[2].iov_base = (char *) &xcb_out; 6518 xcb_parts[2].iov_len = sizeof(xcb_out); 6519 xcb_parts[3].iov_base = 0; 6520 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6521 6522 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6523 return xcb_ret; 6524 } 6525 6526 xcb_glx_get_tex_envfv_cookie_t 6527 xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c, 6528 xcb_glx_context_tag_t context_tag, 6529 uint32_t target, 6530 uint32_t pname) 6531 { 6532 static const xcb_protocol_request_t xcb_req = { 6533 .count = 2, 6534 .ext = &xcb_glx_id, 6535 .opcode = XCB_GLX_GET_TEX_ENVFV, 6536 .isvoid = 0 6537 }; 6538 6539 struct iovec xcb_parts[4]; 6540 xcb_glx_get_tex_envfv_cookie_t xcb_ret; 6541 xcb_glx_get_tex_envfv_request_t xcb_out; 6542 6543 xcb_out.context_tag = context_tag; 6544 xcb_out.target = target; 6545 xcb_out.pname = pname; 6546 6547 xcb_parts[2].iov_base = (char *) &xcb_out; 6548 xcb_parts[2].iov_len = sizeof(xcb_out); 6549 xcb_parts[3].iov_base = 0; 6550 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6551 6552 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6553 return xcb_ret; 6554 } 6555 6556 xcb_glx_float32_t * 6557 xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R) 6558 { 6559 return (xcb_glx_float32_t *) (R + 1); 6560 } 6561 6562 int 6563 xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R) 6564 { 6565 return R->n; 6566 } 6567 6568 xcb_generic_iterator_t 6569 xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R) 6570 { 6571 xcb_generic_iterator_t i; 6572 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6573 i.rem = 0; 6574 i.index = (char *) i.data - (char *) R; 6575 return i; 6576 } 6577 6578 xcb_glx_get_tex_envfv_reply_t * 6579 xcb_glx_get_tex_envfv_reply (xcb_connection_t *c, 6580 xcb_glx_get_tex_envfv_cookie_t cookie /**< */, 6581 xcb_generic_error_t **e) 6582 { 6583 return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6584 } 6585 6586 int 6587 xcb_glx_get_tex_enviv_sizeof (const void *_buffer) 6588 { 6589 char *xcb_tmp = (char *)_buffer; 6590 const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer; 6591 unsigned int xcb_buffer_len = 0; 6592 unsigned int xcb_block_len = 0; 6593 unsigned int xcb_pad = 0; 6594 unsigned int xcb_align_to = 0; 6595 6596 6597 xcb_block_len += sizeof(xcb_glx_get_tex_enviv_reply_t); 6598 xcb_tmp += xcb_block_len; 6599 xcb_buffer_len += xcb_block_len; 6600 xcb_block_len = 0; 6601 /* data */ 6602 xcb_block_len += _aux->n * sizeof(int32_t); 6603 xcb_tmp += xcb_block_len; 6604 xcb_align_to = ALIGNOF(int32_t); 6605 /* insert padding */ 6606 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6607 xcb_buffer_len += xcb_block_len + xcb_pad; 6608 if (0 != xcb_pad) { 6609 xcb_tmp += xcb_pad; 6610 xcb_pad = 0; 6611 } 6612 xcb_block_len = 0; 6613 6614 return xcb_buffer_len; 6615 } 6616 6617 xcb_glx_get_tex_enviv_cookie_t 6618 xcb_glx_get_tex_enviv (xcb_connection_t *c, 6619 xcb_glx_context_tag_t context_tag, 6620 uint32_t target, 6621 uint32_t pname) 6622 { 6623 static const xcb_protocol_request_t xcb_req = { 6624 .count = 2, 6625 .ext = &xcb_glx_id, 6626 .opcode = XCB_GLX_GET_TEX_ENVIV, 6627 .isvoid = 0 6628 }; 6629 6630 struct iovec xcb_parts[4]; 6631 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 6632 xcb_glx_get_tex_enviv_request_t xcb_out; 6633 6634 xcb_out.context_tag = context_tag; 6635 xcb_out.target = target; 6636 xcb_out.pname = pname; 6637 6638 xcb_parts[2].iov_base = (char *) &xcb_out; 6639 xcb_parts[2].iov_len = sizeof(xcb_out); 6640 xcb_parts[3].iov_base = 0; 6641 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6642 6643 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6644 return xcb_ret; 6645 } 6646 6647 xcb_glx_get_tex_enviv_cookie_t 6648 xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c, 6649 xcb_glx_context_tag_t context_tag, 6650 uint32_t target, 6651 uint32_t pname) 6652 { 6653 static const xcb_protocol_request_t xcb_req = { 6654 .count = 2, 6655 .ext = &xcb_glx_id, 6656 .opcode = XCB_GLX_GET_TEX_ENVIV, 6657 .isvoid = 0 6658 }; 6659 6660 struct iovec xcb_parts[4]; 6661 xcb_glx_get_tex_enviv_cookie_t xcb_ret; 6662 xcb_glx_get_tex_enviv_request_t xcb_out; 6663 6664 xcb_out.context_tag = context_tag; 6665 xcb_out.target = target; 6666 xcb_out.pname = pname; 6667 6668 xcb_parts[2].iov_base = (char *) &xcb_out; 6669 xcb_parts[2].iov_len = sizeof(xcb_out); 6670 xcb_parts[3].iov_base = 0; 6671 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6672 6673 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6674 return xcb_ret; 6675 } 6676 6677 int32_t * 6678 xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R) 6679 { 6680 return (int32_t *) (R + 1); 6681 } 6682 6683 int 6684 xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R) 6685 { 6686 return R->n; 6687 } 6688 6689 xcb_generic_iterator_t 6690 xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R) 6691 { 6692 xcb_generic_iterator_t i; 6693 i.data = ((int32_t *) (R + 1)) + (R->n); 6694 i.rem = 0; 6695 i.index = (char *) i.data - (char *) R; 6696 return i; 6697 } 6698 6699 xcb_glx_get_tex_enviv_reply_t * 6700 xcb_glx_get_tex_enviv_reply (xcb_connection_t *c, 6701 xcb_glx_get_tex_enviv_cookie_t cookie /**< */, 6702 xcb_generic_error_t **e) 6703 { 6704 return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6705 } 6706 6707 int 6708 xcb_glx_get_tex_gendv_sizeof (const void *_buffer) 6709 { 6710 char *xcb_tmp = (char *)_buffer; 6711 const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer; 6712 unsigned int xcb_buffer_len = 0; 6713 unsigned int xcb_block_len = 0; 6714 unsigned int xcb_pad = 0; 6715 unsigned int xcb_align_to = 0; 6716 6717 6718 xcb_block_len += sizeof(xcb_glx_get_tex_gendv_reply_t); 6719 xcb_tmp += xcb_block_len; 6720 xcb_buffer_len += xcb_block_len; 6721 xcb_block_len = 0; 6722 /* data */ 6723 xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t); 6724 xcb_tmp += xcb_block_len; 6725 xcb_align_to = ALIGNOF(xcb_glx_float64_t); 6726 /* insert padding */ 6727 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6728 xcb_buffer_len += xcb_block_len + xcb_pad; 6729 if (0 != xcb_pad) { 6730 xcb_tmp += xcb_pad; 6731 xcb_pad = 0; 6732 } 6733 xcb_block_len = 0; 6734 6735 return xcb_buffer_len; 6736 } 6737 6738 xcb_glx_get_tex_gendv_cookie_t 6739 xcb_glx_get_tex_gendv (xcb_connection_t *c, 6740 xcb_glx_context_tag_t context_tag, 6741 uint32_t coord, 6742 uint32_t pname) 6743 { 6744 static const xcb_protocol_request_t xcb_req = { 6745 .count = 2, 6746 .ext = &xcb_glx_id, 6747 .opcode = XCB_GLX_GET_TEX_GENDV, 6748 .isvoid = 0 6749 }; 6750 6751 struct iovec xcb_parts[4]; 6752 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 6753 xcb_glx_get_tex_gendv_request_t xcb_out; 6754 6755 xcb_out.context_tag = context_tag; 6756 xcb_out.coord = coord; 6757 xcb_out.pname = pname; 6758 6759 xcb_parts[2].iov_base = (char *) &xcb_out; 6760 xcb_parts[2].iov_len = sizeof(xcb_out); 6761 xcb_parts[3].iov_base = 0; 6762 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6763 6764 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6765 return xcb_ret; 6766 } 6767 6768 xcb_glx_get_tex_gendv_cookie_t 6769 xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c, 6770 xcb_glx_context_tag_t context_tag, 6771 uint32_t coord, 6772 uint32_t pname) 6773 { 6774 static const xcb_protocol_request_t xcb_req = { 6775 .count = 2, 6776 .ext = &xcb_glx_id, 6777 .opcode = XCB_GLX_GET_TEX_GENDV, 6778 .isvoid = 0 6779 }; 6780 6781 struct iovec xcb_parts[4]; 6782 xcb_glx_get_tex_gendv_cookie_t xcb_ret; 6783 xcb_glx_get_tex_gendv_request_t xcb_out; 6784 6785 xcb_out.context_tag = context_tag; 6786 xcb_out.coord = coord; 6787 xcb_out.pname = pname; 6788 6789 xcb_parts[2].iov_base = (char *) &xcb_out; 6790 xcb_parts[2].iov_len = sizeof(xcb_out); 6791 xcb_parts[3].iov_base = 0; 6792 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6793 6794 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6795 return xcb_ret; 6796 } 6797 6798 xcb_glx_float64_t * 6799 xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R) 6800 { 6801 return (xcb_glx_float64_t *) (R + 1); 6802 } 6803 6804 int 6805 xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R) 6806 { 6807 return R->n; 6808 } 6809 6810 xcb_generic_iterator_t 6811 xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R) 6812 { 6813 xcb_generic_iterator_t i; 6814 i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); 6815 i.rem = 0; 6816 i.index = (char *) i.data - (char *) R; 6817 return i; 6818 } 6819 6820 xcb_glx_get_tex_gendv_reply_t * 6821 xcb_glx_get_tex_gendv_reply (xcb_connection_t *c, 6822 xcb_glx_get_tex_gendv_cookie_t cookie /**< */, 6823 xcb_generic_error_t **e) 6824 { 6825 return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6826 } 6827 6828 int 6829 xcb_glx_get_tex_genfv_sizeof (const void *_buffer) 6830 { 6831 char *xcb_tmp = (char *)_buffer; 6832 const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer; 6833 unsigned int xcb_buffer_len = 0; 6834 unsigned int xcb_block_len = 0; 6835 unsigned int xcb_pad = 0; 6836 unsigned int xcb_align_to = 0; 6837 6838 6839 xcb_block_len += sizeof(xcb_glx_get_tex_genfv_reply_t); 6840 xcb_tmp += xcb_block_len; 6841 xcb_buffer_len += xcb_block_len; 6842 xcb_block_len = 0; 6843 /* data */ 6844 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 6845 xcb_tmp += xcb_block_len; 6846 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 6847 /* insert padding */ 6848 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6849 xcb_buffer_len += xcb_block_len + xcb_pad; 6850 if (0 != xcb_pad) { 6851 xcb_tmp += xcb_pad; 6852 xcb_pad = 0; 6853 } 6854 xcb_block_len = 0; 6855 6856 return xcb_buffer_len; 6857 } 6858 6859 xcb_glx_get_tex_genfv_cookie_t 6860 xcb_glx_get_tex_genfv (xcb_connection_t *c, 6861 xcb_glx_context_tag_t context_tag, 6862 uint32_t coord, 6863 uint32_t pname) 6864 { 6865 static const xcb_protocol_request_t xcb_req = { 6866 .count = 2, 6867 .ext = &xcb_glx_id, 6868 .opcode = XCB_GLX_GET_TEX_GENFV, 6869 .isvoid = 0 6870 }; 6871 6872 struct iovec xcb_parts[4]; 6873 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 6874 xcb_glx_get_tex_genfv_request_t xcb_out; 6875 6876 xcb_out.context_tag = context_tag; 6877 xcb_out.coord = coord; 6878 xcb_out.pname = pname; 6879 6880 xcb_parts[2].iov_base = (char *) &xcb_out; 6881 xcb_parts[2].iov_len = sizeof(xcb_out); 6882 xcb_parts[3].iov_base = 0; 6883 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6884 6885 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6886 return xcb_ret; 6887 } 6888 6889 xcb_glx_get_tex_genfv_cookie_t 6890 xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c, 6891 xcb_glx_context_tag_t context_tag, 6892 uint32_t coord, 6893 uint32_t pname) 6894 { 6895 static const xcb_protocol_request_t xcb_req = { 6896 .count = 2, 6897 .ext = &xcb_glx_id, 6898 .opcode = XCB_GLX_GET_TEX_GENFV, 6899 .isvoid = 0 6900 }; 6901 6902 struct iovec xcb_parts[4]; 6903 xcb_glx_get_tex_genfv_cookie_t xcb_ret; 6904 xcb_glx_get_tex_genfv_request_t xcb_out; 6905 6906 xcb_out.context_tag = context_tag; 6907 xcb_out.coord = coord; 6908 xcb_out.pname = pname; 6909 6910 xcb_parts[2].iov_base = (char *) &xcb_out; 6911 xcb_parts[2].iov_len = sizeof(xcb_out); 6912 xcb_parts[3].iov_base = 0; 6913 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6914 6915 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6916 return xcb_ret; 6917 } 6918 6919 xcb_glx_float32_t * 6920 xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R) 6921 { 6922 return (xcb_glx_float32_t *) (R + 1); 6923 } 6924 6925 int 6926 xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R) 6927 { 6928 return R->n; 6929 } 6930 6931 xcb_generic_iterator_t 6932 xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R) 6933 { 6934 xcb_generic_iterator_t i; 6935 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 6936 i.rem = 0; 6937 i.index = (char *) i.data - (char *) R; 6938 return i; 6939 } 6940 6941 xcb_glx_get_tex_genfv_reply_t * 6942 xcb_glx_get_tex_genfv_reply (xcb_connection_t *c, 6943 xcb_glx_get_tex_genfv_cookie_t cookie /**< */, 6944 xcb_generic_error_t **e) 6945 { 6946 return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6947 } 6948 6949 int 6950 xcb_glx_get_tex_geniv_sizeof (const void *_buffer) 6951 { 6952 char *xcb_tmp = (char *)_buffer; 6953 const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer; 6954 unsigned int xcb_buffer_len = 0; 6955 unsigned int xcb_block_len = 0; 6956 unsigned int xcb_pad = 0; 6957 unsigned int xcb_align_to = 0; 6958 6959 6960 xcb_block_len += sizeof(xcb_glx_get_tex_geniv_reply_t); 6961 xcb_tmp += xcb_block_len; 6962 xcb_buffer_len += xcb_block_len; 6963 xcb_block_len = 0; 6964 /* data */ 6965 xcb_block_len += _aux->n * sizeof(int32_t); 6966 xcb_tmp += xcb_block_len; 6967 xcb_align_to = ALIGNOF(int32_t); 6968 /* insert padding */ 6969 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6970 xcb_buffer_len += xcb_block_len + xcb_pad; 6971 if (0 != xcb_pad) { 6972 xcb_tmp += xcb_pad; 6973 xcb_pad = 0; 6974 } 6975 xcb_block_len = 0; 6976 6977 return xcb_buffer_len; 6978 } 6979 6980 xcb_glx_get_tex_geniv_cookie_t 6981 xcb_glx_get_tex_geniv (xcb_connection_t *c, 6982 xcb_glx_context_tag_t context_tag, 6983 uint32_t coord, 6984 uint32_t pname) 6985 { 6986 static const xcb_protocol_request_t xcb_req = { 6987 .count = 2, 6988 .ext = &xcb_glx_id, 6989 .opcode = XCB_GLX_GET_TEX_GENIV, 6990 .isvoid = 0 6991 }; 6992 6993 struct iovec xcb_parts[4]; 6994 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 6995 xcb_glx_get_tex_geniv_request_t xcb_out; 6996 6997 xcb_out.context_tag = context_tag; 6998 xcb_out.coord = coord; 6999 xcb_out.pname = pname; 7000 7001 xcb_parts[2].iov_base = (char *) &xcb_out; 7002 xcb_parts[2].iov_len = sizeof(xcb_out); 7003 xcb_parts[3].iov_base = 0; 7004 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7005 7006 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7007 return xcb_ret; 7008 } 7009 7010 xcb_glx_get_tex_geniv_cookie_t 7011 xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c, 7012 xcb_glx_context_tag_t context_tag, 7013 uint32_t coord, 7014 uint32_t pname) 7015 { 7016 static const xcb_protocol_request_t xcb_req = { 7017 .count = 2, 7018 .ext = &xcb_glx_id, 7019 .opcode = XCB_GLX_GET_TEX_GENIV, 7020 .isvoid = 0 7021 }; 7022 7023 struct iovec xcb_parts[4]; 7024 xcb_glx_get_tex_geniv_cookie_t xcb_ret; 7025 xcb_glx_get_tex_geniv_request_t xcb_out; 7026 7027 xcb_out.context_tag = context_tag; 7028 xcb_out.coord = coord; 7029 xcb_out.pname = pname; 7030 7031 xcb_parts[2].iov_base = (char *) &xcb_out; 7032 xcb_parts[2].iov_len = sizeof(xcb_out); 7033 xcb_parts[3].iov_base = 0; 7034 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7035 7036 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7037 return xcb_ret; 7038 } 7039 7040 int32_t * 7041 xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R) 7042 { 7043 return (int32_t *) (R + 1); 7044 } 7045 7046 int 7047 xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R) 7048 { 7049 return R->n; 7050 } 7051 7052 xcb_generic_iterator_t 7053 xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R) 7054 { 7055 xcb_generic_iterator_t i; 7056 i.data = ((int32_t *) (R + 1)) + (R->n); 7057 i.rem = 0; 7058 i.index = (char *) i.data - (char *) R; 7059 return i; 7060 } 7061 7062 xcb_glx_get_tex_geniv_reply_t * 7063 xcb_glx_get_tex_geniv_reply (xcb_connection_t *c, 7064 xcb_glx_get_tex_geniv_cookie_t cookie /**< */, 7065 xcb_generic_error_t **e) 7066 { 7067 return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7068 } 7069 7070 int 7071 xcb_glx_get_tex_image_sizeof (const void *_buffer) 7072 { 7073 char *xcb_tmp = (char *)_buffer; 7074 const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer; 7075 unsigned int xcb_buffer_len = 0; 7076 unsigned int xcb_block_len = 0; 7077 unsigned int xcb_pad = 0; 7078 unsigned int xcb_align_to = 0; 7079 7080 7081 xcb_block_len += sizeof(xcb_glx_get_tex_image_reply_t); 7082 xcb_tmp += xcb_block_len; 7083 xcb_buffer_len += xcb_block_len; 7084 xcb_block_len = 0; 7085 /* data */ 7086 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 7087 xcb_tmp += xcb_block_len; 7088 xcb_align_to = ALIGNOF(uint8_t); 7089 /* insert padding */ 7090 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7091 xcb_buffer_len += xcb_block_len + xcb_pad; 7092 if (0 != xcb_pad) { 7093 xcb_tmp += xcb_pad; 7094 xcb_pad = 0; 7095 } 7096 xcb_block_len = 0; 7097 7098 return xcb_buffer_len; 7099 } 7100 7101 xcb_glx_get_tex_image_cookie_t 7102 xcb_glx_get_tex_image (xcb_connection_t *c, 7103 xcb_glx_context_tag_t context_tag, 7104 uint32_t target, 7105 int32_t level, 7106 uint32_t format, 7107 uint32_t type, 7108 uint8_t swap_bytes) 7109 { 7110 static const xcb_protocol_request_t xcb_req = { 7111 .count = 2, 7112 .ext = &xcb_glx_id, 7113 .opcode = XCB_GLX_GET_TEX_IMAGE, 7114 .isvoid = 0 7115 }; 7116 7117 struct iovec xcb_parts[4]; 7118 xcb_glx_get_tex_image_cookie_t xcb_ret; 7119 xcb_glx_get_tex_image_request_t xcb_out; 7120 7121 xcb_out.context_tag = context_tag; 7122 xcb_out.target = target; 7123 xcb_out.level = level; 7124 xcb_out.format = format; 7125 xcb_out.type = type; 7126 xcb_out.swap_bytes = swap_bytes; 7127 7128 xcb_parts[2].iov_base = (char *) &xcb_out; 7129 xcb_parts[2].iov_len = sizeof(xcb_out); 7130 xcb_parts[3].iov_base = 0; 7131 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7132 7133 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7134 return xcb_ret; 7135 } 7136 7137 xcb_glx_get_tex_image_cookie_t 7138 xcb_glx_get_tex_image_unchecked (xcb_connection_t *c, 7139 xcb_glx_context_tag_t context_tag, 7140 uint32_t target, 7141 int32_t level, 7142 uint32_t format, 7143 uint32_t type, 7144 uint8_t swap_bytes) 7145 { 7146 static const xcb_protocol_request_t xcb_req = { 7147 .count = 2, 7148 .ext = &xcb_glx_id, 7149 .opcode = XCB_GLX_GET_TEX_IMAGE, 7150 .isvoid = 0 7151 }; 7152 7153 struct iovec xcb_parts[4]; 7154 xcb_glx_get_tex_image_cookie_t xcb_ret; 7155 xcb_glx_get_tex_image_request_t xcb_out; 7156 7157 xcb_out.context_tag = context_tag; 7158 xcb_out.target = target; 7159 xcb_out.level = level; 7160 xcb_out.format = format; 7161 xcb_out.type = type; 7162 xcb_out.swap_bytes = swap_bytes; 7163 7164 xcb_parts[2].iov_base = (char *) &xcb_out; 7165 xcb_parts[2].iov_len = sizeof(xcb_out); 7166 xcb_parts[3].iov_base = 0; 7167 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7168 7169 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7170 return xcb_ret; 7171 } 7172 7173 uint8_t * 7174 xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R) 7175 { 7176 return (uint8_t *) (R + 1); 7177 } 7178 7179 int 7180 xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R) 7181 { 7182 return (R->length * 4); 7183 } 7184 7185 xcb_generic_iterator_t 7186 xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R) 7187 { 7188 xcb_generic_iterator_t i; 7189 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 7190 i.rem = 0; 7191 i.index = (char *) i.data - (char *) R; 7192 return i; 7193 } 7194 7195 xcb_glx_get_tex_image_reply_t * 7196 xcb_glx_get_tex_image_reply (xcb_connection_t *c, 7197 xcb_glx_get_tex_image_cookie_t cookie /**< */, 7198 xcb_generic_error_t **e) 7199 { 7200 return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7201 } 7202 7203 int 7204 xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer) 7205 { 7206 char *xcb_tmp = (char *)_buffer; 7207 const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer; 7208 unsigned int xcb_buffer_len = 0; 7209 unsigned int xcb_block_len = 0; 7210 unsigned int xcb_pad = 0; 7211 unsigned int xcb_align_to = 0; 7212 7213 7214 xcb_block_len += sizeof(xcb_glx_get_tex_parameterfv_reply_t); 7215 xcb_tmp += xcb_block_len; 7216 xcb_buffer_len += xcb_block_len; 7217 xcb_block_len = 0; 7218 /* data */ 7219 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7220 xcb_tmp += xcb_block_len; 7221 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7222 /* insert padding */ 7223 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7224 xcb_buffer_len += xcb_block_len + xcb_pad; 7225 if (0 != xcb_pad) { 7226 xcb_tmp += xcb_pad; 7227 xcb_pad = 0; 7228 } 7229 xcb_block_len = 0; 7230 7231 return xcb_buffer_len; 7232 } 7233 7234 xcb_glx_get_tex_parameterfv_cookie_t 7235 xcb_glx_get_tex_parameterfv (xcb_connection_t *c, 7236 xcb_glx_context_tag_t context_tag, 7237 uint32_t target, 7238 uint32_t pname) 7239 { 7240 static const xcb_protocol_request_t xcb_req = { 7241 .count = 2, 7242 .ext = &xcb_glx_id, 7243 .opcode = XCB_GLX_GET_TEX_PARAMETERFV, 7244 .isvoid = 0 7245 }; 7246 7247 struct iovec xcb_parts[4]; 7248 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 7249 xcb_glx_get_tex_parameterfv_request_t xcb_out; 7250 7251 xcb_out.context_tag = context_tag; 7252 xcb_out.target = target; 7253 xcb_out.pname = pname; 7254 7255 xcb_parts[2].iov_base = (char *) &xcb_out; 7256 xcb_parts[2].iov_len = sizeof(xcb_out); 7257 xcb_parts[3].iov_base = 0; 7258 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7259 7260 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7261 return xcb_ret; 7262 } 7263 7264 xcb_glx_get_tex_parameterfv_cookie_t 7265 xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c, 7266 xcb_glx_context_tag_t context_tag, 7267 uint32_t target, 7268 uint32_t pname) 7269 { 7270 static const xcb_protocol_request_t xcb_req = { 7271 .count = 2, 7272 .ext = &xcb_glx_id, 7273 .opcode = XCB_GLX_GET_TEX_PARAMETERFV, 7274 .isvoid = 0 7275 }; 7276 7277 struct iovec xcb_parts[4]; 7278 xcb_glx_get_tex_parameterfv_cookie_t xcb_ret; 7279 xcb_glx_get_tex_parameterfv_request_t xcb_out; 7280 7281 xcb_out.context_tag = context_tag; 7282 xcb_out.target = target; 7283 xcb_out.pname = pname; 7284 7285 xcb_parts[2].iov_base = (char *) &xcb_out; 7286 xcb_parts[2].iov_len = sizeof(xcb_out); 7287 xcb_parts[3].iov_base = 0; 7288 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7289 7290 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7291 return xcb_ret; 7292 } 7293 7294 xcb_glx_float32_t * 7295 xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R) 7296 { 7297 return (xcb_glx_float32_t *) (R + 1); 7298 } 7299 7300 int 7301 xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R) 7302 { 7303 return R->n; 7304 } 7305 7306 xcb_generic_iterator_t 7307 xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R) 7308 { 7309 xcb_generic_iterator_t i; 7310 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7311 i.rem = 0; 7312 i.index = (char *) i.data - (char *) R; 7313 return i; 7314 } 7315 7316 xcb_glx_get_tex_parameterfv_reply_t * 7317 xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c, 7318 xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, 7319 xcb_generic_error_t **e) 7320 { 7321 return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7322 } 7323 7324 int 7325 xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer) 7326 { 7327 char *xcb_tmp = (char *)_buffer; 7328 const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer; 7329 unsigned int xcb_buffer_len = 0; 7330 unsigned int xcb_block_len = 0; 7331 unsigned int xcb_pad = 0; 7332 unsigned int xcb_align_to = 0; 7333 7334 7335 xcb_block_len += sizeof(xcb_glx_get_tex_parameteriv_reply_t); 7336 xcb_tmp += xcb_block_len; 7337 xcb_buffer_len += xcb_block_len; 7338 xcb_block_len = 0; 7339 /* data */ 7340 xcb_block_len += _aux->n * sizeof(int32_t); 7341 xcb_tmp += xcb_block_len; 7342 xcb_align_to = ALIGNOF(int32_t); 7343 /* insert padding */ 7344 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7345 xcb_buffer_len += xcb_block_len + xcb_pad; 7346 if (0 != xcb_pad) { 7347 xcb_tmp += xcb_pad; 7348 xcb_pad = 0; 7349 } 7350 xcb_block_len = 0; 7351 7352 return xcb_buffer_len; 7353 } 7354 7355 xcb_glx_get_tex_parameteriv_cookie_t 7356 xcb_glx_get_tex_parameteriv (xcb_connection_t *c, 7357 xcb_glx_context_tag_t context_tag, 7358 uint32_t target, 7359 uint32_t pname) 7360 { 7361 static const xcb_protocol_request_t xcb_req = { 7362 .count = 2, 7363 .ext = &xcb_glx_id, 7364 .opcode = XCB_GLX_GET_TEX_PARAMETERIV, 7365 .isvoid = 0 7366 }; 7367 7368 struct iovec xcb_parts[4]; 7369 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 7370 xcb_glx_get_tex_parameteriv_request_t xcb_out; 7371 7372 xcb_out.context_tag = context_tag; 7373 xcb_out.target = target; 7374 xcb_out.pname = pname; 7375 7376 xcb_parts[2].iov_base = (char *) &xcb_out; 7377 xcb_parts[2].iov_len = sizeof(xcb_out); 7378 xcb_parts[3].iov_base = 0; 7379 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7380 7381 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7382 return xcb_ret; 7383 } 7384 7385 xcb_glx_get_tex_parameteriv_cookie_t 7386 xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c, 7387 xcb_glx_context_tag_t context_tag, 7388 uint32_t target, 7389 uint32_t pname) 7390 { 7391 static const xcb_protocol_request_t xcb_req = { 7392 .count = 2, 7393 .ext = &xcb_glx_id, 7394 .opcode = XCB_GLX_GET_TEX_PARAMETERIV, 7395 .isvoid = 0 7396 }; 7397 7398 struct iovec xcb_parts[4]; 7399 xcb_glx_get_tex_parameteriv_cookie_t xcb_ret; 7400 xcb_glx_get_tex_parameteriv_request_t xcb_out; 7401 7402 xcb_out.context_tag = context_tag; 7403 xcb_out.target = target; 7404 xcb_out.pname = pname; 7405 7406 xcb_parts[2].iov_base = (char *) &xcb_out; 7407 xcb_parts[2].iov_len = sizeof(xcb_out); 7408 xcb_parts[3].iov_base = 0; 7409 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7410 7411 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7412 return xcb_ret; 7413 } 7414 7415 int32_t * 7416 xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R) 7417 { 7418 return (int32_t *) (R + 1); 7419 } 7420 7421 int 7422 xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R) 7423 { 7424 return R->n; 7425 } 7426 7427 xcb_generic_iterator_t 7428 xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R) 7429 { 7430 xcb_generic_iterator_t i; 7431 i.data = ((int32_t *) (R + 1)) + (R->n); 7432 i.rem = 0; 7433 i.index = (char *) i.data - (char *) R; 7434 return i; 7435 } 7436 7437 xcb_glx_get_tex_parameteriv_reply_t * 7438 xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c, 7439 xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, 7440 xcb_generic_error_t **e) 7441 { 7442 return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7443 } 7444 7445 int 7446 xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer) 7447 { 7448 char *xcb_tmp = (char *)_buffer; 7449 const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer; 7450 unsigned int xcb_buffer_len = 0; 7451 unsigned int xcb_block_len = 0; 7452 unsigned int xcb_pad = 0; 7453 unsigned int xcb_align_to = 0; 7454 7455 7456 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameterfv_reply_t); 7457 xcb_tmp += xcb_block_len; 7458 xcb_buffer_len += xcb_block_len; 7459 xcb_block_len = 0; 7460 /* data */ 7461 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 7462 xcb_tmp += xcb_block_len; 7463 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 7464 /* insert padding */ 7465 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7466 xcb_buffer_len += xcb_block_len + xcb_pad; 7467 if (0 != xcb_pad) { 7468 xcb_tmp += xcb_pad; 7469 xcb_pad = 0; 7470 } 7471 xcb_block_len = 0; 7472 7473 return xcb_buffer_len; 7474 } 7475 7476 xcb_glx_get_tex_level_parameterfv_cookie_t 7477 xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c, 7478 xcb_glx_context_tag_t context_tag, 7479 uint32_t target, 7480 int32_t level, 7481 uint32_t pname) 7482 { 7483 static const xcb_protocol_request_t xcb_req = { 7484 .count = 2, 7485 .ext = &xcb_glx_id, 7486 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 7487 .isvoid = 0 7488 }; 7489 7490 struct iovec xcb_parts[4]; 7491 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 7492 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 7493 7494 xcb_out.context_tag = context_tag; 7495 xcb_out.target = target; 7496 xcb_out.level = level; 7497 xcb_out.pname = pname; 7498 7499 xcb_parts[2].iov_base = (char *) &xcb_out; 7500 xcb_parts[2].iov_len = sizeof(xcb_out); 7501 xcb_parts[3].iov_base = 0; 7502 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7503 7504 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7505 return xcb_ret; 7506 } 7507 7508 xcb_glx_get_tex_level_parameterfv_cookie_t 7509 xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c, 7510 xcb_glx_context_tag_t context_tag, 7511 uint32_t target, 7512 int32_t level, 7513 uint32_t pname) 7514 { 7515 static const xcb_protocol_request_t xcb_req = { 7516 .count = 2, 7517 .ext = &xcb_glx_id, 7518 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, 7519 .isvoid = 0 7520 }; 7521 7522 struct iovec xcb_parts[4]; 7523 xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret; 7524 xcb_glx_get_tex_level_parameterfv_request_t xcb_out; 7525 7526 xcb_out.context_tag = context_tag; 7527 xcb_out.target = target; 7528 xcb_out.level = level; 7529 xcb_out.pname = pname; 7530 7531 xcb_parts[2].iov_base = (char *) &xcb_out; 7532 xcb_parts[2].iov_len = sizeof(xcb_out); 7533 xcb_parts[3].iov_base = 0; 7534 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7535 7536 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7537 return xcb_ret; 7538 } 7539 7540 xcb_glx_float32_t * 7541 xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7542 { 7543 return (xcb_glx_float32_t *) (R + 1); 7544 } 7545 7546 int 7547 xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7548 { 7549 return R->n; 7550 } 7551 7552 xcb_generic_iterator_t 7553 xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R) 7554 { 7555 xcb_generic_iterator_t i; 7556 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 7557 i.rem = 0; 7558 i.index = (char *) i.data - (char *) R; 7559 return i; 7560 } 7561 7562 xcb_glx_get_tex_level_parameterfv_reply_t * 7563 xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c, 7564 xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, 7565 xcb_generic_error_t **e) 7566 { 7567 return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7568 } 7569 7570 int 7571 xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer) 7572 { 7573 char *xcb_tmp = (char *)_buffer; 7574 const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer; 7575 unsigned int xcb_buffer_len = 0; 7576 unsigned int xcb_block_len = 0; 7577 unsigned int xcb_pad = 0; 7578 unsigned int xcb_align_to = 0; 7579 7580 7581 xcb_block_len += sizeof(xcb_glx_get_tex_level_parameteriv_reply_t); 7582 xcb_tmp += xcb_block_len; 7583 xcb_buffer_len += xcb_block_len; 7584 xcb_block_len = 0; 7585 /* data */ 7586 xcb_block_len += _aux->n * sizeof(int32_t); 7587 xcb_tmp += xcb_block_len; 7588 xcb_align_to = ALIGNOF(int32_t); 7589 /* insert padding */ 7590 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7591 xcb_buffer_len += xcb_block_len + xcb_pad; 7592 if (0 != xcb_pad) { 7593 xcb_tmp += xcb_pad; 7594 xcb_pad = 0; 7595 } 7596 xcb_block_len = 0; 7597 7598 return xcb_buffer_len; 7599 } 7600 7601 xcb_glx_get_tex_level_parameteriv_cookie_t 7602 xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c, 7603 xcb_glx_context_tag_t context_tag, 7604 uint32_t target, 7605 int32_t level, 7606 uint32_t pname) 7607 { 7608 static const xcb_protocol_request_t xcb_req = { 7609 .count = 2, 7610 .ext = &xcb_glx_id, 7611 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 7612 .isvoid = 0 7613 }; 7614 7615 struct iovec xcb_parts[4]; 7616 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 7617 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 7618 7619 xcb_out.context_tag = context_tag; 7620 xcb_out.target = target; 7621 xcb_out.level = level; 7622 xcb_out.pname = pname; 7623 7624 xcb_parts[2].iov_base = (char *) &xcb_out; 7625 xcb_parts[2].iov_len = sizeof(xcb_out); 7626 xcb_parts[3].iov_base = 0; 7627 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7628 7629 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7630 return xcb_ret; 7631 } 7632 7633 xcb_glx_get_tex_level_parameteriv_cookie_t 7634 xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c, 7635 xcb_glx_context_tag_t context_tag, 7636 uint32_t target, 7637 int32_t level, 7638 uint32_t pname) 7639 { 7640 static const xcb_protocol_request_t xcb_req = { 7641 .count = 2, 7642 .ext = &xcb_glx_id, 7643 .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, 7644 .isvoid = 0 7645 }; 7646 7647 struct iovec xcb_parts[4]; 7648 xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret; 7649 xcb_glx_get_tex_level_parameteriv_request_t xcb_out; 7650 7651 xcb_out.context_tag = context_tag; 7652 xcb_out.target = target; 7653 xcb_out.level = level; 7654 xcb_out.pname = pname; 7655 7656 xcb_parts[2].iov_base = (char *) &xcb_out; 7657 xcb_parts[2].iov_len = sizeof(xcb_out); 7658 xcb_parts[3].iov_base = 0; 7659 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7660 7661 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7662 return xcb_ret; 7663 } 7664 7665 int32_t * 7666 xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7667 { 7668 return (int32_t *) (R + 1); 7669 } 7670 7671 int 7672 xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7673 { 7674 return R->n; 7675 } 7676 7677 xcb_generic_iterator_t 7678 xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R) 7679 { 7680 xcb_generic_iterator_t i; 7681 i.data = ((int32_t *) (R + 1)) + (R->n); 7682 i.rem = 0; 7683 i.index = (char *) i.data - (char *) R; 7684 return i; 7685 } 7686 7687 xcb_glx_get_tex_level_parameteriv_reply_t * 7688 xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c, 7689 xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, 7690 xcb_generic_error_t **e) 7691 { 7692 return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7693 } 7694 7695 xcb_glx_is_enabled_cookie_t 7696 xcb_glx_is_enabled (xcb_connection_t *c, 7697 xcb_glx_context_tag_t context_tag, 7698 uint32_t capability) 7699 { 7700 static const xcb_protocol_request_t xcb_req = { 7701 .count = 2, 7702 .ext = &xcb_glx_id, 7703 .opcode = XCB_GLX_IS_ENABLED, 7704 .isvoid = 0 7705 }; 7706 7707 struct iovec xcb_parts[4]; 7708 xcb_glx_is_enabled_cookie_t xcb_ret; 7709 xcb_glx_is_enabled_request_t xcb_out; 7710 7711 xcb_out.context_tag = context_tag; 7712 xcb_out.capability = capability; 7713 7714 xcb_parts[2].iov_base = (char *) &xcb_out; 7715 xcb_parts[2].iov_len = sizeof(xcb_out); 7716 xcb_parts[3].iov_base = 0; 7717 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7718 7719 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7720 return xcb_ret; 7721 } 7722 7723 xcb_glx_is_enabled_cookie_t 7724 xcb_glx_is_enabled_unchecked (xcb_connection_t *c, 7725 xcb_glx_context_tag_t context_tag, 7726 uint32_t capability) 7727 { 7728 static const xcb_protocol_request_t xcb_req = { 7729 .count = 2, 7730 .ext = &xcb_glx_id, 7731 .opcode = XCB_GLX_IS_ENABLED, 7732 .isvoid = 0 7733 }; 7734 7735 struct iovec xcb_parts[4]; 7736 xcb_glx_is_enabled_cookie_t xcb_ret; 7737 xcb_glx_is_enabled_request_t xcb_out; 7738 7739 xcb_out.context_tag = context_tag; 7740 xcb_out.capability = capability; 7741 7742 xcb_parts[2].iov_base = (char *) &xcb_out; 7743 xcb_parts[2].iov_len = sizeof(xcb_out); 7744 xcb_parts[3].iov_base = 0; 7745 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7746 7747 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7748 return xcb_ret; 7749 } 7750 7751 xcb_glx_is_enabled_reply_t * 7752 xcb_glx_is_enabled_reply (xcb_connection_t *c, 7753 xcb_glx_is_enabled_cookie_t cookie /**< */, 7754 xcb_generic_error_t **e) 7755 { 7756 return (xcb_glx_is_enabled_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7757 } 7758 7759 xcb_glx_is_list_cookie_t 7760 xcb_glx_is_list (xcb_connection_t *c, 7761 xcb_glx_context_tag_t context_tag, 7762 uint32_t list) 7763 { 7764 static const xcb_protocol_request_t xcb_req = { 7765 .count = 2, 7766 .ext = &xcb_glx_id, 7767 .opcode = XCB_GLX_IS_LIST, 7768 .isvoid = 0 7769 }; 7770 7771 struct iovec xcb_parts[4]; 7772 xcb_glx_is_list_cookie_t xcb_ret; 7773 xcb_glx_is_list_request_t xcb_out; 7774 7775 xcb_out.context_tag = context_tag; 7776 xcb_out.list = list; 7777 7778 xcb_parts[2].iov_base = (char *) &xcb_out; 7779 xcb_parts[2].iov_len = sizeof(xcb_out); 7780 xcb_parts[3].iov_base = 0; 7781 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7782 7783 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7784 return xcb_ret; 7785 } 7786 7787 xcb_glx_is_list_cookie_t 7788 xcb_glx_is_list_unchecked (xcb_connection_t *c, 7789 xcb_glx_context_tag_t context_tag, 7790 uint32_t list) 7791 { 7792 static const xcb_protocol_request_t xcb_req = { 7793 .count = 2, 7794 .ext = &xcb_glx_id, 7795 .opcode = XCB_GLX_IS_LIST, 7796 .isvoid = 0 7797 }; 7798 7799 struct iovec xcb_parts[4]; 7800 xcb_glx_is_list_cookie_t xcb_ret; 7801 xcb_glx_is_list_request_t xcb_out; 7802 7803 xcb_out.context_tag = context_tag; 7804 xcb_out.list = list; 7805 7806 xcb_parts[2].iov_base = (char *) &xcb_out; 7807 xcb_parts[2].iov_len = sizeof(xcb_out); 7808 xcb_parts[3].iov_base = 0; 7809 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7810 7811 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7812 return xcb_ret; 7813 } 7814 7815 xcb_glx_is_list_reply_t * 7816 xcb_glx_is_list_reply (xcb_connection_t *c, 7817 xcb_glx_is_list_cookie_t cookie /**< */, 7818 xcb_generic_error_t **e) 7819 { 7820 return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7821 } 7822 7823 xcb_void_cookie_t 7824 xcb_glx_flush_checked (xcb_connection_t *c, 7825 xcb_glx_context_tag_t context_tag) 7826 { 7827 static const xcb_protocol_request_t xcb_req = { 7828 .count = 2, 7829 .ext = &xcb_glx_id, 7830 .opcode = XCB_GLX_FLUSH, 7831 .isvoid = 1 7832 }; 7833 7834 struct iovec xcb_parts[4]; 7835 xcb_void_cookie_t xcb_ret; 7836 xcb_glx_flush_request_t xcb_out; 7837 7838 xcb_out.context_tag = context_tag; 7839 7840 xcb_parts[2].iov_base = (char *) &xcb_out; 7841 xcb_parts[2].iov_len = sizeof(xcb_out); 7842 xcb_parts[3].iov_base = 0; 7843 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7844 7845 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7846 return xcb_ret; 7847 } 7848 7849 xcb_void_cookie_t 7850 xcb_glx_flush (xcb_connection_t *c, 7851 xcb_glx_context_tag_t context_tag) 7852 { 7853 static const xcb_protocol_request_t xcb_req = { 7854 .count = 2, 7855 .ext = &xcb_glx_id, 7856 .opcode = XCB_GLX_FLUSH, 7857 .isvoid = 1 7858 }; 7859 7860 struct iovec xcb_parts[4]; 7861 xcb_void_cookie_t xcb_ret; 7862 xcb_glx_flush_request_t xcb_out; 7863 7864 xcb_out.context_tag = context_tag; 7865 7866 xcb_parts[2].iov_base = (char *) &xcb_out; 7867 xcb_parts[2].iov_len = sizeof(xcb_out); 7868 xcb_parts[3].iov_base = 0; 7869 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7870 7871 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7872 return xcb_ret; 7873 } 7874 7875 int 7876 xcb_glx_are_textures_resident_sizeof (const void *_buffer) 7877 { 7878 char *xcb_tmp = (char *)_buffer; 7879 const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer; 7880 unsigned int xcb_buffer_len = 0; 7881 unsigned int xcb_block_len = 0; 7882 unsigned int xcb_pad = 0; 7883 unsigned int xcb_align_to = 0; 7884 7885 7886 xcb_block_len += sizeof(xcb_glx_are_textures_resident_request_t); 7887 xcb_tmp += xcb_block_len; 7888 xcb_buffer_len += xcb_block_len; 7889 xcb_block_len = 0; 7890 /* textures */ 7891 xcb_block_len += _aux->n * sizeof(uint32_t); 7892 xcb_tmp += xcb_block_len; 7893 xcb_align_to = ALIGNOF(uint32_t); 7894 /* insert padding */ 7895 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7896 xcb_buffer_len += xcb_block_len + xcb_pad; 7897 if (0 != xcb_pad) { 7898 xcb_tmp += xcb_pad; 7899 xcb_pad = 0; 7900 } 7901 xcb_block_len = 0; 7902 7903 return xcb_buffer_len; 7904 } 7905 7906 xcb_glx_are_textures_resident_cookie_t 7907 xcb_glx_are_textures_resident (xcb_connection_t *c, 7908 xcb_glx_context_tag_t context_tag, 7909 int32_t n, 7910 const uint32_t *textures) 7911 { 7912 static const xcb_protocol_request_t xcb_req = { 7913 .count = 4, 7914 .ext = &xcb_glx_id, 7915 .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, 7916 .isvoid = 0 7917 }; 7918 7919 struct iovec xcb_parts[6]; 7920 xcb_glx_are_textures_resident_cookie_t xcb_ret; 7921 xcb_glx_are_textures_resident_request_t xcb_out; 7922 7923 xcb_out.context_tag = context_tag; 7924 xcb_out.n = n; 7925 7926 xcb_parts[2].iov_base = (char *) &xcb_out; 7927 xcb_parts[2].iov_len = sizeof(xcb_out); 7928 xcb_parts[3].iov_base = 0; 7929 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7930 /* uint32_t textures */ 7931 xcb_parts[4].iov_base = (char *) textures; 7932 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 7933 xcb_parts[5].iov_base = 0; 7934 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7935 7936 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7937 return xcb_ret; 7938 } 7939 7940 xcb_glx_are_textures_resident_cookie_t 7941 xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c, 7942 xcb_glx_context_tag_t context_tag, 7943 int32_t n, 7944 const uint32_t *textures) 7945 { 7946 static const xcb_protocol_request_t xcb_req = { 7947 .count = 4, 7948 .ext = &xcb_glx_id, 7949 .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, 7950 .isvoid = 0 7951 }; 7952 7953 struct iovec xcb_parts[6]; 7954 xcb_glx_are_textures_resident_cookie_t xcb_ret; 7955 xcb_glx_are_textures_resident_request_t xcb_out; 7956 7957 xcb_out.context_tag = context_tag; 7958 xcb_out.n = n; 7959 7960 xcb_parts[2].iov_base = (char *) &xcb_out; 7961 xcb_parts[2].iov_len = sizeof(xcb_out); 7962 xcb_parts[3].iov_base = 0; 7963 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7964 /* uint32_t textures */ 7965 xcb_parts[4].iov_base = (char *) textures; 7966 xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t); 7967 xcb_parts[5].iov_base = 0; 7968 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7969 7970 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7971 return xcb_ret; 7972 } 7973 7974 uint8_t * 7975 xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R) 7976 { 7977 return (uint8_t *) (R + 1); 7978 } 7979 7980 int 7981 xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R) 7982 { 7983 return (R->length * 4); 7984 } 7985 7986 xcb_generic_iterator_t 7987 xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R) 7988 { 7989 xcb_generic_iterator_t i; 7990 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 7991 i.rem = 0; 7992 i.index = (char *) i.data - (char *) R; 7993 return i; 7994 } 7995 7996 xcb_glx_are_textures_resident_reply_t * 7997 xcb_glx_are_textures_resident_reply (xcb_connection_t *c, 7998 xcb_glx_are_textures_resident_cookie_t cookie /**< */, 7999 xcb_generic_error_t **e) 8000 { 8001 return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8002 } 8003 8004 int 8005 xcb_glx_delete_textures_sizeof (const void *_buffer) 8006 { 8007 char *xcb_tmp = (char *)_buffer; 8008 const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer; 8009 unsigned int xcb_buffer_len = 0; 8010 unsigned int xcb_block_len = 0; 8011 unsigned int xcb_pad = 0; 8012 unsigned int xcb_align_to = 0; 8013 8014 8015 xcb_block_len += sizeof(xcb_glx_delete_textures_request_t); 8016 xcb_tmp += xcb_block_len; 8017 xcb_buffer_len += xcb_block_len; 8018 xcb_block_len = 0; 8019 /* textures */ 8020 xcb_block_len += _aux->n * sizeof(uint32_t); 8021 xcb_tmp += xcb_block_len; 8022 xcb_align_to = ALIGNOF(uint32_t); 8023 /* insert padding */ 8024 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8025 xcb_buffer_len += xcb_block_len + xcb_pad; 8026 if (0 != xcb_pad) { 8027 xcb_tmp += xcb_pad; 8028 xcb_pad = 0; 8029 } 8030 xcb_block_len = 0; 8031 8032 return xcb_buffer_len; 8033 } 8034 8035 xcb_void_cookie_t 8036 xcb_glx_delete_textures_checked (xcb_connection_t *c, 8037 xcb_glx_context_tag_t context_tag, 8038 int32_t n, 8039 const uint32_t *textures) 8040 { 8041 static const xcb_protocol_request_t xcb_req = { 8042 .count = 4, 8043 .ext = &xcb_glx_id, 8044 .opcode = XCB_GLX_DELETE_TEXTURES, 8045 .isvoid = 1 8046 }; 8047 8048 struct iovec xcb_parts[6]; 8049 xcb_void_cookie_t xcb_ret; 8050 xcb_glx_delete_textures_request_t xcb_out; 8051 8052 xcb_out.context_tag = context_tag; 8053 xcb_out.n = n; 8054 8055 xcb_parts[2].iov_base = (char *) &xcb_out; 8056 xcb_parts[2].iov_len = sizeof(xcb_out); 8057 xcb_parts[3].iov_base = 0; 8058 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8059 /* uint32_t textures */ 8060 xcb_parts[4].iov_base = (char *) textures; 8061 xcb_parts[4].iov_len = n * sizeof(uint32_t); 8062 xcb_parts[5].iov_base = 0; 8063 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8064 8065 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8066 return xcb_ret; 8067 } 8068 8069 xcb_void_cookie_t 8070 xcb_glx_delete_textures (xcb_connection_t *c, 8071 xcb_glx_context_tag_t context_tag, 8072 int32_t n, 8073 const uint32_t *textures) 8074 { 8075 static const xcb_protocol_request_t xcb_req = { 8076 .count = 4, 8077 .ext = &xcb_glx_id, 8078 .opcode = XCB_GLX_DELETE_TEXTURES, 8079 .isvoid = 1 8080 }; 8081 8082 struct iovec xcb_parts[6]; 8083 xcb_void_cookie_t xcb_ret; 8084 xcb_glx_delete_textures_request_t xcb_out; 8085 8086 xcb_out.context_tag = context_tag; 8087 xcb_out.n = n; 8088 8089 xcb_parts[2].iov_base = (char *) &xcb_out; 8090 xcb_parts[2].iov_len = sizeof(xcb_out); 8091 xcb_parts[3].iov_base = 0; 8092 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8093 /* uint32_t textures */ 8094 xcb_parts[4].iov_base = (char *) textures; 8095 xcb_parts[4].iov_len = n * sizeof(uint32_t); 8096 xcb_parts[5].iov_base = 0; 8097 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8098 8099 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8100 return xcb_ret; 8101 } 8102 8103 uint32_t * 8104 xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R) 8105 { 8106 return (uint32_t *) (R + 1); 8107 } 8108 8109 int 8110 xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R) 8111 { 8112 return R->n; 8113 } 8114 8115 xcb_generic_iterator_t 8116 xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R) 8117 { 8118 xcb_generic_iterator_t i; 8119 i.data = ((uint32_t *) (R + 1)) + (R->n); 8120 i.rem = 0; 8121 i.index = (char *) i.data - (char *) R; 8122 return i; 8123 } 8124 8125 int 8126 xcb_glx_gen_textures_sizeof (const void *_buffer) 8127 { 8128 char *xcb_tmp = (char *)_buffer; 8129 const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer; 8130 unsigned int xcb_buffer_len = 0; 8131 unsigned int xcb_block_len = 0; 8132 unsigned int xcb_pad = 0; 8133 unsigned int xcb_align_to = 0; 8134 8135 8136 xcb_block_len += sizeof(xcb_glx_gen_textures_reply_t); 8137 xcb_tmp += xcb_block_len; 8138 xcb_buffer_len += xcb_block_len; 8139 xcb_block_len = 0; 8140 /* data */ 8141 xcb_block_len += _aux->length * sizeof(uint32_t); 8142 xcb_tmp += xcb_block_len; 8143 xcb_align_to = ALIGNOF(uint32_t); 8144 /* insert padding */ 8145 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8146 xcb_buffer_len += xcb_block_len + xcb_pad; 8147 if (0 != xcb_pad) { 8148 xcb_tmp += xcb_pad; 8149 xcb_pad = 0; 8150 } 8151 xcb_block_len = 0; 8152 8153 return xcb_buffer_len; 8154 } 8155 8156 xcb_glx_gen_textures_cookie_t 8157 xcb_glx_gen_textures (xcb_connection_t *c, 8158 xcb_glx_context_tag_t context_tag, 8159 int32_t n) 8160 { 8161 static const xcb_protocol_request_t xcb_req = { 8162 .count = 2, 8163 .ext = &xcb_glx_id, 8164 .opcode = XCB_GLX_GEN_TEXTURES, 8165 .isvoid = 0 8166 }; 8167 8168 struct iovec xcb_parts[4]; 8169 xcb_glx_gen_textures_cookie_t xcb_ret; 8170 xcb_glx_gen_textures_request_t xcb_out; 8171 8172 xcb_out.context_tag = context_tag; 8173 xcb_out.n = n; 8174 8175 xcb_parts[2].iov_base = (char *) &xcb_out; 8176 xcb_parts[2].iov_len = sizeof(xcb_out); 8177 xcb_parts[3].iov_base = 0; 8178 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8179 8180 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8181 return xcb_ret; 8182 } 8183 8184 xcb_glx_gen_textures_cookie_t 8185 xcb_glx_gen_textures_unchecked (xcb_connection_t *c, 8186 xcb_glx_context_tag_t context_tag, 8187 int32_t n) 8188 { 8189 static const xcb_protocol_request_t xcb_req = { 8190 .count = 2, 8191 .ext = &xcb_glx_id, 8192 .opcode = XCB_GLX_GEN_TEXTURES, 8193 .isvoid = 0 8194 }; 8195 8196 struct iovec xcb_parts[4]; 8197 xcb_glx_gen_textures_cookie_t xcb_ret; 8198 xcb_glx_gen_textures_request_t xcb_out; 8199 8200 xcb_out.context_tag = context_tag; 8201 xcb_out.n = n; 8202 8203 xcb_parts[2].iov_base = (char *) &xcb_out; 8204 xcb_parts[2].iov_len = sizeof(xcb_out); 8205 xcb_parts[3].iov_base = 0; 8206 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8207 8208 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8209 return xcb_ret; 8210 } 8211 8212 uint32_t * 8213 xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R) 8214 { 8215 return (uint32_t *) (R + 1); 8216 } 8217 8218 int 8219 xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R) 8220 { 8221 return R->length; 8222 } 8223 8224 xcb_generic_iterator_t 8225 xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R) 8226 { 8227 xcb_generic_iterator_t i; 8228 i.data = ((uint32_t *) (R + 1)) + (R->length); 8229 i.rem = 0; 8230 i.index = (char *) i.data - (char *) R; 8231 return i; 8232 } 8233 8234 xcb_glx_gen_textures_reply_t * 8235 xcb_glx_gen_textures_reply (xcb_connection_t *c, 8236 xcb_glx_gen_textures_cookie_t cookie /**< */, 8237 xcb_generic_error_t **e) 8238 { 8239 return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8240 } 8241 8242 xcb_glx_is_texture_cookie_t 8243 xcb_glx_is_texture (xcb_connection_t *c, 8244 xcb_glx_context_tag_t context_tag, 8245 uint32_t texture) 8246 { 8247 static const xcb_protocol_request_t xcb_req = { 8248 .count = 2, 8249 .ext = &xcb_glx_id, 8250 .opcode = XCB_GLX_IS_TEXTURE, 8251 .isvoid = 0 8252 }; 8253 8254 struct iovec xcb_parts[4]; 8255 xcb_glx_is_texture_cookie_t xcb_ret; 8256 xcb_glx_is_texture_request_t xcb_out; 8257 8258 xcb_out.context_tag = context_tag; 8259 xcb_out.texture = texture; 8260 8261 xcb_parts[2].iov_base = (char *) &xcb_out; 8262 xcb_parts[2].iov_len = sizeof(xcb_out); 8263 xcb_parts[3].iov_base = 0; 8264 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8265 8266 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8267 return xcb_ret; 8268 } 8269 8270 xcb_glx_is_texture_cookie_t 8271 xcb_glx_is_texture_unchecked (xcb_connection_t *c, 8272 xcb_glx_context_tag_t context_tag, 8273 uint32_t texture) 8274 { 8275 static const xcb_protocol_request_t xcb_req = { 8276 .count = 2, 8277 .ext = &xcb_glx_id, 8278 .opcode = XCB_GLX_IS_TEXTURE, 8279 .isvoid = 0 8280 }; 8281 8282 struct iovec xcb_parts[4]; 8283 xcb_glx_is_texture_cookie_t xcb_ret; 8284 xcb_glx_is_texture_request_t xcb_out; 8285 8286 xcb_out.context_tag = context_tag; 8287 xcb_out.texture = texture; 8288 8289 xcb_parts[2].iov_base = (char *) &xcb_out; 8290 xcb_parts[2].iov_len = sizeof(xcb_out); 8291 xcb_parts[3].iov_base = 0; 8292 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8293 8294 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8295 return xcb_ret; 8296 } 8297 8298 xcb_glx_is_texture_reply_t * 8299 xcb_glx_is_texture_reply (xcb_connection_t *c, 8300 xcb_glx_is_texture_cookie_t cookie /**< */, 8301 xcb_generic_error_t **e) 8302 { 8303 return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8304 } 8305 8306 int 8307 xcb_glx_get_color_table_sizeof (const void *_buffer) 8308 { 8309 char *xcb_tmp = (char *)_buffer; 8310 const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer; 8311 unsigned int xcb_buffer_len = 0; 8312 unsigned int xcb_block_len = 0; 8313 unsigned int xcb_pad = 0; 8314 unsigned int xcb_align_to = 0; 8315 8316 8317 xcb_block_len += sizeof(xcb_glx_get_color_table_reply_t); 8318 xcb_tmp += xcb_block_len; 8319 xcb_buffer_len += xcb_block_len; 8320 xcb_block_len = 0; 8321 /* data */ 8322 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8323 xcb_tmp += xcb_block_len; 8324 xcb_align_to = ALIGNOF(uint8_t); 8325 /* insert padding */ 8326 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8327 xcb_buffer_len += xcb_block_len + xcb_pad; 8328 if (0 != xcb_pad) { 8329 xcb_tmp += xcb_pad; 8330 xcb_pad = 0; 8331 } 8332 xcb_block_len = 0; 8333 8334 return xcb_buffer_len; 8335 } 8336 8337 xcb_glx_get_color_table_cookie_t 8338 xcb_glx_get_color_table (xcb_connection_t *c, 8339 xcb_glx_context_tag_t context_tag, 8340 uint32_t target, 8341 uint32_t format, 8342 uint32_t type, 8343 uint8_t swap_bytes) 8344 { 8345 static const xcb_protocol_request_t xcb_req = { 8346 .count = 2, 8347 .ext = &xcb_glx_id, 8348 .opcode = XCB_GLX_GET_COLOR_TABLE, 8349 .isvoid = 0 8350 }; 8351 8352 struct iovec xcb_parts[4]; 8353 xcb_glx_get_color_table_cookie_t xcb_ret; 8354 xcb_glx_get_color_table_request_t xcb_out; 8355 8356 xcb_out.context_tag = context_tag; 8357 xcb_out.target = target; 8358 xcb_out.format = format; 8359 xcb_out.type = type; 8360 xcb_out.swap_bytes = swap_bytes; 8361 8362 xcb_parts[2].iov_base = (char *) &xcb_out; 8363 xcb_parts[2].iov_len = sizeof(xcb_out); 8364 xcb_parts[3].iov_base = 0; 8365 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8366 8367 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8368 return xcb_ret; 8369 } 8370 8371 xcb_glx_get_color_table_cookie_t 8372 xcb_glx_get_color_table_unchecked (xcb_connection_t *c, 8373 xcb_glx_context_tag_t context_tag, 8374 uint32_t target, 8375 uint32_t format, 8376 uint32_t type, 8377 uint8_t swap_bytes) 8378 { 8379 static const xcb_protocol_request_t xcb_req = { 8380 .count = 2, 8381 .ext = &xcb_glx_id, 8382 .opcode = XCB_GLX_GET_COLOR_TABLE, 8383 .isvoid = 0 8384 }; 8385 8386 struct iovec xcb_parts[4]; 8387 xcb_glx_get_color_table_cookie_t xcb_ret; 8388 xcb_glx_get_color_table_request_t xcb_out; 8389 8390 xcb_out.context_tag = context_tag; 8391 xcb_out.target = target; 8392 xcb_out.format = format; 8393 xcb_out.type = type; 8394 xcb_out.swap_bytes = swap_bytes; 8395 8396 xcb_parts[2].iov_base = (char *) &xcb_out; 8397 xcb_parts[2].iov_len = sizeof(xcb_out); 8398 xcb_parts[3].iov_base = 0; 8399 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8400 8401 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8402 return xcb_ret; 8403 } 8404 8405 uint8_t * 8406 xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R) 8407 { 8408 return (uint8_t *) (R + 1); 8409 } 8410 8411 int 8412 xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R) 8413 { 8414 return (R->length * 4); 8415 } 8416 8417 xcb_generic_iterator_t 8418 xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R) 8419 { 8420 xcb_generic_iterator_t i; 8421 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8422 i.rem = 0; 8423 i.index = (char *) i.data - (char *) R; 8424 return i; 8425 } 8426 8427 xcb_glx_get_color_table_reply_t * 8428 xcb_glx_get_color_table_reply (xcb_connection_t *c, 8429 xcb_glx_get_color_table_cookie_t cookie /**< */, 8430 xcb_generic_error_t **e) 8431 { 8432 return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8433 } 8434 8435 int 8436 xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer) 8437 { 8438 char *xcb_tmp = (char *)_buffer; 8439 const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer; 8440 unsigned int xcb_buffer_len = 0; 8441 unsigned int xcb_block_len = 0; 8442 unsigned int xcb_pad = 0; 8443 unsigned int xcb_align_to = 0; 8444 8445 8446 xcb_block_len += sizeof(xcb_glx_get_color_table_parameterfv_reply_t); 8447 xcb_tmp += xcb_block_len; 8448 xcb_buffer_len += xcb_block_len; 8449 xcb_block_len = 0; 8450 /* data */ 8451 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8452 xcb_tmp += xcb_block_len; 8453 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8454 /* insert padding */ 8455 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8456 xcb_buffer_len += xcb_block_len + xcb_pad; 8457 if (0 != xcb_pad) { 8458 xcb_tmp += xcb_pad; 8459 xcb_pad = 0; 8460 } 8461 xcb_block_len = 0; 8462 8463 return xcb_buffer_len; 8464 } 8465 8466 xcb_glx_get_color_table_parameterfv_cookie_t 8467 xcb_glx_get_color_table_parameterfv (xcb_connection_t *c, 8468 xcb_glx_context_tag_t context_tag, 8469 uint32_t target, 8470 uint32_t pname) 8471 { 8472 static const xcb_protocol_request_t xcb_req = { 8473 .count = 2, 8474 .ext = &xcb_glx_id, 8475 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 8476 .isvoid = 0 8477 }; 8478 8479 struct iovec xcb_parts[4]; 8480 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 8481 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 8482 8483 xcb_out.context_tag = context_tag; 8484 xcb_out.target = target; 8485 xcb_out.pname = pname; 8486 8487 xcb_parts[2].iov_base = (char *) &xcb_out; 8488 xcb_parts[2].iov_len = sizeof(xcb_out); 8489 xcb_parts[3].iov_base = 0; 8490 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8491 8492 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8493 return xcb_ret; 8494 } 8495 8496 xcb_glx_get_color_table_parameterfv_cookie_t 8497 xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c, 8498 xcb_glx_context_tag_t context_tag, 8499 uint32_t target, 8500 uint32_t pname) 8501 { 8502 static const xcb_protocol_request_t xcb_req = { 8503 .count = 2, 8504 .ext = &xcb_glx_id, 8505 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, 8506 .isvoid = 0 8507 }; 8508 8509 struct iovec xcb_parts[4]; 8510 xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret; 8511 xcb_glx_get_color_table_parameterfv_request_t xcb_out; 8512 8513 xcb_out.context_tag = context_tag; 8514 xcb_out.target = target; 8515 xcb_out.pname = pname; 8516 8517 xcb_parts[2].iov_base = (char *) &xcb_out; 8518 xcb_parts[2].iov_len = sizeof(xcb_out); 8519 xcb_parts[3].iov_base = 0; 8520 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8521 8522 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8523 return xcb_ret; 8524 } 8525 8526 xcb_glx_float32_t * 8527 xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8528 { 8529 return (xcb_glx_float32_t *) (R + 1); 8530 } 8531 8532 int 8533 xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8534 { 8535 return R->n; 8536 } 8537 8538 xcb_generic_iterator_t 8539 xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R) 8540 { 8541 xcb_generic_iterator_t i; 8542 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8543 i.rem = 0; 8544 i.index = (char *) i.data - (char *) R; 8545 return i; 8546 } 8547 8548 xcb_glx_get_color_table_parameterfv_reply_t * 8549 xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c, 8550 xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, 8551 xcb_generic_error_t **e) 8552 { 8553 return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8554 } 8555 8556 int 8557 xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer) 8558 { 8559 char *xcb_tmp = (char *)_buffer; 8560 const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer; 8561 unsigned int xcb_buffer_len = 0; 8562 unsigned int xcb_block_len = 0; 8563 unsigned int xcb_pad = 0; 8564 unsigned int xcb_align_to = 0; 8565 8566 8567 xcb_block_len += sizeof(xcb_glx_get_color_table_parameteriv_reply_t); 8568 xcb_tmp += xcb_block_len; 8569 xcb_buffer_len += xcb_block_len; 8570 xcb_block_len = 0; 8571 /* data */ 8572 xcb_block_len += _aux->n * sizeof(int32_t); 8573 xcb_tmp += xcb_block_len; 8574 xcb_align_to = ALIGNOF(int32_t); 8575 /* insert padding */ 8576 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8577 xcb_buffer_len += xcb_block_len + xcb_pad; 8578 if (0 != xcb_pad) { 8579 xcb_tmp += xcb_pad; 8580 xcb_pad = 0; 8581 } 8582 xcb_block_len = 0; 8583 8584 return xcb_buffer_len; 8585 } 8586 8587 xcb_glx_get_color_table_parameteriv_cookie_t 8588 xcb_glx_get_color_table_parameteriv (xcb_connection_t *c, 8589 xcb_glx_context_tag_t context_tag, 8590 uint32_t target, 8591 uint32_t pname) 8592 { 8593 static const xcb_protocol_request_t xcb_req = { 8594 .count = 2, 8595 .ext = &xcb_glx_id, 8596 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 8597 .isvoid = 0 8598 }; 8599 8600 struct iovec xcb_parts[4]; 8601 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 8602 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 8603 8604 xcb_out.context_tag = context_tag; 8605 xcb_out.target = target; 8606 xcb_out.pname = pname; 8607 8608 xcb_parts[2].iov_base = (char *) &xcb_out; 8609 xcb_parts[2].iov_len = sizeof(xcb_out); 8610 xcb_parts[3].iov_base = 0; 8611 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8612 8613 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8614 return xcb_ret; 8615 } 8616 8617 xcb_glx_get_color_table_parameteriv_cookie_t 8618 xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c, 8619 xcb_glx_context_tag_t context_tag, 8620 uint32_t target, 8621 uint32_t pname) 8622 { 8623 static const xcb_protocol_request_t xcb_req = { 8624 .count = 2, 8625 .ext = &xcb_glx_id, 8626 .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, 8627 .isvoid = 0 8628 }; 8629 8630 struct iovec xcb_parts[4]; 8631 xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret; 8632 xcb_glx_get_color_table_parameteriv_request_t xcb_out; 8633 8634 xcb_out.context_tag = context_tag; 8635 xcb_out.target = target; 8636 xcb_out.pname = pname; 8637 8638 xcb_parts[2].iov_base = (char *) &xcb_out; 8639 xcb_parts[2].iov_len = sizeof(xcb_out); 8640 xcb_parts[3].iov_base = 0; 8641 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8642 8643 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8644 return xcb_ret; 8645 } 8646 8647 int32_t * 8648 xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8649 { 8650 return (int32_t *) (R + 1); 8651 } 8652 8653 int 8654 xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8655 { 8656 return R->n; 8657 } 8658 8659 xcb_generic_iterator_t 8660 xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R) 8661 { 8662 xcb_generic_iterator_t i; 8663 i.data = ((int32_t *) (R + 1)) + (R->n); 8664 i.rem = 0; 8665 i.index = (char *) i.data - (char *) R; 8666 return i; 8667 } 8668 8669 xcb_glx_get_color_table_parameteriv_reply_t * 8670 xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c, 8671 xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, 8672 xcb_generic_error_t **e) 8673 { 8674 return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8675 } 8676 8677 int 8678 xcb_glx_get_convolution_filter_sizeof (const void *_buffer) 8679 { 8680 char *xcb_tmp = (char *)_buffer; 8681 const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer; 8682 unsigned int xcb_buffer_len = 0; 8683 unsigned int xcb_block_len = 0; 8684 unsigned int xcb_pad = 0; 8685 unsigned int xcb_align_to = 0; 8686 8687 8688 xcb_block_len += sizeof(xcb_glx_get_convolution_filter_reply_t); 8689 xcb_tmp += xcb_block_len; 8690 xcb_buffer_len += xcb_block_len; 8691 xcb_block_len = 0; 8692 /* data */ 8693 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 8694 xcb_tmp += xcb_block_len; 8695 xcb_align_to = ALIGNOF(uint8_t); 8696 /* insert padding */ 8697 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8698 xcb_buffer_len += xcb_block_len + xcb_pad; 8699 if (0 != xcb_pad) { 8700 xcb_tmp += xcb_pad; 8701 xcb_pad = 0; 8702 } 8703 xcb_block_len = 0; 8704 8705 return xcb_buffer_len; 8706 } 8707 8708 xcb_glx_get_convolution_filter_cookie_t 8709 xcb_glx_get_convolution_filter (xcb_connection_t *c, 8710 xcb_glx_context_tag_t context_tag, 8711 uint32_t target, 8712 uint32_t format, 8713 uint32_t type, 8714 uint8_t swap_bytes) 8715 { 8716 static const xcb_protocol_request_t xcb_req = { 8717 .count = 2, 8718 .ext = &xcb_glx_id, 8719 .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, 8720 .isvoid = 0 8721 }; 8722 8723 struct iovec xcb_parts[4]; 8724 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 8725 xcb_glx_get_convolution_filter_request_t xcb_out; 8726 8727 xcb_out.context_tag = context_tag; 8728 xcb_out.target = target; 8729 xcb_out.format = format; 8730 xcb_out.type = type; 8731 xcb_out.swap_bytes = swap_bytes; 8732 8733 xcb_parts[2].iov_base = (char *) &xcb_out; 8734 xcb_parts[2].iov_len = sizeof(xcb_out); 8735 xcb_parts[3].iov_base = 0; 8736 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8737 8738 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8739 return xcb_ret; 8740 } 8741 8742 xcb_glx_get_convolution_filter_cookie_t 8743 xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c, 8744 xcb_glx_context_tag_t context_tag, 8745 uint32_t target, 8746 uint32_t format, 8747 uint32_t type, 8748 uint8_t swap_bytes) 8749 { 8750 static const xcb_protocol_request_t xcb_req = { 8751 .count = 2, 8752 .ext = &xcb_glx_id, 8753 .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, 8754 .isvoid = 0 8755 }; 8756 8757 struct iovec xcb_parts[4]; 8758 xcb_glx_get_convolution_filter_cookie_t xcb_ret; 8759 xcb_glx_get_convolution_filter_request_t xcb_out; 8760 8761 xcb_out.context_tag = context_tag; 8762 xcb_out.target = target; 8763 xcb_out.format = format; 8764 xcb_out.type = type; 8765 xcb_out.swap_bytes = swap_bytes; 8766 8767 xcb_parts[2].iov_base = (char *) &xcb_out; 8768 xcb_parts[2].iov_len = sizeof(xcb_out); 8769 xcb_parts[3].iov_base = 0; 8770 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8771 8772 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8773 return xcb_ret; 8774 } 8775 8776 uint8_t * 8777 xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R) 8778 { 8779 return (uint8_t *) (R + 1); 8780 } 8781 8782 int 8783 xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R) 8784 { 8785 return (R->length * 4); 8786 } 8787 8788 xcb_generic_iterator_t 8789 xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R) 8790 { 8791 xcb_generic_iterator_t i; 8792 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 8793 i.rem = 0; 8794 i.index = (char *) i.data - (char *) R; 8795 return i; 8796 } 8797 8798 xcb_glx_get_convolution_filter_reply_t * 8799 xcb_glx_get_convolution_filter_reply (xcb_connection_t *c, 8800 xcb_glx_get_convolution_filter_cookie_t cookie /**< */, 8801 xcb_generic_error_t **e) 8802 { 8803 return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8804 } 8805 8806 int 8807 xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer) 8808 { 8809 char *xcb_tmp = (char *)_buffer; 8810 const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer; 8811 unsigned int xcb_buffer_len = 0; 8812 unsigned int xcb_block_len = 0; 8813 unsigned int xcb_pad = 0; 8814 unsigned int xcb_align_to = 0; 8815 8816 8817 xcb_block_len += sizeof(xcb_glx_get_convolution_parameterfv_reply_t); 8818 xcb_tmp += xcb_block_len; 8819 xcb_buffer_len += xcb_block_len; 8820 xcb_block_len = 0; 8821 /* data */ 8822 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 8823 xcb_tmp += xcb_block_len; 8824 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 8825 /* insert padding */ 8826 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8827 xcb_buffer_len += xcb_block_len + xcb_pad; 8828 if (0 != xcb_pad) { 8829 xcb_tmp += xcb_pad; 8830 xcb_pad = 0; 8831 } 8832 xcb_block_len = 0; 8833 8834 return xcb_buffer_len; 8835 } 8836 8837 xcb_glx_get_convolution_parameterfv_cookie_t 8838 xcb_glx_get_convolution_parameterfv (xcb_connection_t *c, 8839 xcb_glx_context_tag_t context_tag, 8840 uint32_t target, 8841 uint32_t pname) 8842 { 8843 static const xcb_protocol_request_t xcb_req = { 8844 .count = 2, 8845 .ext = &xcb_glx_id, 8846 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 8847 .isvoid = 0 8848 }; 8849 8850 struct iovec xcb_parts[4]; 8851 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 8852 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 8853 8854 xcb_out.context_tag = context_tag; 8855 xcb_out.target = target; 8856 xcb_out.pname = pname; 8857 8858 xcb_parts[2].iov_base = (char *) &xcb_out; 8859 xcb_parts[2].iov_len = sizeof(xcb_out); 8860 xcb_parts[3].iov_base = 0; 8861 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8862 8863 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8864 return xcb_ret; 8865 } 8866 8867 xcb_glx_get_convolution_parameterfv_cookie_t 8868 xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c, 8869 xcb_glx_context_tag_t context_tag, 8870 uint32_t target, 8871 uint32_t pname) 8872 { 8873 static const xcb_protocol_request_t xcb_req = { 8874 .count = 2, 8875 .ext = &xcb_glx_id, 8876 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, 8877 .isvoid = 0 8878 }; 8879 8880 struct iovec xcb_parts[4]; 8881 xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret; 8882 xcb_glx_get_convolution_parameterfv_request_t xcb_out; 8883 8884 xcb_out.context_tag = context_tag; 8885 xcb_out.target = target; 8886 xcb_out.pname = pname; 8887 8888 xcb_parts[2].iov_base = (char *) &xcb_out; 8889 xcb_parts[2].iov_len = sizeof(xcb_out); 8890 xcb_parts[3].iov_base = 0; 8891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8892 8893 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8894 return xcb_ret; 8895 } 8896 8897 xcb_glx_float32_t * 8898 xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8899 { 8900 return (xcb_glx_float32_t *) (R + 1); 8901 } 8902 8903 int 8904 xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8905 { 8906 return R->n; 8907 } 8908 8909 xcb_generic_iterator_t 8910 xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R) 8911 { 8912 xcb_generic_iterator_t i; 8913 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 8914 i.rem = 0; 8915 i.index = (char *) i.data - (char *) R; 8916 return i; 8917 } 8918 8919 xcb_glx_get_convolution_parameterfv_reply_t * 8920 xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c, 8921 xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, 8922 xcb_generic_error_t **e) 8923 { 8924 return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8925 } 8926 8927 int 8928 xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer) 8929 { 8930 char *xcb_tmp = (char *)_buffer; 8931 const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer; 8932 unsigned int xcb_buffer_len = 0; 8933 unsigned int xcb_block_len = 0; 8934 unsigned int xcb_pad = 0; 8935 unsigned int xcb_align_to = 0; 8936 8937 8938 xcb_block_len += sizeof(xcb_glx_get_convolution_parameteriv_reply_t); 8939 xcb_tmp += xcb_block_len; 8940 xcb_buffer_len += xcb_block_len; 8941 xcb_block_len = 0; 8942 /* data */ 8943 xcb_block_len += _aux->n * sizeof(int32_t); 8944 xcb_tmp += xcb_block_len; 8945 xcb_align_to = ALIGNOF(int32_t); 8946 /* insert padding */ 8947 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8948 xcb_buffer_len += xcb_block_len + xcb_pad; 8949 if (0 != xcb_pad) { 8950 xcb_tmp += xcb_pad; 8951 xcb_pad = 0; 8952 } 8953 xcb_block_len = 0; 8954 8955 return xcb_buffer_len; 8956 } 8957 8958 xcb_glx_get_convolution_parameteriv_cookie_t 8959 xcb_glx_get_convolution_parameteriv (xcb_connection_t *c, 8960 xcb_glx_context_tag_t context_tag, 8961 uint32_t target, 8962 uint32_t pname) 8963 { 8964 static const xcb_protocol_request_t xcb_req = { 8965 .count = 2, 8966 .ext = &xcb_glx_id, 8967 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 8968 .isvoid = 0 8969 }; 8970 8971 struct iovec xcb_parts[4]; 8972 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 8973 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 8974 8975 xcb_out.context_tag = context_tag; 8976 xcb_out.target = target; 8977 xcb_out.pname = pname; 8978 8979 xcb_parts[2].iov_base = (char *) &xcb_out; 8980 xcb_parts[2].iov_len = sizeof(xcb_out); 8981 xcb_parts[3].iov_base = 0; 8982 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8983 8984 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8985 return xcb_ret; 8986 } 8987 8988 xcb_glx_get_convolution_parameteriv_cookie_t 8989 xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c, 8990 xcb_glx_context_tag_t context_tag, 8991 uint32_t target, 8992 uint32_t pname) 8993 { 8994 static const xcb_protocol_request_t xcb_req = { 8995 .count = 2, 8996 .ext = &xcb_glx_id, 8997 .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, 8998 .isvoid = 0 8999 }; 9000 9001 struct iovec xcb_parts[4]; 9002 xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret; 9003 xcb_glx_get_convolution_parameteriv_request_t xcb_out; 9004 9005 xcb_out.context_tag = context_tag; 9006 xcb_out.target = target; 9007 xcb_out.pname = pname; 9008 9009 xcb_parts[2].iov_base = (char *) &xcb_out; 9010 xcb_parts[2].iov_len = sizeof(xcb_out); 9011 xcb_parts[3].iov_base = 0; 9012 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9013 9014 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9015 return xcb_ret; 9016 } 9017 9018 int32_t * 9019 xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9020 { 9021 return (int32_t *) (R + 1); 9022 } 9023 9024 int 9025 xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9026 { 9027 return R->n; 9028 } 9029 9030 xcb_generic_iterator_t 9031 xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R) 9032 { 9033 xcb_generic_iterator_t i; 9034 i.data = ((int32_t *) (R + 1)) + (R->n); 9035 i.rem = 0; 9036 i.index = (char *) i.data - (char *) R; 9037 return i; 9038 } 9039 9040 xcb_glx_get_convolution_parameteriv_reply_t * 9041 xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c, 9042 xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, 9043 xcb_generic_error_t **e) 9044 { 9045 return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9046 } 9047 9048 int 9049 xcb_glx_get_separable_filter_sizeof (const void *_buffer) 9050 { 9051 char *xcb_tmp = (char *)_buffer; 9052 const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer; 9053 unsigned int xcb_buffer_len = 0; 9054 unsigned int xcb_block_len = 0; 9055 unsigned int xcb_pad = 0; 9056 unsigned int xcb_align_to = 0; 9057 9058 9059 xcb_block_len += sizeof(xcb_glx_get_separable_filter_reply_t); 9060 xcb_tmp += xcb_block_len; 9061 xcb_buffer_len += xcb_block_len; 9062 xcb_block_len = 0; 9063 /* rows_and_cols */ 9064 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9065 xcb_tmp += xcb_block_len; 9066 xcb_align_to = ALIGNOF(uint8_t); 9067 /* insert padding */ 9068 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9069 xcb_buffer_len += xcb_block_len + xcb_pad; 9070 if (0 != xcb_pad) { 9071 xcb_tmp += xcb_pad; 9072 xcb_pad = 0; 9073 } 9074 xcb_block_len = 0; 9075 9076 return xcb_buffer_len; 9077 } 9078 9079 xcb_glx_get_separable_filter_cookie_t 9080 xcb_glx_get_separable_filter (xcb_connection_t *c, 9081 xcb_glx_context_tag_t context_tag, 9082 uint32_t target, 9083 uint32_t format, 9084 uint32_t type, 9085 uint8_t swap_bytes) 9086 { 9087 static const xcb_protocol_request_t xcb_req = { 9088 .count = 2, 9089 .ext = &xcb_glx_id, 9090 .opcode = XCB_GLX_GET_SEPARABLE_FILTER, 9091 .isvoid = 0 9092 }; 9093 9094 struct iovec xcb_parts[4]; 9095 xcb_glx_get_separable_filter_cookie_t xcb_ret; 9096 xcb_glx_get_separable_filter_request_t xcb_out; 9097 9098 xcb_out.context_tag = context_tag; 9099 xcb_out.target = target; 9100 xcb_out.format = format; 9101 xcb_out.type = type; 9102 xcb_out.swap_bytes = swap_bytes; 9103 9104 xcb_parts[2].iov_base = (char *) &xcb_out; 9105 xcb_parts[2].iov_len = sizeof(xcb_out); 9106 xcb_parts[3].iov_base = 0; 9107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9108 9109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9110 return xcb_ret; 9111 } 9112 9113 xcb_glx_get_separable_filter_cookie_t 9114 xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c, 9115 xcb_glx_context_tag_t context_tag, 9116 uint32_t target, 9117 uint32_t format, 9118 uint32_t type, 9119 uint8_t swap_bytes) 9120 { 9121 static const xcb_protocol_request_t xcb_req = { 9122 .count = 2, 9123 .ext = &xcb_glx_id, 9124 .opcode = XCB_GLX_GET_SEPARABLE_FILTER, 9125 .isvoid = 0 9126 }; 9127 9128 struct iovec xcb_parts[4]; 9129 xcb_glx_get_separable_filter_cookie_t xcb_ret; 9130 xcb_glx_get_separable_filter_request_t xcb_out; 9131 9132 xcb_out.context_tag = context_tag; 9133 xcb_out.target = target; 9134 xcb_out.format = format; 9135 xcb_out.type = type; 9136 xcb_out.swap_bytes = swap_bytes; 9137 9138 xcb_parts[2].iov_base = (char *) &xcb_out; 9139 xcb_parts[2].iov_len = sizeof(xcb_out); 9140 xcb_parts[3].iov_base = 0; 9141 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9142 9143 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9144 return xcb_ret; 9145 } 9146 9147 uint8_t * 9148 xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R) 9149 { 9150 return (uint8_t *) (R + 1); 9151 } 9152 9153 int 9154 xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R) 9155 { 9156 return (R->length * 4); 9157 } 9158 9159 xcb_generic_iterator_t 9160 xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R) 9161 { 9162 xcb_generic_iterator_t i; 9163 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9164 i.rem = 0; 9165 i.index = (char *) i.data - (char *) R; 9166 return i; 9167 } 9168 9169 xcb_glx_get_separable_filter_reply_t * 9170 xcb_glx_get_separable_filter_reply (xcb_connection_t *c, 9171 xcb_glx_get_separable_filter_cookie_t cookie /**< */, 9172 xcb_generic_error_t **e) 9173 { 9174 return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9175 } 9176 9177 int 9178 xcb_glx_get_histogram_sizeof (const void *_buffer) 9179 { 9180 char *xcb_tmp = (char *)_buffer; 9181 const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer; 9182 unsigned int xcb_buffer_len = 0; 9183 unsigned int xcb_block_len = 0; 9184 unsigned int xcb_pad = 0; 9185 unsigned int xcb_align_to = 0; 9186 9187 9188 xcb_block_len += sizeof(xcb_glx_get_histogram_reply_t); 9189 xcb_tmp += xcb_block_len; 9190 xcb_buffer_len += xcb_block_len; 9191 xcb_block_len = 0; 9192 /* data */ 9193 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9194 xcb_tmp += xcb_block_len; 9195 xcb_align_to = ALIGNOF(uint8_t); 9196 /* insert padding */ 9197 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9198 xcb_buffer_len += xcb_block_len + xcb_pad; 9199 if (0 != xcb_pad) { 9200 xcb_tmp += xcb_pad; 9201 xcb_pad = 0; 9202 } 9203 xcb_block_len = 0; 9204 9205 return xcb_buffer_len; 9206 } 9207 9208 xcb_glx_get_histogram_cookie_t 9209 xcb_glx_get_histogram (xcb_connection_t *c, 9210 xcb_glx_context_tag_t context_tag, 9211 uint32_t target, 9212 uint32_t format, 9213 uint32_t type, 9214 uint8_t swap_bytes, 9215 uint8_t reset) 9216 { 9217 static const xcb_protocol_request_t xcb_req = { 9218 .count = 2, 9219 .ext = &xcb_glx_id, 9220 .opcode = XCB_GLX_GET_HISTOGRAM, 9221 .isvoid = 0 9222 }; 9223 9224 struct iovec xcb_parts[4]; 9225 xcb_glx_get_histogram_cookie_t xcb_ret; 9226 xcb_glx_get_histogram_request_t xcb_out; 9227 9228 xcb_out.context_tag = context_tag; 9229 xcb_out.target = target; 9230 xcb_out.format = format; 9231 xcb_out.type = type; 9232 xcb_out.swap_bytes = swap_bytes; 9233 xcb_out.reset = reset; 9234 9235 xcb_parts[2].iov_base = (char *) &xcb_out; 9236 xcb_parts[2].iov_len = sizeof(xcb_out); 9237 xcb_parts[3].iov_base = 0; 9238 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9239 9240 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9241 return xcb_ret; 9242 } 9243 9244 xcb_glx_get_histogram_cookie_t 9245 xcb_glx_get_histogram_unchecked (xcb_connection_t *c, 9246 xcb_glx_context_tag_t context_tag, 9247 uint32_t target, 9248 uint32_t format, 9249 uint32_t type, 9250 uint8_t swap_bytes, 9251 uint8_t reset) 9252 { 9253 static const xcb_protocol_request_t xcb_req = { 9254 .count = 2, 9255 .ext = &xcb_glx_id, 9256 .opcode = XCB_GLX_GET_HISTOGRAM, 9257 .isvoid = 0 9258 }; 9259 9260 struct iovec xcb_parts[4]; 9261 xcb_glx_get_histogram_cookie_t xcb_ret; 9262 xcb_glx_get_histogram_request_t xcb_out; 9263 9264 xcb_out.context_tag = context_tag; 9265 xcb_out.target = target; 9266 xcb_out.format = format; 9267 xcb_out.type = type; 9268 xcb_out.swap_bytes = swap_bytes; 9269 xcb_out.reset = reset; 9270 9271 xcb_parts[2].iov_base = (char *) &xcb_out; 9272 xcb_parts[2].iov_len = sizeof(xcb_out); 9273 xcb_parts[3].iov_base = 0; 9274 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9275 9276 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9277 return xcb_ret; 9278 } 9279 9280 uint8_t * 9281 xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R) 9282 { 9283 return (uint8_t *) (R + 1); 9284 } 9285 9286 int 9287 xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R) 9288 { 9289 return (R->length * 4); 9290 } 9291 9292 xcb_generic_iterator_t 9293 xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R) 9294 { 9295 xcb_generic_iterator_t i; 9296 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9297 i.rem = 0; 9298 i.index = (char *) i.data - (char *) R; 9299 return i; 9300 } 9301 9302 xcb_glx_get_histogram_reply_t * 9303 xcb_glx_get_histogram_reply (xcb_connection_t *c, 9304 xcb_glx_get_histogram_cookie_t cookie /**< */, 9305 xcb_generic_error_t **e) 9306 { 9307 return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9308 } 9309 9310 int 9311 xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer) 9312 { 9313 char *xcb_tmp = (char *)_buffer; 9314 const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer; 9315 unsigned int xcb_buffer_len = 0; 9316 unsigned int xcb_block_len = 0; 9317 unsigned int xcb_pad = 0; 9318 unsigned int xcb_align_to = 0; 9319 9320 9321 xcb_block_len += sizeof(xcb_glx_get_histogram_parameterfv_reply_t); 9322 xcb_tmp += xcb_block_len; 9323 xcb_buffer_len += xcb_block_len; 9324 xcb_block_len = 0; 9325 /* data */ 9326 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9327 xcb_tmp += xcb_block_len; 9328 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9329 /* insert padding */ 9330 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9331 xcb_buffer_len += xcb_block_len + xcb_pad; 9332 if (0 != xcb_pad) { 9333 xcb_tmp += xcb_pad; 9334 xcb_pad = 0; 9335 } 9336 xcb_block_len = 0; 9337 9338 return xcb_buffer_len; 9339 } 9340 9341 xcb_glx_get_histogram_parameterfv_cookie_t 9342 xcb_glx_get_histogram_parameterfv (xcb_connection_t *c, 9343 xcb_glx_context_tag_t context_tag, 9344 uint32_t target, 9345 uint32_t pname) 9346 { 9347 static const xcb_protocol_request_t xcb_req = { 9348 .count = 2, 9349 .ext = &xcb_glx_id, 9350 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 9351 .isvoid = 0 9352 }; 9353 9354 struct iovec xcb_parts[4]; 9355 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 9356 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 9357 9358 xcb_out.context_tag = context_tag; 9359 xcb_out.target = target; 9360 xcb_out.pname = pname; 9361 9362 xcb_parts[2].iov_base = (char *) &xcb_out; 9363 xcb_parts[2].iov_len = sizeof(xcb_out); 9364 xcb_parts[3].iov_base = 0; 9365 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9366 9367 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9368 return xcb_ret; 9369 } 9370 9371 xcb_glx_get_histogram_parameterfv_cookie_t 9372 xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c, 9373 xcb_glx_context_tag_t context_tag, 9374 uint32_t target, 9375 uint32_t pname) 9376 { 9377 static const xcb_protocol_request_t xcb_req = { 9378 .count = 2, 9379 .ext = &xcb_glx_id, 9380 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, 9381 .isvoid = 0 9382 }; 9383 9384 struct iovec xcb_parts[4]; 9385 xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret; 9386 xcb_glx_get_histogram_parameterfv_request_t xcb_out; 9387 9388 xcb_out.context_tag = context_tag; 9389 xcb_out.target = target; 9390 xcb_out.pname = pname; 9391 9392 xcb_parts[2].iov_base = (char *) &xcb_out; 9393 xcb_parts[2].iov_len = sizeof(xcb_out); 9394 xcb_parts[3].iov_base = 0; 9395 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9396 9397 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9398 return xcb_ret; 9399 } 9400 9401 xcb_glx_float32_t * 9402 xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9403 { 9404 return (xcb_glx_float32_t *) (R + 1); 9405 } 9406 9407 int 9408 xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9409 { 9410 return R->n; 9411 } 9412 9413 xcb_generic_iterator_t 9414 xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R) 9415 { 9416 xcb_generic_iterator_t i; 9417 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9418 i.rem = 0; 9419 i.index = (char *) i.data - (char *) R; 9420 return i; 9421 } 9422 9423 xcb_glx_get_histogram_parameterfv_reply_t * 9424 xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c, 9425 xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, 9426 xcb_generic_error_t **e) 9427 { 9428 return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9429 } 9430 9431 int 9432 xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer) 9433 { 9434 char *xcb_tmp = (char *)_buffer; 9435 const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer; 9436 unsigned int xcb_buffer_len = 0; 9437 unsigned int xcb_block_len = 0; 9438 unsigned int xcb_pad = 0; 9439 unsigned int xcb_align_to = 0; 9440 9441 9442 xcb_block_len += sizeof(xcb_glx_get_histogram_parameteriv_reply_t); 9443 xcb_tmp += xcb_block_len; 9444 xcb_buffer_len += xcb_block_len; 9445 xcb_block_len = 0; 9446 /* data */ 9447 xcb_block_len += _aux->n * sizeof(int32_t); 9448 xcb_tmp += xcb_block_len; 9449 xcb_align_to = ALIGNOF(int32_t); 9450 /* insert padding */ 9451 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9452 xcb_buffer_len += xcb_block_len + xcb_pad; 9453 if (0 != xcb_pad) { 9454 xcb_tmp += xcb_pad; 9455 xcb_pad = 0; 9456 } 9457 xcb_block_len = 0; 9458 9459 return xcb_buffer_len; 9460 } 9461 9462 xcb_glx_get_histogram_parameteriv_cookie_t 9463 xcb_glx_get_histogram_parameteriv (xcb_connection_t *c, 9464 xcb_glx_context_tag_t context_tag, 9465 uint32_t target, 9466 uint32_t pname) 9467 { 9468 static const xcb_protocol_request_t xcb_req = { 9469 .count = 2, 9470 .ext = &xcb_glx_id, 9471 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 9472 .isvoid = 0 9473 }; 9474 9475 struct iovec xcb_parts[4]; 9476 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 9477 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 9478 9479 xcb_out.context_tag = context_tag; 9480 xcb_out.target = target; 9481 xcb_out.pname = pname; 9482 9483 xcb_parts[2].iov_base = (char *) &xcb_out; 9484 xcb_parts[2].iov_len = sizeof(xcb_out); 9485 xcb_parts[3].iov_base = 0; 9486 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9487 9488 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9489 return xcb_ret; 9490 } 9491 9492 xcb_glx_get_histogram_parameteriv_cookie_t 9493 xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c, 9494 xcb_glx_context_tag_t context_tag, 9495 uint32_t target, 9496 uint32_t pname) 9497 { 9498 static const xcb_protocol_request_t xcb_req = { 9499 .count = 2, 9500 .ext = &xcb_glx_id, 9501 .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, 9502 .isvoid = 0 9503 }; 9504 9505 struct iovec xcb_parts[4]; 9506 xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret; 9507 xcb_glx_get_histogram_parameteriv_request_t xcb_out; 9508 9509 xcb_out.context_tag = context_tag; 9510 xcb_out.target = target; 9511 xcb_out.pname = pname; 9512 9513 xcb_parts[2].iov_base = (char *) &xcb_out; 9514 xcb_parts[2].iov_len = sizeof(xcb_out); 9515 xcb_parts[3].iov_base = 0; 9516 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9517 9518 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9519 return xcb_ret; 9520 } 9521 9522 int32_t * 9523 xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9524 { 9525 return (int32_t *) (R + 1); 9526 } 9527 9528 int 9529 xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9530 { 9531 return R->n; 9532 } 9533 9534 xcb_generic_iterator_t 9535 xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R) 9536 { 9537 xcb_generic_iterator_t i; 9538 i.data = ((int32_t *) (R + 1)) + (R->n); 9539 i.rem = 0; 9540 i.index = (char *) i.data - (char *) R; 9541 return i; 9542 } 9543 9544 xcb_glx_get_histogram_parameteriv_reply_t * 9545 xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c, 9546 xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, 9547 xcb_generic_error_t **e) 9548 { 9549 return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9550 } 9551 9552 int 9553 xcb_glx_get_minmax_sizeof (const void *_buffer) 9554 { 9555 char *xcb_tmp = (char *)_buffer; 9556 const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer; 9557 unsigned int xcb_buffer_len = 0; 9558 unsigned int xcb_block_len = 0; 9559 unsigned int xcb_pad = 0; 9560 unsigned int xcb_align_to = 0; 9561 9562 9563 xcb_block_len += sizeof(xcb_glx_get_minmax_reply_t); 9564 xcb_tmp += xcb_block_len; 9565 xcb_buffer_len += xcb_block_len; 9566 xcb_block_len = 0; 9567 /* data */ 9568 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9569 xcb_tmp += xcb_block_len; 9570 xcb_align_to = ALIGNOF(uint8_t); 9571 /* insert padding */ 9572 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9573 xcb_buffer_len += xcb_block_len + xcb_pad; 9574 if (0 != xcb_pad) { 9575 xcb_tmp += xcb_pad; 9576 xcb_pad = 0; 9577 } 9578 xcb_block_len = 0; 9579 9580 return xcb_buffer_len; 9581 } 9582 9583 xcb_glx_get_minmax_cookie_t 9584 xcb_glx_get_minmax (xcb_connection_t *c, 9585 xcb_glx_context_tag_t context_tag, 9586 uint32_t target, 9587 uint32_t format, 9588 uint32_t type, 9589 uint8_t swap_bytes, 9590 uint8_t reset) 9591 { 9592 static const xcb_protocol_request_t xcb_req = { 9593 .count = 2, 9594 .ext = &xcb_glx_id, 9595 .opcode = XCB_GLX_GET_MINMAX, 9596 .isvoid = 0 9597 }; 9598 9599 struct iovec xcb_parts[4]; 9600 xcb_glx_get_minmax_cookie_t xcb_ret; 9601 xcb_glx_get_minmax_request_t xcb_out; 9602 9603 xcb_out.context_tag = context_tag; 9604 xcb_out.target = target; 9605 xcb_out.format = format; 9606 xcb_out.type = type; 9607 xcb_out.swap_bytes = swap_bytes; 9608 xcb_out.reset = reset; 9609 9610 xcb_parts[2].iov_base = (char *) &xcb_out; 9611 xcb_parts[2].iov_len = sizeof(xcb_out); 9612 xcb_parts[3].iov_base = 0; 9613 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9614 9615 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9616 return xcb_ret; 9617 } 9618 9619 xcb_glx_get_minmax_cookie_t 9620 xcb_glx_get_minmax_unchecked (xcb_connection_t *c, 9621 xcb_glx_context_tag_t context_tag, 9622 uint32_t target, 9623 uint32_t format, 9624 uint32_t type, 9625 uint8_t swap_bytes, 9626 uint8_t reset) 9627 { 9628 static const xcb_protocol_request_t xcb_req = { 9629 .count = 2, 9630 .ext = &xcb_glx_id, 9631 .opcode = XCB_GLX_GET_MINMAX, 9632 .isvoid = 0 9633 }; 9634 9635 struct iovec xcb_parts[4]; 9636 xcb_glx_get_minmax_cookie_t xcb_ret; 9637 xcb_glx_get_minmax_request_t xcb_out; 9638 9639 xcb_out.context_tag = context_tag; 9640 xcb_out.target = target; 9641 xcb_out.format = format; 9642 xcb_out.type = type; 9643 xcb_out.swap_bytes = swap_bytes; 9644 xcb_out.reset = reset; 9645 9646 xcb_parts[2].iov_base = (char *) &xcb_out; 9647 xcb_parts[2].iov_len = sizeof(xcb_out); 9648 xcb_parts[3].iov_base = 0; 9649 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9650 9651 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9652 return xcb_ret; 9653 } 9654 9655 uint8_t * 9656 xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R) 9657 { 9658 return (uint8_t *) (R + 1); 9659 } 9660 9661 int 9662 xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R) 9663 { 9664 return (R->length * 4); 9665 } 9666 9667 xcb_generic_iterator_t 9668 xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R) 9669 { 9670 xcb_generic_iterator_t i; 9671 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 9672 i.rem = 0; 9673 i.index = (char *) i.data - (char *) R; 9674 return i; 9675 } 9676 9677 xcb_glx_get_minmax_reply_t * 9678 xcb_glx_get_minmax_reply (xcb_connection_t *c, 9679 xcb_glx_get_minmax_cookie_t cookie /**< */, 9680 xcb_generic_error_t **e) 9681 { 9682 return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9683 } 9684 9685 int 9686 xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer) 9687 { 9688 char *xcb_tmp = (char *)_buffer; 9689 const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer; 9690 unsigned int xcb_buffer_len = 0; 9691 unsigned int xcb_block_len = 0; 9692 unsigned int xcb_pad = 0; 9693 unsigned int xcb_align_to = 0; 9694 9695 9696 xcb_block_len += sizeof(xcb_glx_get_minmax_parameterfv_reply_t); 9697 xcb_tmp += xcb_block_len; 9698 xcb_buffer_len += xcb_block_len; 9699 xcb_block_len = 0; 9700 /* data */ 9701 xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t); 9702 xcb_tmp += xcb_block_len; 9703 xcb_align_to = ALIGNOF(xcb_glx_float32_t); 9704 /* insert padding */ 9705 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9706 xcb_buffer_len += xcb_block_len + xcb_pad; 9707 if (0 != xcb_pad) { 9708 xcb_tmp += xcb_pad; 9709 xcb_pad = 0; 9710 } 9711 xcb_block_len = 0; 9712 9713 return xcb_buffer_len; 9714 } 9715 9716 xcb_glx_get_minmax_parameterfv_cookie_t 9717 xcb_glx_get_minmax_parameterfv (xcb_connection_t *c, 9718 xcb_glx_context_tag_t context_tag, 9719 uint32_t target, 9720 uint32_t pname) 9721 { 9722 static const xcb_protocol_request_t xcb_req = { 9723 .count = 2, 9724 .ext = &xcb_glx_id, 9725 .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, 9726 .isvoid = 0 9727 }; 9728 9729 struct iovec xcb_parts[4]; 9730 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 9731 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 9732 9733 xcb_out.context_tag = context_tag; 9734 xcb_out.target = target; 9735 xcb_out.pname = pname; 9736 9737 xcb_parts[2].iov_base = (char *) &xcb_out; 9738 xcb_parts[2].iov_len = sizeof(xcb_out); 9739 xcb_parts[3].iov_base = 0; 9740 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9741 9742 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9743 return xcb_ret; 9744 } 9745 9746 xcb_glx_get_minmax_parameterfv_cookie_t 9747 xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c, 9748 xcb_glx_context_tag_t context_tag, 9749 uint32_t target, 9750 uint32_t pname) 9751 { 9752 static const xcb_protocol_request_t xcb_req = { 9753 .count = 2, 9754 .ext = &xcb_glx_id, 9755 .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, 9756 .isvoid = 0 9757 }; 9758 9759 struct iovec xcb_parts[4]; 9760 xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret; 9761 xcb_glx_get_minmax_parameterfv_request_t xcb_out; 9762 9763 xcb_out.context_tag = context_tag; 9764 xcb_out.target = target; 9765 xcb_out.pname = pname; 9766 9767 xcb_parts[2].iov_base = (char *) &xcb_out; 9768 xcb_parts[2].iov_len = sizeof(xcb_out); 9769 xcb_parts[3].iov_base = 0; 9770 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9771 9772 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9773 return xcb_ret; 9774 } 9775 9776 xcb_glx_float32_t * 9777 xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9778 { 9779 return (xcb_glx_float32_t *) (R + 1); 9780 } 9781 9782 int 9783 xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9784 { 9785 return R->n; 9786 } 9787 9788 xcb_generic_iterator_t 9789 xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R) 9790 { 9791 xcb_generic_iterator_t i; 9792 i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); 9793 i.rem = 0; 9794 i.index = (char *) i.data - (char *) R; 9795 return i; 9796 } 9797 9798 xcb_glx_get_minmax_parameterfv_reply_t * 9799 xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c, 9800 xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, 9801 xcb_generic_error_t **e) 9802 { 9803 return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9804 } 9805 9806 int 9807 xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer) 9808 { 9809 char *xcb_tmp = (char *)_buffer; 9810 const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer; 9811 unsigned int xcb_buffer_len = 0; 9812 unsigned int xcb_block_len = 0; 9813 unsigned int xcb_pad = 0; 9814 unsigned int xcb_align_to = 0; 9815 9816 9817 xcb_block_len += sizeof(xcb_glx_get_minmax_parameteriv_reply_t); 9818 xcb_tmp += xcb_block_len; 9819 xcb_buffer_len += xcb_block_len; 9820 xcb_block_len = 0; 9821 /* data */ 9822 xcb_block_len += _aux->n * sizeof(int32_t); 9823 xcb_tmp += xcb_block_len; 9824 xcb_align_to = ALIGNOF(int32_t); 9825 /* insert padding */ 9826 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9827 xcb_buffer_len += xcb_block_len + xcb_pad; 9828 if (0 != xcb_pad) { 9829 xcb_tmp += xcb_pad; 9830 xcb_pad = 0; 9831 } 9832 xcb_block_len = 0; 9833 9834 return xcb_buffer_len; 9835 } 9836 9837 xcb_glx_get_minmax_parameteriv_cookie_t 9838 xcb_glx_get_minmax_parameteriv (xcb_connection_t *c, 9839 xcb_glx_context_tag_t context_tag, 9840 uint32_t target, 9841 uint32_t pname) 9842 { 9843 static const xcb_protocol_request_t xcb_req = { 9844 .count = 2, 9845 .ext = &xcb_glx_id, 9846 .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, 9847 .isvoid = 0 9848 }; 9849 9850 struct iovec xcb_parts[4]; 9851 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 9852 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 9853 9854 xcb_out.context_tag = context_tag; 9855 xcb_out.target = target; 9856 xcb_out.pname = pname; 9857 9858 xcb_parts[2].iov_base = (char *) &xcb_out; 9859 xcb_parts[2].iov_len = sizeof(xcb_out); 9860 xcb_parts[3].iov_base = 0; 9861 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9862 9863 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9864 return xcb_ret; 9865 } 9866 9867 xcb_glx_get_minmax_parameteriv_cookie_t 9868 xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c, 9869 xcb_glx_context_tag_t context_tag, 9870 uint32_t target, 9871 uint32_t pname) 9872 { 9873 static const xcb_protocol_request_t xcb_req = { 9874 .count = 2, 9875 .ext = &xcb_glx_id, 9876 .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, 9877 .isvoid = 0 9878 }; 9879 9880 struct iovec xcb_parts[4]; 9881 xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret; 9882 xcb_glx_get_minmax_parameteriv_request_t xcb_out; 9883 9884 xcb_out.context_tag = context_tag; 9885 xcb_out.target = target; 9886 xcb_out.pname = pname; 9887 9888 xcb_parts[2].iov_base = (char *) &xcb_out; 9889 xcb_parts[2].iov_len = sizeof(xcb_out); 9890 xcb_parts[3].iov_base = 0; 9891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9892 9893 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9894 return xcb_ret; 9895 } 9896 9897 int32_t * 9898 xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9899 { 9900 return (int32_t *) (R + 1); 9901 } 9902 9903 int 9904 xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9905 { 9906 return R->n; 9907 } 9908 9909 xcb_generic_iterator_t 9910 xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R) 9911 { 9912 xcb_generic_iterator_t i; 9913 i.data = ((int32_t *) (R + 1)) + (R->n); 9914 i.rem = 0; 9915 i.index = (char *) i.data - (char *) R; 9916 return i; 9917 } 9918 9919 xcb_glx_get_minmax_parameteriv_reply_t * 9920 xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c, 9921 xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, 9922 xcb_generic_error_t **e) 9923 { 9924 return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 9925 } 9926 9927 int 9928 xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer) 9929 { 9930 char *xcb_tmp = (char *)_buffer; 9931 const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer; 9932 unsigned int xcb_buffer_len = 0; 9933 unsigned int xcb_block_len = 0; 9934 unsigned int xcb_pad = 0; 9935 unsigned int xcb_align_to = 0; 9936 9937 9938 xcb_block_len += sizeof(xcb_glx_get_compressed_tex_image_arb_reply_t); 9939 xcb_tmp += xcb_block_len; 9940 xcb_buffer_len += xcb_block_len; 9941 xcb_block_len = 0; 9942 /* data */ 9943 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 9944 xcb_tmp += xcb_block_len; 9945 xcb_align_to = ALIGNOF(uint8_t); 9946 /* insert padding */ 9947 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9948 xcb_buffer_len += xcb_block_len + xcb_pad; 9949 if (0 != xcb_pad) { 9950 xcb_tmp += xcb_pad; 9951 xcb_pad = 0; 9952 } 9953 xcb_block_len = 0; 9954 9955 return xcb_buffer_len; 9956 } 9957 9958 xcb_glx_get_compressed_tex_image_arb_cookie_t 9959 xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c, 9960 xcb_glx_context_tag_t context_tag, 9961 uint32_t target, 9962 int32_t level) 9963 { 9964 static const xcb_protocol_request_t xcb_req = { 9965 .count = 2, 9966 .ext = &xcb_glx_id, 9967 .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 9968 .isvoid = 0 9969 }; 9970 9971 struct iovec xcb_parts[4]; 9972 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 9973 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 9974 9975 xcb_out.context_tag = context_tag; 9976 xcb_out.target = target; 9977 xcb_out.level = level; 9978 9979 xcb_parts[2].iov_base = (char *) &xcb_out; 9980 xcb_parts[2].iov_len = sizeof(xcb_out); 9981 xcb_parts[3].iov_base = 0; 9982 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9983 9984 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9985 return xcb_ret; 9986 } 9987 9988 xcb_glx_get_compressed_tex_image_arb_cookie_t 9989 xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c, 9990 xcb_glx_context_tag_t context_tag, 9991 uint32_t target, 9992 int32_t level) 9993 { 9994 static const xcb_protocol_request_t xcb_req = { 9995 .count = 2, 9996 .ext = &xcb_glx_id, 9997 .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, 9998 .isvoid = 0 9999 }; 10000 10001 struct iovec xcb_parts[4]; 10002 xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret; 10003 xcb_glx_get_compressed_tex_image_arb_request_t xcb_out; 10004 10005 xcb_out.context_tag = context_tag; 10006 xcb_out.target = target; 10007 xcb_out.level = level; 10008 10009 xcb_parts[2].iov_base = (char *) &xcb_out; 10010 xcb_parts[2].iov_len = sizeof(xcb_out); 10011 xcb_parts[3].iov_base = 0; 10012 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10013 10014 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10015 return xcb_ret; 10016 } 10017 10018 uint8_t * 10019 xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10020 { 10021 return (uint8_t *) (R + 1); 10022 } 10023 10024 int 10025 xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10026 { 10027 return (R->length * 4); 10028 } 10029 10030 xcb_generic_iterator_t 10031 xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) 10032 { 10033 xcb_generic_iterator_t i; 10034 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 10035 i.rem = 0; 10036 i.index = (char *) i.data - (char *) R; 10037 return i; 10038 } 10039 10040 xcb_glx_get_compressed_tex_image_arb_reply_t * 10041 xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c, 10042 xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, 10043 xcb_generic_error_t **e) 10044 { 10045 return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10046 } 10047 10048 int 10049 xcb_glx_delete_queries_arb_sizeof (const void *_buffer) 10050 { 10051 char *xcb_tmp = (char *)_buffer; 10052 const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer; 10053 unsigned int xcb_buffer_len = 0; 10054 unsigned int xcb_block_len = 0; 10055 unsigned int xcb_pad = 0; 10056 unsigned int xcb_align_to = 0; 10057 10058 10059 xcb_block_len += sizeof(xcb_glx_delete_queries_arb_request_t); 10060 xcb_tmp += xcb_block_len; 10061 xcb_buffer_len += xcb_block_len; 10062 xcb_block_len = 0; 10063 /* ids */ 10064 xcb_block_len += _aux->n * sizeof(uint32_t); 10065 xcb_tmp += xcb_block_len; 10066 xcb_align_to = ALIGNOF(uint32_t); 10067 /* insert padding */ 10068 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10069 xcb_buffer_len += xcb_block_len + xcb_pad; 10070 if (0 != xcb_pad) { 10071 xcb_tmp += xcb_pad; 10072 xcb_pad = 0; 10073 } 10074 xcb_block_len = 0; 10075 10076 return xcb_buffer_len; 10077 } 10078 10079 xcb_void_cookie_t 10080 xcb_glx_delete_queries_arb_checked (xcb_connection_t *c, 10081 xcb_glx_context_tag_t context_tag, 10082 int32_t n, 10083 const uint32_t *ids) 10084 { 10085 static const xcb_protocol_request_t xcb_req = { 10086 .count = 4, 10087 .ext = &xcb_glx_id, 10088 .opcode = XCB_GLX_DELETE_QUERIES_ARB, 10089 .isvoid = 1 10090 }; 10091 10092 struct iovec xcb_parts[6]; 10093 xcb_void_cookie_t xcb_ret; 10094 xcb_glx_delete_queries_arb_request_t xcb_out; 10095 10096 xcb_out.context_tag = context_tag; 10097 xcb_out.n = n; 10098 10099 xcb_parts[2].iov_base = (char *) &xcb_out; 10100 xcb_parts[2].iov_len = sizeof(xcb_out); 10101 xcb_parts[3].iov_base = 0; 10102 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10103 /* uint32_t ids */ 10104 xcb_parts[4].iov_base = (char *) ids; 10105 xcb_parts[4].iov_len = n * sizeof(uint32_t); 10106 xcb_parts[5].iov_base = 0; 10107 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10108 10109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10110 return xcb_ret; 10111 } 10112 10113 xcb_void_cookie_t 10114 xcb_glx_delete_queries_arb (xcb_connection_t *c, 10115 xcb_glx_context_tag_t context_tag, 10116 int32_t n, 10117 const uint32_t *ids) 10118 { 10119 static const xcb_protocol_request_t xcb_req = { 10120 .count = 4, 10121 .ext = &xcb_glx_id, 10122 .opcode = XCB_GLX_DELETE_QUERIES_ARB, 10123 .isvoid = 1 10124 }; 10125 10126 struct iovec xcb_parts[6]; 10127 xcb_void_cookie_t xcb_ret; 10128 xcb_glx_delete_queries_arb_request_t xcb_out; 10129 10130 xcb_out.context_tag = context_tag; 10131 xcb_out.n = n; 10132 10133 xcb_parts[2].iov_base = (char *) &xcb_out; 10134 xcb_parts[2].iov_len = sizeof(xcb_out); 10135 xcb_parts[3].iov_base = 0; 10136 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10137 /* uint32_t ids */ 10138 xcb_parts[4].iov_base = (char *) ids; 10139 xcb_parts[4].iov_len = n * sizeof(uint32_t); 10140 xcb_parts[5].iov_base = 0; 10141 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10142 10143 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10144 return xcb_ret; 10145 } 10146 10147 uint32_t * 10148 xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R) 10149 { 10150 return (uint32_t *) (R + 1); 10151 } 10152 10153 int 10154 xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R) 10155 { 10156 return R->n; 10157 } 10158 10159 xcb_generic_iterator_t 10160 xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R) 10161 { 10162 xcb_generic_iterator_t i; 10163 i.data = ((uint32_t *) (R + 1)) + (R->n); 10164 i.rem = 0; 10165 i.index = (char *) i.data - (char *) R; 10166 return i; 10167 } 10168 10169 int 10170 xcb_glx_gen_queries_arb_sizeof (const void *_buffer) 10171 { 10172 char *xcb_tmp = (char *)_buffer; 10173 const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer; 10174 unsigned int xcb_buffer_len = 0; 10175 unsigned int xcb_block_len = 0; 10176 unsigned int xcb_pad = 0; 10177 unsigned int xcb_align_to = 0; 10178 10179 10180 xcb_block_len += sizeof(xcb_glx_gen_queries_arb_reply_t); 10181 xcb_tmp += xcb_block_len; 10182 xcb_buffer_len += xcb_block_len; 10183 xcb_block_len = 0; 10184 /* data */ 10185 xcb_block_len += _aux->length * sizeof(uint32_t); 10186 xcb_tmp += xcb_block_len; 10187 xcb_align_to = ALIGNOF(uint32_t); 10188 /* insert padding */ 10189 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10190 xcb_buffer_len += xcb_block_len + xcb_pad; 10191 if (0 != xcb_pad) { 10192 xcb_tmp += xcb_pad; 10193 xcb_pad = 0; 10194 } 10195 xcb_block_len = 0; 10196 10197 return xcb_buffer_len; 10198 } 10199 10200 xcb_glx_gen_queries_arb_cookie_t 10201 xcb_glx_gen_queries_arb (xcb_connection_t *c, 10202 xcb_glx_context_tag_t context_tag, 10203 int32_t n) 10204 { 10205 static const xcb_protocol_request_t xcb_req = { 10206 .count = 2, 10207 .ext = &xcb_glx_id, 10208 .opcode = XCB_GLX_GEN_QUERIES_ARB, 10209 .isvoid = 0 10210 }; 10211 10212 struct iovec xcb_parts[4]; 10213 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 10214 xcb_glx_gen_queries_arb_request_t xcb_out; 10215 10216 xcb_out.context_tag = context_tag; 10217 xcb_out.n = n; 10218 10219 xcb_parts[2].iov_base = (char *) &xcb_out; 10220 xcb_parts[2].iov_len = sizeof(xcb_out); 10221 xcb_parts[3].iov_base = 0; 10222 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10223 10224 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10225 return xcb_ret; 10226 } 10227 10228 xcb_glx_gen_queries_arb_cookie_t 10229 xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c, 10230 xcb_glx_context_tag_t context_tag, 10231 int32_t n) 10232 { 10233 static const xcb_protocol_request_t xcb_req = { 10234 .count = 2, 10235 .ext = &xcb_glx_id, 10236 .opcode = XCB_GLX_GEN_QUERIES_ARB, 10237 .isvoid = 0 10238 }; 10239 10240 struct iovec xcb_parts[4]; 10241 xcb_glx_gen_queries_arb_cookie_t xcb_ret; 10242 xcb_glx_gen_queries_arb_request_t xcb_out; 10243 10244 xcb_out.context_tag = context_tag; 10245 xcb_out.n = n; 10246 10247 xcb_parts[2].iov_base = (char *) &xcb_out; 10248 xcb_parts[2].iov_len = sizeof(xcb_out); 10249 xcb_parts[3].iov_base = 0; 10250 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10251 10252 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10253 return xcb_ret; 10254 } 10255 10256 uint32_t * 10257 xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R) 10258 { 10259 return (uint32_t *) (R + 1); 10260 } 10261 10262 int 10263 xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R) 10264 { 10265 return R->length; 10266 } 10267 10268 xcb_generic_iterator_t 10269 xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R) 10270 { 10271 xcb_generic_iterator_t i; 10272 i.data = ((uint32_t *) (R + 1)) + (R->length); 10273 i.rem = 0; 10274 i.index = (char *) i.data - (char *) R; 10275 return i; 10276 } 10277 10278 xcb_glx_gen_queries_arb_reply_t * 10279 xcb_glx_gen_queries_arb_reply (xcb_connection_t *c, 10280 xcb_glx_gen_queries_arb_cookie_t cookie /**< */, 10281 xcb_generic_error_t **e) 10282 { 10283 return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10284 } 10285 10286 xcb_glx_is_query_arb_cookie_t 10287 xcb_glx_is_query_arb (xcb_connection_t *c, 10288 xcb_glx_context_tag_t context_tag, 10289 uint32_t id) 10290 { 10291 static const xcb_protocol_request_t xcb_req = { 10292 .count = 2, 10293 .ext = &xcb_glx_id, 10294 .opcode = XCB_GLX_IS_QUERY_ARB, 10295 .isvoid = 0 10296 }; 10297 10298 struct iovec xcb_parts[4]; 10299 xcb_glx_is_query_arb_cookie_t xcb_ret; 10300 xcb_glx_is_query_arb_request_t xcb_out; 10301 10302 xcb_out.context_tag = context_tag; 10303 xcb_out.id = id; 10304 10305 xcb_parts[2].iov_base = (char *) &xcb_out; 10306 xcb_parts[2].iov_len = sizeof(xcb_out); 10307 xcb_parts[3].iov_base = 0; 10308 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10309 10310 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10311 return xcb_ret; 10312 } 10313 10314 xcb_glx_is_query_arb_cookie_t 10315 xcb_glx_is_query_arb_unchecked (xcb_connection_t *c, 10316 xcb_glx_context_tag_t context_tag, 10317 uint32_t id) 10318 { 10319 static const xcb_protocol_request_t xcb_req = { 10320 .count = 2, 10321 .ext = &xcb_glx_id, 10322 .opcode = XCB_GLX_IS_QUERY_ARB, 10323 .isvoid = 0 10324 }; 10325 10326 struct iovec xcb_parts[4]; 10327 xcb_glx_is_query_arb_cookie_t xcb_ret; 10328 xcb_glx_is_query_arb_request_t xcb_out; 10329 10330 xcb_out.context_tag = context_tag; 10331 xcb_out.id = id; 10332 10333 xcb_parts[2].iov_base = (char *) &xcb_out; 10334 xcb_parts[2].iov_len = sizeof(xcb_out); 10335 xcb_parts[3].iov_base = 0; 10336 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10337 10338 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10339 return xcb_ret; 10340 } 10341 10342 xcb_glx_is_query_arb_reply_t * 10343 xcb_glx_is_query_arb_reply (xcb_connection_t *c, 10344 xcb_glx_is_query_arb_cookie_t cookie /**< */, 10345 xcb_generic_error_t **e) 10346 { 10347 return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10348 } 10349 10350 int 10351 xcb_glx_get_queryiv_arb_sizeof (const void *_buffer) 10352 { 10353 char *xcb_tmp = (char *)_buffer; 10354 const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer; 10355 unsigned int xcb_buffer_len = 0; 10356 unsigned int xcb_block_len = 0; 10357 unsigned int xcb_pad = 0; 10358 unsigned int xcb_align_to = 0; 10359 10360 10361 xcb_block_len += sizeof(xcb_glx_get_queryiv_arb_reply_t); 10362 xcb_tmp += xcb_block_len; 10363 xcb_buffer_len += xcb_block_len; 10364 xcb_block_len = 0; 10365 /* data */ 10366 xcb_block_len += _aux->n * sizeof(int32_t); 10367 xcb_tmp += xcb_block_len; 10368 xcb_align_to = ALIGNOF(int32_t); 10369 /* insert padding */ 10370 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10371 xcb_buffer_len += xcb_block_len + xcb_pad; 10372 if (0 != xcb_pad) { 10373 xcb_tmp += xcb_pad; 10374 xcb_pad = 0; 10375 } 10376 xcb_block_len = 0; 10377 10378 return xcb_buffer_len; 10379 } 10380 10381 xcb_glx_get_queryiv_arb_cookie_t 10382 xcb_glx_get_queryiv_arb (xcb_connection_t *c, 10383 xcb_glx_context_tag_t context_tag, 10384 uint32_t target, 10385 uint32_t pname) 10386 { 10387 static const xcb_protocol_request_t xcb_req = { 10388 .count = 2, 10389 .ext = &xcb_glx_id, 10390 .opcode = XCB_GLX_GET_QUERYIV_ARB, 10391 .isvoid = 0 10392 }; 10393 10394 struct iovec xcb_parts[4]; 10395 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 10396 xcb_glx_get_queryiv_arb_request_t xcb_out; 10397 10398 xcb_out.context_tag = context_tag; 10399 xcb_out.target = target; 10400 xcb_out.pname = pname; 10401 10402 xcb_parts[2].iov_base = (char *) &xcb_out; 10403 xcb_parts[2].iov_len = sizeof(xcb_out); 10404 xcb_parts[3].iov_base = 0; 10405 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10406 10407 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10408 return xcb_ret; 10409 } 10410 10411 xcb_glx_get_queryiv_arb_cookie_t 10412 xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c, 10413 xcb_glx_context_tag_t context_tag, 10414 uint32_t target, 10415 uint32_t pname) 10416 { 10417 static const xcb_protocol_request_t xcb_req = { 10418 .count = 2, 10419 .ext = &xcb_glx_id, 10420 .opcode = XCB_GLX_GET_QUERYIV_ARB, 10421 .isvoid = 0 10422 }; 10423 10424 struct iovec xcb_parts[4]; 10425 xcb_glx_get_queryiv_arb_cookie_t xcb_ret; 10426 xcb_glx_get_queryiv_arb_request_t xcb_out; 10427 10428 xcb_out.context_tag = context_tag; 10429 xcb_out.target = target; 10430 xcb_out.pname = pname; 10431 10432 xcb_parts[2].iov_base = (char *) &xcb_out; 10433 xcb_parts[2].iov_len = sizeof(xcb_out); 10434 xcb_parts[3].iov_base = 0; 10435 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10436 10437 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10438 return xcb_ret; 10439 } 10440 10441 int32_t * 10442 xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R) 10443 { 10444 return (int32_t *) (R + 1); 10445 } 10446 10447 int 10448 xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R) 10449 { 10450 return R->n; 10451 } 10452 10453 xcb_generic_iterator_t 10454 xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R) 10455 { 10456 xcb_generic_iterator_t i; 10457 i.data = ((int32_t *) (R + 1)) + (R->n); 10458 i.rem = 0; 10459 i.index = (char *) i.data - (char *) R; 10460 return i; 10461 } 10462 10463 xcb_glx_get_queryiv_arb_reply_t * 10464 xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c, 10465 xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, 10466 xcb_generic_error_t **e) 10467 { 10468 return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10469 } 10470 10471 int 10472 xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer) 10473 { 10474 char *xcb_tmp = (char *)_buffer; 10475 const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer; 10476 unsigned int xcb_buffer_len = 0; 10477 unsigned int xcb_block_len = 0; 10478 unsigned int xcb_pad = 0; 10479 unsigned int xcb_align_to = 0; 10480 10481 10482 xcb_block_len += sizeof(xcb_glx_get_query_objectiv_arb_reply_t); 10483 xcb_tmp += xcb_block_len; 10484 xcb_buffer_len += xcb_block_len; 10485 xcb_block_len = 0; 10486 /* data */ 10487 xcb_block_len += _aux->n * sizeof(int32_t); 10488 xcb_tmp += xcb_block_len; 10489 xcb_align_to = ALIGNOF(int32_t); 10490 /* insert padding */ 10491 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10492 xcb_buffer_len += xcb_block_len + xcb_pad; 10493 if (0 != xcb_pad) { 10494 xcb_tmp += xcb_pad; 10495 xcb_pad = 0; 10496 } 10497 xcb_block_len = 0; 10498 10499 return xcb_buffer_len; 10500 } 10501 10502 xcb_glx_get_query_objectiv_arb_cookie_t 10503 xcb_glx_get_query_objectiv_arb (xcb_connection_t *c, 10504 xcb_glx_context_tag_t context_tag, 10505 uint32_t id, 10506 uint32_t pname) 10507 { 10508 static const xcb_protocol_request_t xcb_req = { 10509 .count = 2, 10510 .ext = &xcb_glx_id, 10511 .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, 10512 .isvoid = 0 10513 }; 10514 10515 struct iovec xcb_parts[4]; 10516 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 10517 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 10518 10519 xcb_out.context_tag = context_tag; 10520 xcb_out.id = id; 10521 xcb_out.pname = pname; 10522 10523 xcb_parts[2].iov_base = (char *) &xcb_out; 10524 xcb_parts[2].iov_len = sizeof(xcb_out); 10525 xcb_parts[3].iov_base = 0; 10526 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10527 10528 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10529 return xcb_ret; 10530 } 10531 10532 xcb_glx_get_query_objectiv_arb_cookie_t 10533 xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c, 10534 xcb_glx_context_tag_t context_tag, 10535 uint32_t id, 10536 uint32_t pname) 10537 { 10538 static const xcb_protocol_request_t xcb_req = { 10539 .count = 2, 10540 .ext = &xcb_glx_id, 10541 .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, 10542 .isvoid = 0 10543 }; 10544 10545 struct iovec xcb_parts[4]; 10546 xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret; 10547 xcb_glx_get_query_objectiv_arb_request_t xcb_out; 10548 10549 xcb_out.context_tag = context_tag; 10550 xcb_out.id = id; 10551 xcb_out.pname = pname; 10552 10553 xcb_parts[2].iov_base = (char *) &xcb_out; 10554 xcb_parts[2].iov_len = sizeof(xcb_out); 10555 xcb_parts[3].iov_base = 0; 10556 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10557 10558 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10559 return xcb_ret; 10560 } 10561 10562 int32_t * 10563 xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10564 { 10565 return (int32_t *) (R + 1); 10566 } 10567 10568 int 10569 xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10570 { 10571 return R->n; 10572 } 10573 10574 xcb_generic_iterator_t 10575 xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R) 10576 { 10577 xcb_generic_iterator_t i; 10578 i.data = ((int32_t *) (R + 1)) + (R->n); 10579 i.rem = 0; 10580 i.index = (char *) i.data - (char *) R; 10581 return i; 10582 } 10583 10584 xcb_glx_get_query_objectiv_arb_reply_t * 10585 xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c, 10586 xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, 10587 xcb_generic_error_t **e) 10588 { 10589 return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10590 } 10591 10592 int 10593 xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer) 10594 { 10595 char *xcb_tmp = (char *)_buffer; 10596 const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer; 10597 unsigned int xcb_buffer_len = 0; 10598 unsigned int xcb_block_len = 0; 10599 unsigned int xcb_pad = 0; 10600 unsigned int xcb_align_to = 0; 10601 10602 10603 xcb_block_len += sizeof(xcb_glx_get_query_objectuiv_arb_reply_t); 10604 xcb_tmp += xcb_block_len; 10605 xcb_buffer_len += xcb_block_len; 10606 xcb_block_len = 0; 10607 /* data */ 10608 xcb_block_len += _aux->n * sizeof(uint32_t); 10609 xcb_tmp += xcb_block_len; 10610 xcb_align_to = ALIGNOF(uint32_t); 10611 /* insert padding */ 10612 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10613 xcb_buffer_len += xcb_block_len + xcb_pad; 10614 if (0 != xcb_pad) { 10615 xcb_tmp += xcb_pad; 10616 xcb_pad = 0; 10617 } 10618 xcb_block_len = 0; 10619 10620 return xcb_buffer_len; 10621 } 10622 10623 xcb_glx_get_query_objectuiv_arb_cookie_t 10624 xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c, 10625 xcb_glx_context_tag_t context_tag, 10626 uint32_t id, 10627 uint32_t pname) 10628 { 10629 static const xcb_protocol_request_t xcb_req = { 10630 .count = 2, 10631 .ext = &xcb_glx_id, 10632 .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 10633 .isvoid = 0 10634 }; 10635 10636 struct iovec xcb_parts[4]; 10637 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 10638 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 10639 10640 xcb_out.context_tag = context_tag; 10641 xcb_out.id = id; 10642 xcb_out.pname = pname; 10643 10644 xcb_parts[2].iov_base = (char *) &xcb_out; 10645 xcb_parts[2].iov_len = sizeof(xcb_out); 10646 xcb_parts[3].iov_base = 0; 10647 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10648 10649 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10650 return xcb_ret; 10651 } 10652 10653 xcb_glx_get_query_objectuiv_arb_cookie_t 10654 xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c, 10655 xcb_glx_context_tag_t context_tag, 10656 uint32_t id, 10657 uint32_t pname) 10658 { 10659 static const xcb_protocol_request_t xcb_req = { 10660 .count = 2, 10661 .ext = &xcb_glx_id, 10662 .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, 10663 .isvoid = 0 10664 }; 10665 10666 struct iovec xcb_parts[4]; 10667 xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret; 10668 xcb_glx_get_query_objectuiv_arb_request_t xcb_out; 10669 10670 xcb_out.context_tag = context_tag; 10671 xcb_out.id = id; 10672 xcb_out.pname = pname; 10673 10674 xcb_parts[2].iov_base = (char *) &xcb_out; 10675 xcb_parts[2].iov_len = sizeof(xcb_out); 10676 xcb_parts[3].iov_base = 0; 10677 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10678 10679 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10680 return xcb_ret; 10681 } 10682 10683 uint32_t * 10684 xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10685 { 10686 return (uint32_t *) (R + 1); 10687 } 10688 10689 int 10690 xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10691 { 10692 return R->n; 10693 } 10694 10695 xcb_generic_iterator_t 10696 xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R) 10697 { 10698 xcb_generic_iterator_t i; 10699 i.data = ((uint32_t *) (R + 1)) + (R->n); 10700 i.rem = 0; 10701 i.index = (char *) i.data - (char *) R; 10702 return i; 10703 } 10704 10705 xcb_glx_get_query_objectuiv_arb_reply_t * 10706 xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c, 10707 xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, 10708 xcb_generic_error_t **e) 10709 { 10710 return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10711 } 10712 10713