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
xcb_glx_pixmap_next(xcb_glx_pixmap_iterator_t * i)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
xcb_glx_pixmap_end(xcb_glx_pixmap_iterator_t i)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
xcb_glx_context_next(xcb_glx_context_iterator_t * i)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
xcb_glx_context_end(xcb_glx_context_iterator_t i)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
xcb_glx_pbuffer_next(xcb_glx_pbuffer_iterator_t * i)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
xcb_glx_pbuffer_end(xcb_glx_pbuffer_iterator_t i)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
xcb_glx_window_next(xcb_glx_window_iterator_t * i)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
xcb_glx_window_end(xcb_glx_window_iterator_t i)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
xcb_glx_fbconfig_next(xcb_glx_fbconfig_iterator_t * i)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
xcb_glx_fbconfig_end(xcb_glx_fbconfig_iterator_t i)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
xcb_glx_drawable_next(xcb_glx_drawable_iterator_t * i)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
xcb_glx_drawable_end(xcb_glx_drawable_iterator_t i)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
xcb_glx_float32_next(xcb_glx_float32_iterator_t * i)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
xcb_glx_float32_end(xcb_glx_float32_iterator_t i)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
xcb_glx_float64_next(xcb_glx_float64_iterator_t * i)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
xcb_glx_float64_end(xcb_glx_float64_iterator_t i)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
xcb_glx_bool32_next(xcb_glx_bool32_iterator_t * i)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
xcb_glx_bool32_end(xcb_glx_bool32_iterator_t i)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
xcb_glx_context_tag_next(xcb_glx_context_tag_iterator_t * i)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
xcb_glx_context_tag_end(xcb_glx_context_tag_iterator_t i)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
xcb_glx_render_sizeof(const void * _buffer,uint32_t data_len)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
xcb_glx_render_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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
xcb_glx_render(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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 *
xcb_glx_render_data(const xcb_glx_render_request_t * R)299 xcb_glx_render_data (const xcb_glx_render_request_t *R)
300 {
301 return (uint8_t *) (R + 1);
302 }
303
304 int
xcb_glx_render_data_length(const xcb_glx_render_request_t * R)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
xcb_glx_render_data_end(const xcb_glx_render_request_t * R)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
xcb_glx_render_large_sizeof(const void * _buffer)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
xcb_glx_render_large_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint16_t request_num,uint16_t request_total,uint32_t data_len,const uint8_t * data)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
xcb_glx_render_large(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint16_t request_num,uint16_t request_total,uint32_t data_len,const uint8_t * data)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 *
xcb_glx_render_large_data(const xcb_glx_render_large_request_t * R)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
xcb_glx_render_large_data_length(const xcb_glx_render_large_request_t * R)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
xcb_glx_render_large_data_end(const xcb_glx_render_large_request_t * R)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
xcb_glx_create_context_checked(xcb_connection_t * c,xcb_glx_context_t context,xcb_visualid_t visual,uint32_t screen,xcb_glx_context_t share_list,uint8_t is_direct)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
xcb_glx_create_context(xcb_connection_t * c,xcb_glx_context_t context,xcb_visualid_t visual,uint32_t screen,xcb_glx_context_t share_list,uint8_t is_direct)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
xcb_glx_destroy_context_checked(xcb_connection_t * c,xcb_glx_context_t context)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
xcb_glx_destroy_context(xcb_connection_t * c,xcb_glx_context_t context)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
xcb_glx_make_current(xcb_connection_t * c,xcb_glx_drawable_t drawable,xcb_glx_context_t context,xcb_glx_context_tag_t old_context_tag)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
xcb_glx_make_current_unchecked(xcb_connection_t * c,xcb_glx_drawable_t drawable,xcb_glx_context_t context,xcb_glx_context_tag_t old_context_tag)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 *
xcb_glx_make_current_reply(xcb_connection_t * c,xcb_glx_make_current_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_is_direct(xcb_connection_t * c,xcb_glx_context_t context)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
xcb_glx_is_direct_unchecked(xcb_connection_t * c,xcb_glx_context_t context)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 *
xcb_glx_is_direct_reply(xcb_connection_t * c,xcb_glx_is_direct_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_query_version(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version)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
xcb_glx_query_version_unchecked(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version)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 *
xcb_glx_query_version_reply(xcb_connection_t * c,xcb_glx_query_version_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_wait_gl_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_wait_gl(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_wait_x_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_wait_x(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_copy_context_checked(xcb_connection_t * c,xcb_glx_context_t src,xcb_glx_context_t dest,uint32_t mask,xcb_glx_context_tag_t src_context_tag)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
xcb_glx_copy_context(xcb_connection_t * c,xcb_glx_context_t src,xcb_glx_context_t dest,uint32_t mask,xcb_glx_context_tag_t src_context_tag)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
xcb_glx_swap_buffers_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,xcb_glx_drawable_t drawable)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
xcb_glx_swap_buffers(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,xcb_glx_drawable_t drawable)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
xcb_glx_use_x_font_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,xcb_font_t font,uint32_t first,uint32_t count,uint32_t list_base)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
xcb_glx_use_x_font(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,xcb_font_t font,uint32_t first,uint32_t count,uint32_t list_base)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
xcb_glx_create_glx_pixmap_checked(xcb_connection_t * c,uint32_t screen,xcb_visualid_t visual,xcb_pixmap_t pixmap,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_create_glx_pixmap(xcb_connection_t * c,uint32_t screen,xcb_visualid_t visual,xcb_pixmap_t pixmap,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_get_visual_configs_sizeof(const void * _buffer)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
xcb_glx_get_visual_configs(xcb_connection_t * c,uint32_t screen)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
xcb_glx_get_visual_configs_unchecked(xcb_connection_t * c,uint32_t screen)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 *
xcb_glx_get_visual_configs_property_list(const xcb_glx_get_visual_configs_reply_t * R)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
xcb_glx_get_visual_configs_property_list_length(const xcb_glx_get_visual_configs_reply_t * R)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
xcb_glx_get_visual_configs_property_list_end(const xcb_glx_get_visual_configs_reply_t * R)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 *
xcb_glx_get_visual_configs_reply(xcb_connection_t * c,xcb_glx_get_visual_configs_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_destroy_glx_pixmap_checked(xcb_connection_t * c,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_destroy_glx_pixmap(xcb_connection_t * c,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_vendor_private_sizeof(const void * _buffer,uint32_t data_len)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
xcb_glx_vendor_private_checked(xcb_connection_t * c,uint32_t vendor_code,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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
xcb_glx_vendor_private(xcb_connection_t * c,uint32_t vendor_code,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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 *
xcb_glx_vendor_private_data(const xcb_glx_vendor_private_request_t * R)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
xcb_glx_vendor_private_data_length(const xcb_glx_vendor_private_request_t * R)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
xcb_glx_vendor_private_data_end(const xcb_glx_vendor_private_request_t * R)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
xcb_glx_vendor_private_with_reply_sizeof(const void * _buffer,uint32_t data_len)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
xcb_glx_vendor_private_with_reply(xcb_connection_t * c,uint32_t vendor_code,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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
xcb_glx_vendor_private_with_reply_unchecked(xcb_connection_t * c,uint32_t vendor_code,xcb_glx_context_tag_t context_tag,uint32_t data_len,const uint8_t * data)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 *
xcb_glx_vendor_private_with_reply_data_2(const xcb_glx_vendor_private_with_reply_reply_t * R)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
xcb_glx_vendor_private_with_reply_data_2_length(const xcb_glx_vendor_private_with_reply_reply_t * R)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
xcb_glx_vendor_private_with_reply_data_2_end(const xcb_glx_vendor_private_with_reply_reply_t * R)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 *
xcb_glx_vendor_private_with_reply_reply(xcb_connection_t * c,xcb_glx_vendor_private_with_reply_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_query_extensions_string(xcb_connection_t * c,uint32_t screen)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
xcb_glx_query_extensions_string_unchecked(xcb_connection_t * c,uint32_t screen)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 *
xcb_glx_query_extensions_string_reply(xcb_connection_t * c,xcb_glx_query_extensions_string_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_query_server_string_sizeof(const void * _buffer)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
xcb_glx_query_server_string(xcb_connection_t * c,uint32_t screen,uint32_t name)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
xcb_glx_query_server_string_unchecked(xcb_connection_t * c,uint32_t screen,uint32_t name)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 *
xcb_glx_query_server_string_string(const xcb_glx_query_server_string_reply_t * R)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
xcb_glx_query_server_string_string_length(const xcb_glx_query_server_string_reply_t * R)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
xcb_glx_query_server_string_string_end(const xcb_glx_query_server_string_reply_t * R)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 *
xcb_glx_query_server_string_reply(xcb_connection_t * c,xcb_glx_query_server_string_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_client_info_sizeof(const void * _buffer)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
xcb_glx_client_info_checked(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t str_len,const char * string)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
xcb_glx_client_info(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t str_len,const char * string)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 *
xcb_glx_client_info_string(const xcb_glx_client_info_request_t * R)1819 xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R)
1820 {
1821 return (char *) (R + 1);
1822 }
1823
1824 int
xcb_glx_client_info_string_length(const xcb_glx_client_info_request_t * R)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
xcb_glx_client_info_string_end(const xcb_glx_client_info_request_t * R)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
xcb_glx_get_fb_configs_sizeof(const void * _buffer)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
xcb_glx_get_fb_configs(xcb_connection_t * c,uint32_t screen)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
xcb_glx_get_fb_configs_unchecked(xcb_connection_t * c,uint32_t screen)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 *
xcb_glx_get_fb_configs_property_list(const xcb_glx_get_fb_configs_reply_t * R)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
xcb_glx_get_fb_configs_property_list_length(const xcb_glx_get_fb_configs_reply_t * R)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
xcb_glx_get_fb_configs_property_list_end(const xcb_glx_get_fb_configs_reply_t * R)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 *
xcb_glx_get_fb_configs_reply(xcb_connection_t * c,xcb_glx_get_fb_configs_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_create_pixmap_sizeof(const void * _buffer)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
xcb_glx_create_pixmap_checked(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_pixmap_t pixmap,xcb_glx_pixmap_t glx_pixmap,uint32_t num_attribs,const uint32_t * attribs)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
xcb_glx_create_pixmap(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_pixmap_t pixmap,xcb_glx_pixmap_t glx_pixmap,uint32_t num_attribs,const uint32_t * attribs)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 *
xcb_glx_create_pixmap_attribs(const xcb_glx_create_pixmap_request_t * R)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
xcb_glx_create_pixmap_attribs_length(const xcb_glx_create_pixmap_request_t * R)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
xcb_glx_create_pixmap_attribs_end(const xcb_glx_create_pixmap_request_t * R)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
xcb_glx_destroy_pixmap_checked(xcb_connection_t * c,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_destroy_pixmap(xcb_connection_t * c,xcb_glx_pixmap_t glx_pixmap)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
xcb_glx_create_new_context_checked(xcb_connection_t * c,xcb_glx_context_t context,xcb_glx_fbconfig_t fbconfig,uint32_t screen,uint32_t render_type,xcb_glx_context_t share_list,uint8_t is_direct)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
xcb_glx_create_new_context(xcb_connection_t * c,xcb_glx_context_t context,xcb_glx_fbconfig_t fbconfig,uint32_t screen,uint32_t render_type,xcb_glx_context_t share_list,uint8_t is_direct)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
xcb_glx_query_context_sizeof(const void * _buffer)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
xcb_glx_query_context(xcb_connection_t * c,xcb_glx_context_t context)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
xcb_glx_query_context_unchecked(xcb_connection_t * c,xcb_glx_context_t context)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 *
xcb_glx_query_context_attribs(const xcb_glx_query_context_reply_t * R)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
xcb_glx_query_context_attribs_length(const xcb_glx_query_context_reply_t * R)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
xcb_glx_query_context_attribs_end(const xcb_glx_query_context_reply_t * R)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 *
xcb_glx_query_context_reply(xcb_connection_t * c,xcb_glx_query_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_make_context_current(xcb_connection_t * c,xcb_glx_context_tag_t old_context_tag,xcb_glx_drawable_t drawable,xcb_glx_drawable_t read_drawable,xcb_glx_context_t context)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
xcb_glx_make_context_current_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t old_context_tag,xcb_glx_drawable_t drawable,xcb_glx_drawable_t read_drawable,xcb_glx_context_t context)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 *
xcb_glx_make_context_current_reply(xcb_connection_t * c,xcb_glx_make_context_current_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_create_pbuffer_sizeof(const void * _buffer)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
xcb_glx_create_pbuffer_checked(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_glx_pbuffer_t pbuffer,uint32_t num_attribs,const uint32_t * attribs)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
xcb_glx_create_pbuffer(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_glx_pbuffer_t pbuffer,uint32_t num_attribs,const uint32_t * attribs)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 *
xcb_glx_create_pbuffer_attribs(const xcb_glx_create_pbuffer_request_t * R)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
xcb_glx_create_pbuffer_attribs_length(const xcb_glx_create_pbuffer_request_t * R)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
xcb_glx_create_pbuffer_attribs_end(const xcb_glx_create_pbuffer_request_t * R)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
xcb_glx_destroy_pbuffer_checked(xcb_connection_t * c,xcb_glx_pbuffer_t pbuffer)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
xcb_glx_destroy_pbuffer(xcb_connection_t * c,xcb_glx_pbuffer_t pbuffer)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
xcb_glx_get_drawable_attributes_sizeof(const void * _buffer)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
xcb_glx_get_drawable_attributes(xcb_connection_t * c,xcb_glx_drawable_t drawable)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
xcb_glx_get_drawable_attributes_unchecked(xcb_connection_t * c,xcb_glx_drawable_t drawable)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 *
xcb_glx_get_drawable_attributes_attribs(const xcb_glx_get_drawable_attributes_reply_t * R)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
xcb_glx_get_drawable_attributes_attribs_length(const xcb_glx_get_drawable_attributes_reply_t * R)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
xcb_glx_get_drawable_attributes_attribs_end(const xcb_glx_get_drawable_attributes_reply_t * R)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 *
xcb_glx_get_drawable_attributes_reply(xcb_connection_t * c,xcb_glx_get_drawable_attributes_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_change_drawable_attributes_sizeof(const void * _buffer)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
xcb_glx_change_drawable_attributes_checked(xcb_connection_t * c,xcb_glx_drawable_t drawable,uint32_t num_attribs,const uint32_t * attribs)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
xcb_glx_change_drawable_attributes(xcb_connection_t * c,xcb_glx_drawable_t drawable,uint32_t num_attribs,const uint32_t * attribs)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 *
xcb_glx_change_drawable_attributes_attribs(const xcb_glx_change_drawable_attributes_request_t * R)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
xcb_glx_change_drawable_attributes_attribs_length(const xcb_glx_change_drawable_attributes_request_t * R)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
xcb_glx_change_drawable_attributes_attribs_end(const xcb_glx_change_drawable_attributes_request_t * R)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
xcb_glx_create_window_sizeof(const void * _buffer)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
xcb_glx_create_window_checked(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_window_t window,xcb_glx_window_t glx_window,uint32_t num_attribs,const uint32_t * attribs)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
xcb_glx_create_window(xcb_connection_t * c,uint32_t screen,xcb_glx_fbconfig_t fbconfig,xcb_window_t window,xcb_glx_window_t glx_window,uint32_t num_attribs,const uint32_t * attribs)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 *
xcb_glx_create_window_attribs(const xcb_glx_create_window_request_t * R)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
xcb_glx_create_window_attribs_length(const xcb_glx_create_window_request_t * R)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
xcb_glx_create_window_attribs_end(const xcb_glx_create_window_request_t * R)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
xcb_glx_delete_window_checked(xcb_connection_t * c,xcb_glx_window_t glxwindow)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
xcb_glx_delete_window(xcb_connection_t * c,xcb_glx_window_t glxwindow)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
xcb_glx_set_client_info_arb_sizeof(const void * _buffer)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
xcb_glx_set_client_info_arb_checked(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t num_versions,uint32_t gl_str_len,uint32_t glx_str_len,const uint32_t * gl_versions,const char * gl_extension_string,const char * glx_extension_string)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
xcb_glx_set_client_info_arb(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t num_versions,uint32_t gl_str_len,uint32_t glx_str_len,const uint32_t * gl_versions,const char * gl_extension_string,const char * glx_extension_string)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 *
xcb_glx_set_client_info_arb_gl_versions(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_gl_versions_length(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_gl_versions_end(const xcb_glx_set_client_info_arb_request_t * R)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 *
xcb_glx_set_client_info_arb_gl_extension_string(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_gl_extension_string_length(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_gl_extension_string_end(const xcb_glx_set_client_info_arb_request_t * R)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 *
xcb_glx_set_client_info_arb_glx_extension_string(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_glx_extension_string_length(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_set_client_info_arb_glx_extension_string_end(const xcb_glx_set_client_info_arb_request_t * R)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
xcb_glx_create_context_attribs_arb_sizeof(const void * _buffer)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
xcb_glx_create_context_attribs_arb_checked(xcb_connection_t * c,xcb_glx_context_t context,xcb_glx_fbconfig_t fbconfig,uint32_t screen,xcb_glx_context_t share_list,uint8_t is_direct,uint32_t num_attribs,const uint32_t * attribs)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
xcb_glx_create_context_attribs_arb(xcb_connection_t * c,xcb_glx_context_t context,xcb_glx_fbconfig_t fbconfig,uint32_t screen,xcb_glx_context_t share_list,uint8_t is_direct,uint32_t num_attribs,const uint32_t * attribs)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 *
xcb_glx_create_context_attribs_arb_attribs(const xcb_glx_create_context_attribs_arb_request_t * R)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
xcb_glx_create_context_attribs_arb_attribs_length(const xcb_glx_create_context_attribs_arb_request_t * R)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
xcb_glx_create_context_attribs_arb_attribs_end(const xcb_glx_create_context_attribs_arb_request_t * R)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
xcb_glx_set_client_info_2arb_sizeof(const void * _buffer)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
xcb_glx_set_client_info_2arb_checked(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t num_versions,uint32_t gl_str_len,uint32_t glx_str_len,const uint32_t * gl_versions,const char * gl_extension_string,const char * glx_extension_string)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
xcb_glx_set_client_info_2arb(xcb_connection_t * c,uint32_t major_version,uint32_t minor_version,uint32_t num_versions,uint32_t gl_str_len,uint32_t glx_str_len,const uint32_t * gl_versions,const char * gl_extension_string,const char * glx_extension_string)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 *
xcb_glx_set_client_info_2arb_gl_versions(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_gl_versions_length(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_gl_versions_end(const xcb_glx_set_client_info_2arb_request_t * R)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 *
xcb_glx_set_client_info_2arb_gl_extension_string(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_gl_extension_string_length(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_gl_extension_string_end(const xcb_glx_set_client_info_2arb_request_t * R)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 *
xcb_glx_set_client_info_2arb_glx_extension_string(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_glx_extension_string_length(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_set_client_info_2arb_glx_extension_string_end(const xcb_glx_set_client_info_2arb_request_t * R)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
xcb_glx_new_list_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list,uint32_t mode)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
xcb_glx_new_list(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list,uint32_t mode)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
xcb_glx_end_list_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_end_list(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_delete_lists_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list,int32_t range)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
xcb_glx_delete_lists(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list,int32_t range)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
xcb_glx_gen_lists(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t range)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
xcb_glx_gen_lists_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t range)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 *
xcb_glx_gen_lists_reply(xcb_connection_t * c,xcb_glx_gen_lists_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_feedback_buffer_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t size,int32_t type)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
xcb_glx_feedback_buffer(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t size,int32_t type)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
xcb_glx_select_buffer_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t size)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
xcb_glx_select_buffer(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t size)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
xcb_glx_render_mode_sizeof(const void * _buffer)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
xcb_glx_render_mode(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t mode)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
xcb_glx_render_mode_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t mode)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 *
xcb_glx_render_mode_data(const xcb_glx_render_mode_reply_t * R)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
xcb_glx_render_mode_data_length(const xcb_glx_render_mode_reply_t * R)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
xcb_glx_render_mode_data_end(const xcb_glx_render_mode_reply_t * R)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 *
xcb_glx_render_mode_reply(xcb_connection_t * c,xcb_glx_render_mode_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_finish(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_finish_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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 *
xcb_glx_finish_reply(xcb_connection_t * c,xcb_glx_finish_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_pixel_storef_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname,xcb_glx_float32_t datum)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
xcb_glx_pixel_storef(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname,xcb_glx_float32_t datum)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
xcb_glx_pixel_storei_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname,int32_t datum)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
xcb_glx_pixel_storei(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname,int32_t datum)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
xcb_glx_read_pixels_sizeof(const void * _buffer)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
xcb_glx_read_pixels(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t x,int32_t y,int32_t width,int32_t height,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t lsb_first)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
xcb_glx_read_pixels_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t x,int32_t y,int32_t width,int32_t height,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t lsb_first)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 *
xcb_glx_read_pixels_data(const xcb_glx_read_pixels_reply_t * R)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
xcb_glx_read_pixels_data_length(const xcb_glx_read_pixels_reply_t * R)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
xcb_glx_read_pixels_data_end(const xcb_glx_read_pixels_reply_t * R)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 *
xcb_glx_read_pixels_reply(xcb_connection_t * c,xcb_glx_read_pixels_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_booleanv_sizeof(const void * _buffer)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
xcb_glx_get_booleanv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t pname)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
xcb_glx_get_booleanv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t pname)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 *
xcb_glx_get_booleanv_data(const xcb_glx_get_booleanv_reply_t * R)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
xcb_glx_get_booleanv_data_length(const xcb_glx_get_booleanv_reply_t * R)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
xcb_glx_get_booleanv_data_end(const xcb_glx_get_booleanv_reply_t * R)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 *
xcb_glx_get_booleanv_reply(xcb_connection_t * c,xcb_glx_get_booleanv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_clip_plane_sizeof(const void * _buffer)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
xcb_glx_get_clip_plane(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t plane)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
xcb_glx_get_clip_plane_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t plane)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 *
xcb_glx_get_clip_plane_data(const xcb_glx_get_clip_plane_reply_t * R)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
xcb_glx_get_clip_plane_data_length(const xcb_glx_get_clip_plane_reply_t * R)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
xcb_glx_get_clip_plane_data_end(const xcb_glx_get_clip_plane_reply_t * R)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 *
xcb_glx_get_clip_plane_reply(xcb_connection_t * c,xcb_glx_get_clip_plane_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_doublev_sizeof(const void * _buffer)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
xcb_glx_get_doublev(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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
xcb_glx_get_doublev_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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 *
xcb_glx_get_doublev_data(const xcb_glx_get_doublev_reply_t * R)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
xcb_glx_get_doublev_data_length(const xcb_glx_get_doublev_reply_t * R)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
xcb_glx_get_doublev_data_end(const xcb_glx_get_doublev_reply_t * R)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 *
xcb_glx_get_doublev_reply(xcb_connection_t * c,xcb_glx_get_doublev_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_error(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_get_error_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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 *
xcb_glx_get_error_reply(xcb_connection_t * c,xcb_glx_get_error_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_floatv_sizeof(const void * _buffer)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
xcb_glx_get_floatv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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
xcb_glx_get_floatv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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 *
xcb_glx_get_floatv_data(const xcb_glx_get_floatv_reply_t * R)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
xcb_glx_get_floatv_data_length(const xcb_glx_get_floatv_reply_t * R)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
xcb_glx_get_floatv_data_end(const xcb_glx_get_floatv_reply_t * R)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 *
xcb_glx_get_floatv_reply(xcb_connection_t * c,xcb_glx_get_floatv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_integerv_sizeof(const void * _buffer)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
xcb_glx_get_integerv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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
xcb_glx_get_integerv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t pname)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 *
xcb_glx_get_integerv_data(const xcb_glx_get_integerv_reply_t * R)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
xcb_glx_get_integerv_data_length(const xcb_glx_get_integerv_reply_t * R)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
xcb_glx_get_integerv_data_end(const xcb_glx_get_integerv_reply_t * R)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 *
xcb_glx_get_integerv_reply(xcb_connection_t * c,xcb_glx_get_integerv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_lightfv_sizeof(const void * _buffer)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
xcb_glx_get_lightfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t light,uint32_t pname)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
xcb_glx_get_lightfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t light,uint32_t pname)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 *
xcb_glx_get_lightfv_data(const xcb_glx_get_lightfv_reply_t * R)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
xcb_glx_get_lightfv_data_length(const xcb_glx_get_lightfv_reply_t * R)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
xcb_glx_get_lightfv_data_end(const xcb_glx_get_lightfv_reply_t * R)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 *
xcb_glx_get_lightfv_reply(xcb_connection_t * c,xcb_glx_get_lightfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_lightiv_sizeof(const void * _buffer)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
xcb_glx_get_lightiv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t light,uint32_t pname)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
xcb_glx_get_lightiv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t light,uint32_t pname)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 *
xcb_glx_get_lightiv_data(const xcb_glx_get_lightiv_reply_t * R)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
xcb_glx_get_lightiv_data_length(const xcb_glx_get_lightiv_reply_t * R)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
xcb_glx_get_lightiv_data_end(const xcb_glx_get_lightiv_reply_t * R)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 *
xcb_glx_get_lightiv_reply(xcb_connection_t * c,xcb_glx_get_lightiv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_mapdv_sizeof(const void * _buffer)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
xcb_glx_get_mapdv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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
xcb_glx_get_mapdv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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 *
xcb_glx_get_mapdv_data(const xcb_glx_get_mapdv_reply_t * R)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
xcb_glx_get_mapdv_data_length(const xcb_glx_get_mapdv_reply_t * R)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
xcb_glx_get_mapdv_data_end(const xcb_glx_get_mapdv_reply_t * R)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 *
xcb_glx_get_mapdv_reply(xcb_connection_t * c,xcb_glx_get_mapdv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_mapfv_sizeof(const void * _buffer)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
xcb_glx_get_mapfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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
xcb_glx_get_mapfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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 *
xcb_glx_get_mapfv_data(const xcb_glx_get_mapfv_reply_t * R)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
xcb_glx_get_mapfv_data_length(const xcb_glx_get_mapfv_reply_t * R)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
xcb_glx_get_mapfv_data_end(const xcb_glx_get_mapfv_reply_t * R)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 *
xcb_glx_get_mapfv_reply(xcb_connection_t * c,xcb_glx_get_mapfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_mapiv_sizeof(const void * _buffer)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
xcb_glx_get_mapiv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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
xcb_glx_get_mapiv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t query)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 *
xcb_glx_get_mapiv_data(const xcb_glx_get_mapiv_reply_t * R)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
xcb_glx_get_mapiv_data_length(const xcb_glx_get_mapiv_reply_t * R)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
xcb_glx_get_mapiv_data_end(const xcb_glx_get_mapiv_reply_t * R)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 *
xcb_glx_get_mapiv_reply(xcb_connection_t * c,xcb_glx_get_mapiv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_materialfv_sizeof(const void * _buffer)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
xcb_glx_get_materialfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t face,uint32_t pname)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
xcb_glx_get_materialfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t face,uint32_t pname)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 *
xcb_glx_get_materialfv_data(const xcb_glx_get_materialfv_reply_t * R)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
xcb_glx_get_materialfv_data_length(const xcb_glx_get_materialfv_reply_t * R)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
xcb_glx_get_materialfv_data_end(const xcb_glx_get_materialfv_reply_t * R)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 *
xcb_glx_get_materialfv_reply(xcb_connection_t * c,xcb_glx_get_materialfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_materialiv_sizeof(const void * _buffer)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
xcb_glx_get_materialiv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t face,uint32_t pname)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
xcb_glx_get_materialiv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t face,uint32_t pname)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 *
xcb_glx_get_materialiv_data(const xcb_glx_get_materialiv_reply_t * R)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
xcb_glx_get_materialiv_data_length(const xcb_glx_get_materialiv_reply_t * R)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
xcb_glx_get_materialiv_data_end(const xcb_glx_get_materialiv_reply_t * R)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 *
xcb_glx_get_materialiv_reply(xcb_connection_t * c,xcb_glx_get_materialiv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_pixel_mapfv_sizeof(const void * _buffer)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
xcb_glx_get_pixel_mapfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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
xcb_glx_get_pixel_mapfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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 *
xcb_glx_get_pixel_mapfv_data(const xcb_glx_get_pixel_mapfv_reply_t * R)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
xcb_glx_get_pixel_mapfv_data_length(const xcb_glx_get_pixel_mapfv_reply_t * R)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
xcb_glx_get_pixel_mapfv_data_end(const xcb_glx_get_pixel_mapfv_reply_t * R)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 *
xcb_glx_get_pixel_mapfv_reply(xcb_connection_t * c,xcb_glx_get_pixel_mapfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_pixel_mapuiv_sizeof(const void * _buffer)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
xcb_glx_get_pixel_mapuiv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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
xcb_glx_get_pixel_mapuiv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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 *
xcb_glx_get_pixel_mapuiv_data(const xcb_glx_get_pixel_mapuiv_reply_t * R)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
xcb_glx_get_pixel_mapuiv_data_length(const xcb_glx_get_pixel_mapuiv_reply_t * R)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
xcb_glx_get_pixel_mapuiv_data_end(const xcb_glx_get_pixel_mapuiv_reply_t * R)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 *
xcb_glx_get_pixel_mapuiv_reply(xcb_connection_t * c,xcb_glx_get_pixel_mapuiv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_pixel_mapusv_sizeof(const void * _buffer)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
xcb_glx_get_pixel_mapusv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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
xcb_glx_get_pixel_mapusv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t map)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 *
xcb_glx_get_pixel_mapusv_data(const xcb_glx_get_pixel_mapusv_reply_t * R)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
xcb_glx_get_pixel_mapusv_data_length(const xcb_glx_get_pixel_mapusv_reply_t * R)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
xcb_glx_get_pixel_mapusv_data_end(const xcb_glx_get_pixel_mapusv_reply_t * R)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 *
xcb_glx_get_pixel_mapusv_reply(xcb_connection_t * c,xcb_glx_get_pixel_mapusv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_polygon_stipple_sizeof(const void * _buffer)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
xcb_glx_get_polygon_stipple(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint8_t lsb_first)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
xcb_glx_get_polygon_stipple_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint8_t lsb_first)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 *
xcb_glx_get_polygon_stipple_data(const xcb_glx_get_polygon_stipple_reply_t * R)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
xcb_glx_get_polygon_stipple_data_length(const xcb_glx_get_polygon_stipple_reply_t * R)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
xcb_glx_get_polygon_stipple_data_end(const xcb_glx_get_polygon_stipple_reply_t * R)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 *
xcb_glx_get_polygon_stipple_reply(xcb_connection_t * c,xcb_glx_get_polygon_stipple_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_string_sizeof(const void * _buffer)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
xcb_glx_get_string(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t name)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
xcb_glx_get_string_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t name)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 *
xcb_glx_get_string_string(const xcb_glx_get_string_reply_t * R)6454 xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R)
6455 {
6456 return (char *) (R + 1);
6457 }
6458
6459 int
xcb_glx_get_string_string_length(const xcb_glx_get_string_reply_t * R)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
xcb_glx_get_string_string_end(const xcb_glx_get_string_reply_t * R)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 *
xcb_glx_get_string_reply(xcb_connection_t * c,xcb_glx_get_string_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_envfv_sizeof(const void * _buffer)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
xcb_glx_get_tex_envfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_tex_envfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_tex_envfv_data(const xcb_glx_get_tex_envfv_reply_t * R)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
xcb_glx_get_tex_envfv_data_length(const xcb_glx_get_tex_envfv_reply_t * R)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
xcb_glx_get_tex_envfv_data_end(const xcb_glx_get_tex_envfv_reply_t * R)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 *
xcb_glx_get_tex_envfv_reply(xcb_connection_t * c,xcb_glx_get_tex_envfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_enviv_sizeof(const void * _buffer)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
xcb_glx_get_tex_enviv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_tex_enviv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_tex_enviv_data(const xcb_glx_get_tex_enviv_reply_t * R)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
xcb_glx_get_tex_enviv_data_length(const xcb_glx_get_tex_enviv_reply_t * R)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
xcb_glx_get_tex_enviv_data_end(const xcb_glx_get_tex_enviv_reply_t * R)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 *
xcb_glx_get_tex_enviv_reply(xcb_connection_t * c,xcb_glx_get_tex_enviv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_gendv_sizeof(const void * _buffer)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
xcb_glx_get_tex_gendv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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
xcb_glx_get_tex_gendv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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 *
xcb_glx_get_tex_gendv_data(const xcb_glx_get_tex_gendv_reply_t * R)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
xcb_glx_get_tex_gendv_data_length(const xcb_glx_get_tex_gendv_reply_t * R)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
xcb_glx_get_tex_gendv_data_end(const xcb_glx_get_tex_gendv_reply_t * R)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 *
xcb_glx_get_tex_gendv_reply(xcb_connection_t * c,xcb_glx_get_tex_gendv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_genfv_sizeof(const void * _buffer)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
xcb_glx_get_tex_genfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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
xcb_glx_get_tex_genfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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 *
xcb_glx_get_tex_genfv_data(const xcb_glx_get_tex_genfv_reply_t * R)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
xcb_glx_get_tex_genfv_data_length(const xcb_glx_get_tex_genfv_reply_t * R)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
xcb_glx_get_tex_genfv_data_end(const xcb_glx_get_tex_genfv_reply_t * R)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 *
xcb_glx_get_tex_genfv_reply(xcb_connection_t * c,xcb_glx_get_tex_genfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_geniv_sizeof(const void * _buffer)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
xcb_glx_get_tex_geniv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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
xcb_glx_get_tex_geniv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t coord,uint32_t pname)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 *
xcb_glx_get_tex_geniv_data(const xcb_glx_get_tex_geniv_reply_t * R)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
xcb_glx_get_tex_geniv_data_length(const xcb_glx_get_tex_geniv_reply_t * R)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
xcb_glx_get_tex_geniv_data_end(const xcb_glx_get_tex_geniv_reply_t * R)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 *
xcb_glx_get_tex_geniv_reply(xcb_connection_t * c,xcb_glx_get_tex_geniv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_image_sizeof(const void * _buffer)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
xcb_glx_get_tex_image(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t format,uint32_t type,uint8_t swap_bytes)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
xcb_glx_get_tex_image_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t format,uint32_t type,uint8_t swap_bytes)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 *
xcb_glx_get_tex_image_data(const xcb_glx_get_tex_image_reply_t * R)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
xcb_glx_get_tex_image_data_length(const xcb_glx_get_tex_image_reply_t * R)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
xcb_glx_get_tex_image_data_end(const xcb_glx_get_tex_image_reply_t * R)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 *
xcb_glx_get_tex_image_reply(xcb_connection_t * c,xcb_glx_get_tex_image_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_tex_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_tex_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_tex_parameterfv_data(const xcb_glx_get_tex_parameterfv_reply_t * R)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
xcb_glx_get_tex_parameterfv_data_length(const xcb_glx_get_tex_parameterfv_reply_t * R)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
xcb_glx_get_tex_parameterfv_data_end(const xcb_glx_get_tex_parameterfv_reply_t * R)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 *
xcb_glx_get_tex_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_tex_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_tex_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_tex_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_tex_parameteriv_data(const xcb_glx_get_tex_parameteriv_reply_t * R)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
xcb_glx_get_tex_parameteriv_data_length(const xcb_glx_get_tex_parameteriv_reply_t * R)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
xcb_glx_get_tex_parameteriv_data_end(const xcb_glx_get_tex_parameteriv_reply_t * R)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 *
xcb_glx_get_tex_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_tex_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_level_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_tex_level_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t pname)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
xcb_glx_get_tex_level_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t pname)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 *
xcb_glx_get_tex_level_parameterfv_data(const xcb_glx_get_tex_level_parameterfv_reply_t * R)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
xcb_glx_get_tex_level_parameterfv_data_length(const xcb_glx_get_tex_level_parameterfv_reply_t * R)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
xcb_glx_get_tex_level_parameterfv_data_end(const xcb_glx_get_tex_level_parameterfv_reply_t * R)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 *
xcb_glx_get_tex_level_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_tex_level_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_tex_level_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_tex_level_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t pname)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
xcb_glx_get_tex_level_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level,uint32_t pname)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 *
xcb_glx_get_tex_level_parameteriv_data(const xcb_glx_get_tex_level_parameteriv_reply_t * R)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
xcb_glx_get_tex_level_parameteriv_data_length(const xcb_glx_get_tex_level_parameteriv_reply_t * R)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
xcb_glx_get_tex_level_parameteriv_data_end(const xcb_glx_get_tex_level_parameteriv_reply_t * R)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 *
xcb_glx_get_tex_level_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_tex_level_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_is_enabled(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t capability)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
xcb_glx_is_enabled_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t capability)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 *
xcb_glx_is_enabled_reply(xcb_connection_t * c,xcb_glx_is_enabled_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_is_list(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list)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
xcb_glx_is_list_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t list)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 *
xcb_glx_is_list_reply(xcb_connection_t * c,xcb_glx_is_list_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_flush_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_flush(xcb_connection_t * c,xcb_glx_context_tag_t context_tag)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
xcb_glx_are_textures_resident_sizeof(const void * _buffer)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
xcb_glx_are_textures_resident(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * textures)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
xcb_glx_are_textures_resident_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * textures)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 *
xcb_glx_are_textures_resident_data(const xcb_glx_are_textures_resident_reply_t * R)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
xcb_glx_are_textures_resident_data_length(const xcb_glx_are_textures_resident_reply_t * R)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
xcb_glx_are_textures_resident_data_end(const xcb_glx_are_textures_resident_reply_t * R)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 *
xcb_glx_are_textures_resident_reply(xcb_connection_t * c,xcb_glx_are_textures_resident_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_delete_textures_sizeof(const void * _buffer)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
xcb_glx_delete_textures_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * textures)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
xcb_glx_delete_textures(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * textures)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 *
xcb_glx_delete_textures_textures(const xcb_glx_delete_textures_request_t * R)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
xcb_glx_delete_textures_textures_length(const xcb_glx_delete_textures_request_t * R)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
xcb_glx_delete_textures_textures_end(const xcb_glx_delete_textures_request_t * R)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
xcb_glx_gen_textures_sizeof(const void * _buffer)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
xcb_glx_gen_textures(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n)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
xcb_glx_gen_textures_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n)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 *
xcb_glx_gen_textures_data(const xcb_glx_gen_textures_reply_t * R)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
xcb_glx_gen_textures_data_length(const xcb_glx_gen_textures_reply_t * R)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
xcb_glx_gen_textures_data_end(const xcb_glx_gen_textures_reply_t * R)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 *
xcb_glx_gen_textures_reply(xcb_connection_t * c,xcb_glx_gen_textures_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_is_texture(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t texture)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
xcb_glx_is_texture_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t texture)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 *
xcb_glx_is_texture_reply(xcb_connection_t * c,xcb_glx_is_texture_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_color_table_sizeof(const void * _buffer)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
xcb_glx_get_color_table(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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
xcb_glx_get_color_table_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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 *
xcb_glx_get_color_table_data(const xcb_glx_get_color_table_reply_t * R)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
xcb_glx_get_color_table_data_length(const xcb_glx_get_color_table_reply_t * R)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
xcb_glx_get_color_table_data_end(const xcb_glx_get_color_table_reply_t * R)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 *
xcb_glx_get_color_table_reply(xcb_connection_t * c,xcb_glx_get_color_table_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_color_table_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_color_table_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_color_table_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_color_table_parameterfv_data(const xcb_glx_get_color_table_parameterfv_reply_t * R)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
xcb_glx_get_color_table_parameterfv_data_length(const xcb_glx_get_color_table_parameterfv_reply_t * R)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
xcb_glx_get_color_table_parameterfv_data_end(const xcb_glx_get_color_table_parameterfv_reply_t * R)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 *
xcb_glx_get_color_table_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_color_table_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_color_table_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_color_table_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_color_table_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_color_table_parameteriv_data(const xcb_glx_get_color_table_parameteriv_reply_t * R)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
xcb_glx_get_color_table_parameteriv_data_length(const xcb_glx_get_color_table_parameteriv_reply_t * R)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
xcb_glx_get_color_table_parameteriv_data_end(const xcb_glx_get_color_table_parameteriv_reply_t * R)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 *
xcb_glx_get_color_table_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_color_table_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_convolution_filter_sizeof(const void * _buffer)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
xcb_glx_get_convolution_filter(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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
xcb_glx_get_convolution_filter_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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 *
xcb_glx_get_convolution_filter_data(const xcb_glx_get_convolution_filter_reply_t * R)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
xcb_glx_get_convolution_filter_data_length(const xcb_glx_get_convolution_filter_reply_t * R)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
xcb_glx_get_convolution_filter_data_end(const xcb_glx_get_convolution_filter_reply_t * R)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 *
xcb_glx_get_convolution_filter_reply(xcb_connection_t * c,xcb_glx_get_convolution_filter_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_convolution_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_convolution_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_convolution_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_convolution_parameterfv_data(const xcb_glx_get_convolution_parameterfv_reply_t * R)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
xcb_glx_get_convolution_parameterfv_data_length(const xcb_glx_get_convolution_parameterfv_reply_t * R)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
xcb_glx_get_convolution_parameterfv_data_end(const xcb_glx_get_convolution_parameterfv_reply_t * R)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 *
xcb_glx_get_convolution_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_convolution_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_convolution_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_convolution_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_convolution_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_convolution_parameteriv_data(const xcb_glx_get_convolution_parameteriv_reply_t * R)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
xcb_glx_get_convolution_parameteriv_data_length(const xcb_glx_get_convolution_parameteriv_reply_t * R)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
xcb_glx_get_convolution_parameteriv_data_end(const xcb_glx_get_convolution_parameteriv_reply_t * R)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 *
xcb_glx_get_convolution_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_convolution_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_separable_filter_sizeof(const void * _buffer)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
xcb_glx_get_separable_filter(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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
xcb_glx_get_separable_filter_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes)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 *
xcb_glx_get_separable_filter_rows_and_cols(const xcb_glx_get_separable_filter_reply_t * R)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
xcb_glx_get_separable_filter_rows_and_cols_length(const xcb_glx_get_separable_filter_reply_t * R)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
xcb_glx_get_separable_filter_rows_and_cols_end(const xcb_glx_get_separable_filter_reply_t * R)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 *
xcb_glx_get_separable_filter_reply(xcb_connection_t * c,xcb_glx_get_separable_filter_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_histogram_sizeof(const void * _buffer)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
xcb_glx_get_histogram(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t reset)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
xcb_glx_get_histogram_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t reset)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 *
xcb_glx_get_histogram_data(const xcb_glx_get_histogram_reply_t * R)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
xcb_glx_get_histogram_data_length(const xcb_glx_get_histogram_reply_t * R)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
xcb_glx_get_histogram_data_end(const xcb_glx_get_histogram_reply_t * R)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 *
xcb_glx_get_histogram_reply(xcb_connection_t * c,xcb_glx_get_histogram_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_histogram_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_histogram_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_histogram_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_histogram_parameterfv_data(const xcb_glx_get_histogram_parameterfv_reply_t * R)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
xcb_glx_get_histogram_parameterfv_data_length(const xcb_glx_get_histogram_parameterfv_reply_t * R)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
xcb_glx_get_histogram_parameterfv_data_end(const xcb_glx_get_histogram_parameterfv_reply_t * R)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 *
xcb_glx_get_histogram_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_histogram_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_histogram_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_histogram_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_histogram_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_histogram_parameteriv_data(const xcb_glx_get_histogram_parameteriv_reply_t * R)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
xcb_glx_get_histogram_parameteriv_data_length(const xcb_glx_get_histogram_parameteriv_reply_t * R)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
xcb_glx_get_histogram_parameteriv_data_end(const xcb_glx_get_histogram_parameteriv_reply_t * R)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 *
xcb_glx_get_histogram_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_histogram_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_minmax_sizeof(const void * _buffer)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
xcb_glx_get_minmax(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t reset)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
xcb_glx_get_minmax_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t format,uint32_t type,uint8_t swap_bytes,uint8_t reset)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 *
xcb_glx_get_minmax_data(const xcb_glx_get_minmax_reply_t * R)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
xcb_glx_get_minmax_data_length(const xcb_glx_get_minmax_reply_t * R)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
xcb_glx_get_minmax_data_end(const xcb_glx_get_minmax_reply_t * R)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 *
xcb_glx_get_minmax_reply(xcb_connection_t * c,xcb_glx_get_minmax_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_minmax_parameterfv_sizeof(const void * _buffer)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
xcb_glx_get_minmax_parameterfv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_minmax_parameterfv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_minmax_parameterfv_data(const xcb_glx_get_minmax_parameterfv_reply_t * R)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
xcb_glx_get_minmax_parameterfv_data_length(const xcb_glx_get_minmax_parameterfv_reply_t * R)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
xcb_glx_get_minmax_parameterfv_data_end(const xcb_glx_get_minmax_parameterfv_reply_t * R)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 *
xcb_glx_get_minmax_parameterfv_reply(xcb_connection_t * c,xcb_glx_get_minmax_parameterfv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_minmax_parameteriv_sizeof(const void * _buffer)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
xcb_glx_get_minmax_parameteriv(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_minmax_parameteriv_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_minmax_parameteriv_data(const xcb_glx_get_minmax_parameteriv_reply_t * R)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
xcb_glx_get_minmax_parameteriv_data_length(const xcb_glx_get_minmax_parameteriv_reply_t * R)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
xcb_glx_get_minmax_parameteriv_data_end(const xcb_glx_get_minmax_parameteriv_reply_t * R)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 *
xcb_glx_get_minmax_parameteriv_reply(xcb_connection_t * c,xcb_glx_get_minmax_parameteriv_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_compressed_tex_image_arb_sizeof(const void * _buffer)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
xcb_glx_get_compressed_tex_image_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level)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
xcb_glx_get_compressed_tex_image_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,int32_t level)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 *
xcb_glx_get_compressed_tex_image_arb_data(const xcb_glx_get_compressed_tex_image_arb_reply_t * R)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
xcb_glx_get_compressed_tex_image_arb_data_length(const xcb_glx_get_compressed_tex_image_arb_reply_t * R)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
xcb_glx_get_compressed_tex_image_arb_data_end(const xcb_glx_get_compressed_tex_image_arb_reply_t * R)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 *
xcb_glx_get_compressed_tex_image_arb_reply(xcb_connection_t * c,xcb_glx_get_compressed_tex_image_arb_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_delete_queries_arb_sizeof(const void * _buffer)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
xcb_glx_delete_queries_arb_checked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * ids)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
xcb_glx_delete_queries_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n,const uint32_t * ids)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 *
xcb_glx_delete_queries_arb_ids(const xcb_glx_delete_queries_arb_request_t * R)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
xcb_glx_delete_queries_arb_ids_length(const xcb_glx_delete_queries_arb_request_t * R)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
xcb_glx_delete_queries_arb_ids_end(const xcb_glx_delete_queries_arb_request_t * R)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
xcb_glx_gen_queries_arb_sizeof(const void * _buffer)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
xcb_glx_gen_queries_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n)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
xcb_glx_gen_queries_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,int32_t n)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 *
xcb_glx_gen_queries_arb_data(const xcb_glx_gen_queries_arb_reply_t * R)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
xcb_glx_gen_queries_arb_data_length(const xcb_glx_gen_queries_arb_reply_t * R)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
xcb_glx_gen_queries_arb_data_end(const xcb_glx_gen_queries_arb_reply_t * R)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 *
xcb_glx_gen_queries_arb_reply(xcb_connection_t * c,xcb_glx_gen_queries_arb_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_is_query_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id)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
xcb_glx_is_query_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id)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 *
xcb_glx_is_query_arb_reply(xcb_connection_t * c,xcb_glx_is_query_arb_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_queryiv_arb_sizeof(const void * _buffer)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
xcb_glx_get_queryiv_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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
xcb_glx_get_queryiv_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t target,uint32_t pname)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 *
xcb_glx_get_queryiv_arb_data(const xcb_glx_get_queryiv_arb_reply_t * R)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
xcb_glx_get_queryiv_arb_data_length(const xcb_glx_get_queryiv_arb_reply_t * R)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
xcb_glx_get_queryiv_arb_data_end(const xcb_glx_get_queryiv_arb_reply_t * R)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 *
xcb_glx_get_queryiv_arb_reply(xcb_connection_t * c,xcb_glx_get_queryiv_arb_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_query_objectiv_arb_sizeof(const void * _buffer)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
xcb_glx_get_query_objectiv_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id,uint32_t pname)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
xcb_glx_get_query_objectiv_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id,uint32_t pname)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 *
xcb_glx_get_query_objectiv_arb_data(const xcb_glx_get_query_objectiv_arb_reply_t * R)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
xcb_glx_get_query_objectiv_arb_data_length(const xcb_glx_get_query_objectiv_arb_reply_t * R)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
xcb_glx_get_query_objectiv_arb_data_end(const xcb_glx_get_query_objectiv_arb_reply_t * R)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 *
xcb_glx_get_query_objectiv_arb_reply(xcb_connection_t * c,xcb_glx_get_query_objectiv_arb_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_glx_get_query_objectuiv_arb_sizeof(const void * _buffer)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
xcb_glx_get_query_objectuiv_arb(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id,uint32_t pname)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
xcb_glx_get_query_objectuiv_arb_unchecked(xcb_connection_t * c,xcb_glx_context_tag_t context_tag,uint32_t id,uint32_t pname)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 *
xcb_glx_get_query_objectuiv_arb_data(const xcb_glx_get_query_objectuiv_arb_reply_t * R)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
xcb_glx_get_query_objectuiv_arb_data_length(const xcb_glx_get_query_objectuiv_arb_reply_t * R)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
xcb_glx_get_query_objectuiv_arb_data_end(const xcb_glx_get_query_objectuiv_arb_reply_t * R)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 *
xcb_glx_get_query_objectuiv_arb_reply(xcb_connection_t * c,xcb_glx_get_query_objectuiv_arb_cookie_t cookie,xcb_generic_error_t ** e)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