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