1 /*
2 * This file generated automatically from render.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 "render.h"
15
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 #include "xproto.h"
18
19 xcb_extension_t xcb_render_id = { "RENDER", 0 };
20
21 void
xcb_render_glyph_next(xcb_render_glyph_iterator_t * i)22 xcb_render_glyph_next (xcb_render_glyph_iterator_t *i)
23 {
24 --i->rem;
25 ++i->data;
26 i->index += sizeof(xcb_render_glyph_t);
27 }
28
29 xcb_generic_iterator_t
xcb_render_glyph_end(xcb_render_glyph_iterator_t i)30 xcb_render_glyph_end (xcb_render_glyph_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_render_glyphset_next(xcb_render_glyphset_iterator_t * i)40 xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i)
41 {
42 --i->rem;
43 ++i->data;
44 i->index += sizeof(xcb_render_glyphset_t);
45 }
46
47 xcb_generic_iterator_t
xcb_render_glyphset_end(xcb_render_glyphset_iterator_t i)48 xcb_render_glyphset_end (xcb_render_glyphset_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_render_picture_next(xcb_render_picture_iterator_t * i)58 xcb_render_picture_next (xcb_render_picture_iterator_t *i)
59 {
60 --i->rem;
61 ++i->data;
62 i->index += sizeof(xcb_render_picture_t);
63 }
64
65 xcb_generic_iterator_t
xcb_render_picture_end(xcb_render_picture_iterator_t i)66 xcb_render_picture_end (xcb_render_picture_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_render_pictformat_next(xcb_render_pictformat_iterator_t * i)76 xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i)
77 {
78 --i->rem;
79 ++i->data;
80 i->index += sizeof(xcb_render_pictformat_t);
81 }
82
83 xcb_generic_iterator_t
xcb_render_pictformat_end(xcb_render_pictformat_iterator_t i)84 xcb_render_pictformat_end (xcb_render_pictformat_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_render_fixed_next(xcb_render_fixed_iterator_t * i)94 xcb_render_fixed_next (xcb_render_fixed_iterator_t *i)
95 {
96 --i->rem;
97 ++i->data;
98 i->index += sizeof(xcb_render_fixed_t);
99 }
100
101 xcb_generic_iterator_t
xcb_render_fixed_end(xcb_render_fixed_iterator_t i)102 xcb_render_fixed_end (xcb_render_fixed_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_render_directformat_next(xcb_render_directformat_iterator_t * i)112 xcb_render_directformat_next (xcb_render_directformat_iterator_t *i)
113 {
114 --i->rem;
115 ++i->data;
116 i->index += sizeof(xcb_render_directformat_t);
117 }
118
119 xcb_generic_iterator_t
xcb_render_directformat_end(xcb_render_directformat_iterator_t i)120 xcb_render_directformat_end (xcb_render_directformat_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_render_pictforminfo_next(xcb_render_pictforminfo_iterator_t * i)130 xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i)
131 {
132 --i->rem;
133 ++i->data;
134 i->index += sizeof(xcb_render_pictforminfo_t);
135 }
136
137 xcb_generic_iterator_t
xcb_render_pictforminfo_end(xcb_render_pictforminfo_iterator_t i)138 xcb_render_pictforminfo_end (xcb_render_pictforminfo_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_render_pictvisual_next(xcb_render_pictvisual_iterator_t * i)148 xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i)
149 {
150 --i->rem;
151 ++i->data;
152 i->index += sizeof(xcb_render_pictvisual_t);
153 }
154
155 xcb_generic_iterator_t
xcb_render_pictvisual_end(xcb_render_pictvisual_iterator_t i)156 xcb_render_pictvisual_end (xcb_render_pictvisual_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 int
xcb_render_pictdepth_sizeof(const void * _buffer)166 xcb_render_pictdepth_sizeof (const void *_buffer)
167 {
168 char *xcb_tmp = (char *)_buffer;
169 const xcb_render_pictdepth_t *_aux = (xcb_render_pictdepth_t *)_buffer;
170 unsigned int xcb_buffer_len = 0;
171 unsigned int xcb_block_len = 0;
172 unsigned int xcb_pad = 0;
173 unsigned int xcb_align_to = 0;
174
175
176 xcb_block_len += sizeof(xcb_render_pictdepth_t);
177 xcb_tmp += xcb_block_len;
178 xcb_buffer_len += xcb_block_len;
179 xcb_block_len = 0;
180 /* visuals */
181 xcb_block_len += _aux->num_visuals * sizeof(xcb_render_pictvisual_t);
182 xcb_tmp += xcb_block_len;
183 xcb_align_to = ALIGNOF(xcb_render_pictvisual_t);
184 /* insert padding */
185 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
186 xcb_buffer_len += xcb_block_len + xcb_pad;
187 if (0 != xcb_pad) {
188 xcb_tmp += xcb_pad;
189 xcb_pad = 0;
190 }
191 xcb_block_len = 0;
192
193 return xcb_buffer_len;
194 }
195
196 xcb_render_pictvisual_t *
xcb_render_pictdepth_visuals(const xcb_render_pictdepth_t * R)197 xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R)
198 {
199 return (xcb_render_pictvisual_t *) (R + 1);
200 }
201
202 int
xcb_render_pictdepth_visuals_length(const xcb_render_pictdepth_t * R)203 xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R)
204 {
205 return R->num_visuals;
206 }
207
208 xcb_render_pictvisual_iterator_t
xcb_render_pictdepth_visuals_iterator(const xcb_render_pictdepth_t * R)209 xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R)
210 {
211 xcb_render_pictvisual_iterator_t i;
212 i.data = (xcb_render_pictvisual_t *) (R + 1);
213 i.rem = R->num_visuals;
214 i.index = (char *) i.data - (char *) R;
215 return i;
216 }
217
218 void
xcb_render_pictdepth_next(xcb_render_pictdepth_iterator_t * i)219 xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i)
220 {
221 xcb_render_pictdepth_t *R = i->data;
222 xcb_generic_iterator_t child;
223 child.data = (xcb_render_pictdepth_t *)(((char *)R) + xcb_render_pictdepth_sizeof(R));
224 i->index = (char *) child.data - (char *) i->data;
225 --i->rem;
226 i->data = (xcb_render_pictdepth_t *) child.data;
227 }
228
229 xcb_generic_iterator_t
xcb_render_pictdepth_end(xcb_render_pictdepth_iterator_t i)230 xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i)
231 {
232 xcb_generic_iterator_t ret;
233 while(i.rem > 0)
234 xcb_render_pictdepth_next(&i);
235 ret.data = i.data;
236 ret.rem = i.rem;
237 ret.index = i.index;
238 return ret;
239 }
240
241 int
xcb_render_pictscreen_sizeof(const void * _buffer)242 xcb_render_pictscreen_sizeof (const void *_buffer)
243 {
244 char *xcb_tmp = (char *)_buffer;
245 const xcb_render_pictscreen_t *_aux = (xcb_render_pictscreen_t *)_buffer;
246 unsigned int xcb_buffer_len = 0;
247 unsigned int xcb_block_len = 0;
248 unsigned int xcb_pad = 0;
249 unsigned int xcb_align_to = 0;
250
251 unsigned int i;
252 unsigned int xcb_tmp_len;
253
254 xcb_block_len += sizeof(xcb_render_pictscreen_t);
255 xcb_tmp += xcb_block_len;
256 xcb_buffer_len += xcb_block_len;
257 xcb_block_len = 0;
258 /* depths */
259 for(i=0; i<_aux->num_depths; i++) {
260 xcb_tmp_len = xcb_render_pictdepth_sizeof(xcb_tmp);
261 xcb_block_len += xcb_tmp_len;
262 xcb_tmp += xcb_tmp_len;
263 }
264 xcb_align_to = ALIGNOF(xcb_render_pictdepth_t);
265 /* insert padding */
266 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
267 xcb_buffer_len += xcb_block_len + xcb_pad;
268 if (0 != xcb_pad) {
269 xcb_tmp += xcb_pad;
270 xcb_pad = 0;
271 }
272 xcb_block_len = 0;
273
274 return xcb_buffer_len;
275 }
276
277 int
xcb_render_pictscreen_depths_length(const xcb_render_pictscreen_t * R)278 xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R)
279 {
280 return R->num_depths;
281 }
282
283 xcb_render_pictdepth_iterator_t
xcb_render_pictscreen_depths_iterator(const xcb_render_pictscreen_t * R)284 xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R)
285 {
286 xcb_render_pictdepth_iterator_t i;
287 i.data = (xcb_render_pictdepth_t *) (R + 1);
288 i.rem = R->num_depths;
289 i.index = (char *) i.data - (char *) R;
290 return i;
291 }
292
293 void
xcb_render_pictscreen_next(xcb_render_pictscreen_iterator_t * i)294 xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i)
295 {
296 xcb_render_pictscreen_t *R = i->data;
297 xcb_generic_iterator_t child;
298 child.data = (xcb_render_pictscreen_t *)(((char *)R) + xcb_render_pictscreen_sizeof(R));
299 i->index = (char *) child.data - (char *) i->data;
300 --i->rem;
301 i->data = (xcb_render_pictscreen_t *) child.data;
302 }
303
304 xcb_generic_iterator_t
xcb_render_pictscreen_end(xcb_render_pictscreen_iterator_t i)305 xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i)
306 {
307 xcb_generic_iterator_t ret;
308 while(i.rem > 0)
309 xcb_render_pictscreen_next(&i);
310 ret.data = i.data;
311 ret.rem = i.rem;
312 ret.index = i.index;
313 return ret;
314 }
315
316 void
xcb_render_indexvalue_next(xcb_render_indexvalue_iterator_t * i)317 xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i)
318 {
319 --i->rem;
320 ++i->data;
321 i->index += sizeof(xcb_render_indexvalue_t);
322 }
323
324 xcb_generic_iterator_t
xcb_render_indexvalue_end(xcb_render_indexvalue_iterator_t i)325 xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i)
326 {
327 xcb_generic_iterator_t ret;
328 ret.data = i.data + i.rem;
329 ret.index = i.index + ((char *) ret.data - (char *) i.data);
330 ret.rem = 0;
331 return ret;
332 }
333
334 void
xcb_render_color_next(xcb_render_color_iterator_t * i)335 xcb_render_color_next (xcb_render_color_iterator_t *i)
336 {
337 --i->rem;
338 ++i->data;
339 i->index += sizeof(xcb_render_color_t);
340 }
341
342 xcb_generic_iterator_t
xcb_render_color_end(xcb_render_color_iterator_t i)343 xcb_render_color_end (xcb_render_color_iterator_t i)
344 {
345 xcb_generic_iterator_t ret;
346 ret.data = i.data + i.rem;
347 ret.index = i.index + ((char *) ret.data - (char *) i.data);
348 ret.rem = 0;
349 return ret;
350 }
351
352 void
xcb_render_pointfix_next(xcb_render_pointfix_iterator_t * i)353 xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i)
354 {
355 --i->rem;
356 ++i->data;
357 i->index += sizeof(xcb_render_pointfix_t);
358 }
359
360 xcb_generic_iterator_t
xcb_render_pointfix_end(xcb_render_pointfix_iterator_t i)361 xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i)
362 {
363 xcb_generic_iterator_t ret;
364 ret.data = i.data + i.rem;
365 ret.index = i.index + ((char *) ret.data - (char *) i.data);
366 ret.rem = 0;
367 return ret;
368 }
369
370 void
xcb_render_linefix_next(xcb_render_linefix_iterator_t * i)371 xcb_render_linefix_next (xcb_render_linefix_iterator_t *i)
372 {
373 --i->rem;
374 ++i->data;
375 i->index += sizeof(xcb_render_linefix_t);
376 }
377
378 xcb_generic_iterator_t
xcb_render_linefix_end(xcb_render_linefix_iterator_t i)379 xcb_render_linefix_end (xcb_render_linefix_iterator_t i)
380 {
381 xcb_generic_iterator_t ret;
382 ret.data = i.data + i.rem;
383 ret.index = i.index + ((char *) ret.data - (char *) i.data);
384 ret.rem = 0;
385 return ret;
386 }
387
388 void
xcb_render_triangle_next(xcb_render_triangle_iterator_t * i)389 xcb_render_triangle_next (xcb_render_triangle_iterator_t *i)
390 {
391 --i->rem;
392 ++i->data;
393 i->index += sizeof(xcb_render_triangle_t);
394 }
395
396 xcb_generic_iterator_t
xcb_render_triangle_end(xcb_render_triangle_iterator_t i)397 xcb_render_triangle_end (xcb_render_triangle_iterator_t i)
398 {
399 xcb_generic_iterator_t ret;
400 ret.data = i.data + i.rem;
401 ret.index = i.index + ((char *) ret.data - (char *) i.data);
402 ret.rem = 0;
403 return ret;
404 }
405
406 void
xcb_render_trapezoid_next(xcb_render_trapezoid_iterator_t * i)407 xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i)
408 {
409 --i->rem;
410 ++i->data;
411 i->index += sizeof(xcb_render_trapezoid_t);
412 }
413
414 xcb_generic_iterator_t
xcb_render_trapezoid_end(xcb_render_trapezoid_iterator_t i)415 xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i)
416 {
417 xcb_generic_iterator_t ret;
418 ret.data = i.data + i.rem;
419 ret.index = i.index + ((char *) ret.data - (char *) i.data);
420 ret.rem = 0;
421 return ret;
422 }
423
424 void
xcb_render_glyphinfo_next(xcb_render_glyphinfo_iterator_t * i)425 xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i)
426 {
427 --i->rem;
428 ++i->data;
429 i->index += sizeof(xcb_render_glyphinfo_t);
430 }
431
432 xcb_generic_iterator_t
xcb_render_glyphinfo_end(xcb_render_glyphinfo_iterator_t i)433 xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i)
434 {
435 xcb_generic_iterator_t ret;
436 ret.data = i.data + i.rem;
437 ret.index = i.index + ((char *) ret.data - (char *) i.data);
438 ret.rem = 0;
439 return ret;
440 }
441
442 xcb_render_query_version_cookie_t
xcb_render_query_version(xcb_connection_t * c,uint32_t client_major_version,uint32_t client_minor_version)443 xcb_render_query_version (xcb_connection_t *c,
444 uint32_t client_major_version,
445 uint32_t client_minor_version)
446 {
447 static const xcb_protocol_request_t xcb_req = {
448 .count = 2,
449 .ext = &xcb_render_id,
450 .opcode = XCB_RENDER_QUERY_VERSION,
451 .isvoid = 0
452 };
453
454 struct iovec xcb_parts[4];
455 xcb_render_query_version_cookie_t xcb_ret;
456 xcb_render_query_version_request_t xcb_out;
457
458 xcb_out.client_major_version = client_major_version;
459 xcb_out.client_minor_version = client_minor_version;
460
461 xcb_parts[2].iov_base = (char *) &xcb_out;
462 xcb_parts[2].iov_len = sizeof(xcb_out);
463 xcb_parts[3].iov_base = 0;
464 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
465
466 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
467 return xcb_ret;
468 }
469
470 xcb_render_query_version_cookie_t
xcb_render_query_version_unchecked(xcb_connection_t * c,uint32_t client_major_version,uint32_t client_minor_version)471 xcb_render_query_version_unchecked (xcb_connection_t *c,
472 uint32_t client_major_version,
473 uint32_t client_minor_version)
474 {
475 static const xcb_protocol_request_t xcb_req = {
476 .count = 2,
477 .ext = &xcb_render_id,
478 .opcode = XCB_RENDER_QUERY_VERSION,
479 .isvoid = 0
480 };
481
482 struct iovec xcb_parts[4];
483 xcb_render_query_version_cookie_t xcb_ret;
484 xcb_render_query_version_request_t xcb_out;
485
486 xcb_out.client_major_version = client_major_version;
487 xcb_out.client_minor_version = client_minor_version;
488
489 xcb_parts[2].iov_base = (char *) &xcb_out;
490 xcb_parts[2].iov_len = sizeof(xcb_out);
491 xcb_parts[3].iov_base = 0;
492 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
493
494 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
495 return xcb_ret;
496 }
497
498 xcb_render_query_version_reply_t *
xcb_render_query_version_reply(xcb_connection_t * c,xcb_render_query_version_cookie_t cookie,xcb_generic_error_t ** e)499 xcb_render_query_version_reply (xcb_connection_t *c,
500 xcb_render_query_version_cookie_t cookie /**< */,
501 xcb_generic_error_t **e)
502 {
503 return (xcb_render_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
504 }
505
506 int
xcb_render_query_pict_formats_sizeof(const void * _buffer)507 xcb_render_query_pict_formats_sizeof (const void *_buffer)
508 {
509 char *xcb_tmp = (char *)_buffer;
510 const xcb_render_query_pict_formats_reply_t *_aux = (xcb_render_query_pict_formats_reply_t *)_buffer;
511 unsigned int xcb_buffer_len = 0;
512 unsigned int xcb_block_len = 0;
513 unsigned int xcb_pad = 0;
514 unsigned int xcb_align_to = 0;
515
516 unsigned int i;
517 unsigned int xcb_tmp_len;
518
519 xcb_block_len += sizeof(xcb_render_query_pict_formats_reply_t);
520 xcb_tmp += xcb_block_len;
521 xcb_buffer_len += xcb_block_len;
522 xcb_block_len = 0;
523 /* formats */
524 xcb_block_len += _aux->num_formats * sizeof(xcb_render_pictforminfo_t);
525 xcb_tmp += xcb_block_len;
526 xcb_align_to = ALIGNOF(xcb_render_pictforminfo_t);
527 /* insert padding */
528 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
529 xcb_buffer_len += xcb_block_len + xcb_pad;
530 if (0 != xcb_pad) {
531 xcb_tmp += xcb_pad;
532 xcb_pad = 0;
533 }
534 xcb_block_len = 0;
535 /* screens */
536 for(i=0; i<_aux->num_screens; i++) {
537 xcb_tmp_len = xcb_render_pictscreen_sizeof(xcb_tmp);
538 xcb_block_len += xcb_tmp_len;
539 xcb_tmp += xcb_tmp_len;
540 }
541 xcb_align_to = ALIGNOF(xcb_render_pictscreen_t);
542 /* insert padding */
543 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
544 xcb_buffer_len += xcb_block_len + xcb_pad;
545 if (0 != xcb_pad) {
546 xcb_tmp += xcb_pad;
547 xcb_pad = 0;
548 }
549 xcb_block_len = 0;
550 /* subpixels */
551 xcb_block_len += _aux->num_subpixel * sizeof(uint32_t);
552 xcb_tmp += xcb_block_len;
553 xcb_align_to = ALIGNOF(uint32_t);
554 /* insert padding */
555 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
556 xcb_buffer_len += xcb_block_len + xcb_pad;
557 if (0 != xcb_pad) {
558 xcb_tmp += xcb_pad;
559 xcb_pad = 0;
560 }
561 xcb_block_len = 0;
562
563 return xcb_buffer_len;
564 }
565
566 xcb_render_query_pict_formats_cookie_t
xcb_render_query_pict_formats(xcb_connection_t * c)567 xcb_render_query_pict_formats (xcb_connection_t *c)
568 {
569 static const xcb_protocol_request_t xcb_req = {
570 .count = 2,
571 .ext = &xcb_render_id,
572 .opcode = XCB_RENDER_QUERY_PICT_FORMATS,
573 .isvoid = 0
574 };
575
576 struct iovec xcb_parts[4];
577 xcb_render_query_pict_formats_cookie_t xcb_ret;
578 xcb_render_query_pict_formats_request_t xcb_out;
579
580
581 xcb_parts[2].iov_base = (char *) &xcb_out;
582 xcb_parts[2].iov_len = sizeof(xcb_out);
583 xcb_parts[3].iov_base = 0;
584 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
585
586 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
587 return xcb_ret;
588 }
589
590 xcb_render_query_pict_formats_cookie_t
xcb_render_query_pict_formats_unchecked(xcb_connection_t * c)591 xcb_render_query_pict_formats_unchecked (xcb_connection_t *c)
592 {
593 static const xcb_protocol_request_t xcb_req = {
594 .count = 2,
595 .ext = &xcb_render_id,
596 .opcode = XCB_RENDER_QUERY_PICT_FORMATS,
597 .isvoid = 0
598 };
599
600 struct iovec xcb_parts[4];
601 xcb_render_query_pict_formats_cookie_t xcb_ret;
602 xcb_render_query_pict_formats_request_t xcb_out;
603
604
605 xcb_parts[2].iov_base = (char *) &xcb_out;
606 xcb_parts[2].iov_len = sizeof(xcb_out);
607 xcb_parts[3].iov_base = 0;
608 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
609
610 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
611 return xcb_ret;
612 }
613
614 xcb_render_pictforminfo_t *
xcb_render_query_pict_formats_formats(const xcb_render_query_pict_formats_reply_t * R)615 xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R)
616 {
617 return (xcb_render_pictforminfo_t *) (R + 1);
618 }
619
620 int
xcb_render_query_pict_formats_formats_length(const xcb_render_query_pict_formats_reply_t * R)621 xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R)
622 {
623 return R->num_formats;
624 }
625
626 xcb_render_pictforminfo_iterator_t
xcb_render_query_pict_formats_formats_iterator(const xcb_render_query_pict_formats_reply_t * R)627 xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R)
628 {
629 xcb_render_pictforminfo_iterator_t i;
630 i.data = (xcb_render_pictforminfo_t *) (R + 1);
631 i.rem = R->num_formats;
632 i.index = (char *) i.data - (char *) R;
633 return i;
634 }
635
636 int
xcb_render_query_pict_formats_screens_length(const xcb_render_query_pict_formats_reply_t * R)637 xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R)
638 {
639 return R->num_screens;
640 }
641
642 xcb_render_pictscreen_iterator_t
xcb_render_query_pict_formats_screens_iterator(const xcb_render_query_pict_formats_reply_t * R)643 xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R)
644 {
645 xcb_render_pictscreen_iterator_t i;
646 xcb_generic_iterator_t prev = xcb_render_pictforminfo_end(xcb_render_query_pict_formats_formats_iterator(R));
647 i.data = (xcb_render_pictscreen_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_pictscreen_t, prev.index));
648 i.rem = R->num_screens;
649 i.index = (char *) i.data - (char *) R;
650 return i;
651 }
652
653 uint32_t *
xcb_render_query_pict_formats_subpixels(const xcb_render_query_pict_formats_reply_t * R)654 xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R)
655 {
656 xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R));
657 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
658 }
659
660 int
xcb_render_query_pict_formats_subpixels_length(const xcb_render_query_pict_formats_reply_t * R)661 xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R)
662 {
663 return R->num_subpixel;
664 }
665
666 xcb_generic_iterator_t
xcb_render_query_pict_formats_subpixels_end(const xcb_render_query_pict_formats_reply_t * R)667 xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R)
668 {
669 xcb_generic_iterator_t i;
670 xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R));
671 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_subpixel);
672 i.rem = 0;
673 i.index = (char *) i.data - (char *) R;
674 return i;
675 }
676
677 xcb_render_query_pict_formats_reply_t *
xcb_render_query_pict_formats_reply(xcb_connection_t * c,xcb_render_query_pict_formats_cookie_t cookie,xcb_generic_error_t ** e)678 xcb_render_query_pict_formats_reply (xcb_connection_t *c,
679 xcb_render_query_pict_formats_cookie_t cookie /**< */,
680 xcb_generic_error_t **e)
681 {
682 return (xcb_render_query_pict_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
683 }
684
685 int
xcb_render_query_pict_index_values_sizeof(const void * _buffer)686 xcb_render_query_pict_index_values_sizeof (const void *_buffer)
687 {
688 char *xcb_tmp = (char *)_buffer;
689 const xcb_render_query_pict_index_values_reply_t *_aux = (xcb_render_query_pict_index_values_reply_t *)_buffer;
690 unsigned int xcb_buffer_len = 0;
691 unsigned int xcb_block_len = 0;
692 unsigned int xcb_pad = 0;
693 unsigned int xcb_align_to = 0;
694
695
696 xcb_block_len += sizeof(xcb_render_query_pict_index_values_reply_t);
697 xcb_tmp += xcb_block_len;
698 xcb_buffer_len += xcb_block_len;
699 xcb_block_len = 0;
700 /* values */
701 xcb_block_len += _aux->num_values * sizeof(xcb_render_indexvalue_t);
702 xcb_tmp += xcb_block_len;
703 xcb_align_to = ALIGNOF(xcb_render_indexvalue_t);
704 /* insert padding */
705 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
706 xcb_buffer_len += xcb_block_len + xcb_pad;
707 if (0 != xcb_pad) {
708 xcb_tmp += xcb_pad;
709 xcb_pad = 0;
710 }
711 xcb_block_len = 0;
712
713 return xcb_buffer_len;
714 }
715
716 xcb_render_query_pict_index_values_cookie_t
xcb_render_query_pict_index_values(xcb_connection_t * c,xcb_render_pictformat_t format)717 xcb_render_query_pict_index_values (xcb_connection_t *c,
718 xcb_render_pictformat_t format)
719 {
720 static const xcb_protocol_request_t xcb_req = {
721 .count = 2,
722 .ext = &xcb_render_id,
723 .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES,
724 .isvoid = 0
725 };
726
727 struct iovec xcb_parts[4];
728 xcb_render_query_pict_index_values_cookie_t xcb_ret;
729 xcb_render_query_pict_index_values_request_t xcb_out;
730
731 xcb_out.format = format;
732
733 xcb_parts[2].iov_base = (char *) &xcb_out;
734 xcb_parts[2].iov_len = sizeof(xcb_out);
735 xcb_parts[3].iov_base = 0;
736 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
737
738 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
739 return xcb_ret;
740 }
741
742 xcb_render_query_pict_index_values_cookie_t
xcb_render_query_pict_index_values_unchecked(xcb_connection_t * c,xcb_render_pictformat_t format)743 xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c,
744 xcb_render_pictformat_t format)
745 {
746 static const xcb_protocol_request_t xcb_req = {
747 .count = 2,
748 .ext = &xcb_render_id,
749 .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES,
750 .isvoid = 0
751 };
752
753 struct iovec xcb_parts[4];
754 xcb_render_query_pict_index_values_cookie_t xcb_ret;
755 xcb_render_query_pict_index_values_request_t xcb_out;
756
757 xcb_out.format = format;
758
759 xcb_parts[2].iov_base = (char *) &xcb_out;
760 xcb_parts[2].iov_len = sizeof(xcb_out);
761 xcb_parts[3].iov_base = 0;
762 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
763
764 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
765 return xcb_ret;
766 }
767
768 xcb_render_indexvalue_t *
xcb_render_query_pict_index_values_values(const xcb_render_query_pict_index_values_reply_t * R)769 xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R)
770 {
771 return (xcb_render_indexvalue_t *) (R + 1);
772 }
773
774 int
xcb_render_query_pict_index_values_values_length(const xcb_render_query_pict_index_values_reply_t * R)775 xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R)
776 {
777 return R->num_values;
778 }
779
780 xcb_render_indexvalue_iterator_t
xcb_render_query_pict_index_values_values_iterator(const xcb_render_query_pict_index_values_reply_t * R)781 xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R)
782 {
783 xcb_render_indexvalue_iterator_t i;
784 i.data = (xcb_render_indexvalue_t *) (R + 1);
785 i.rem = R->num_values;
786 i.index = (char *) i.data - (char *) R;
787 return i;
788 }
789
790 xcb_render_query_pict_index_values_reply_t *
xcb_render_query_pict_index_values_reply(xcb_connection_t * c,xcb_render_query_pict_index_values_cookie_t cookie,xcb_generic_error_t ** e)791 xcb_render_query_pict_index_values_reply (xcb_connection_t *c,
792 xcb_render_query_pict_index_values_cookie_t cookie /**< */,
793 xcb_generic_error_t **e)
794 {
795 return (xcb_render_query_pict_index_values_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
796 }
797
798 int
xcb_render_create_picture_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_render_create_picture_value_list_t * _aux)799 xcb_render_create_picture_value_list_serialize (void **_buffer,
800 uint32_t value_mask,
801 const xcb_render_create_picture_value_list_t *_aux)
802 {
803 char *xcb_out = *_buffer;
804 unsigned int xcb_buffer_len = 0;
805 unsigned int xcb_align_to = 0;
806 unsigned int xcb_padding_offset = 0;
807
808 unsigned int xcb_pad = 0;
809 char xcb_pad0[3] = {0, 0, 0};
810 struct iovec xcb_parts[14];
811 unsigned int xcb_parts_idx = 0;
812 unsigned int xcb_block_len = 0;
813 unsigned int i;
814 char *xcb_tmp;
815
816 if(value_mask & XCB_RENDER_CP_REPEAT) {
817 /* xcb_render_create_picture_value_list_t.repeat */
818 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat;
819 xcb_block_len += sizeof(uint32_t);
820 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
821 xcb_parts_idx++;
822 xcb_align_to = ALIGNOF(uint32_t);
823 }
824 if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
825 /* xcb_render_create_picture_value_list_t.alphamap */
826 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap;
827 xcb_block_len += sizeof(xcb_render_picture_t);
828 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t);
829 xcb_parts_idx++;
830 xcb_align_to = ALIGNOF(xcb_render_picture_t);
831 }
832 if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
833 /* xcb_render_create_picture_value_list_t.alphaxorigin */
834 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin;
835 xcb_block_len += sizeof(int32_t);
836 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
837 xcb_parts_idx++;
838 xcb_align_to = ALIGNOF(int32_t);
839 }
840 if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
841 /* xcb_render_create_picture_value_list_t.alphayorigin */
842 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin;
843 xcb_block_len += sizeof(int32_t);
844 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
845 xcb_parts_idx++;
846 xcb_align_to = ALIGNOF(int32_t);
847 }
848 if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
849 /* xcb_render_create_picture_value_list_t.clipxorigin */
850 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin;
851 xcb_block_len += sizeof(int32_t);
852 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
853 xcb_parts_idx++;
854 xcb_align_to = ALIGNOF(int32_t);
855 }
856 if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
857 /* xcb_render_create_picture_value_list_t.clipyorigin */
858 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin;
859 xcb_block_len += sizeof(int32_t);
860 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
861 xcb_parts_idx++;
862 xcb_align_to = ALIGNOF(int32_t);
863 }
864 if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
865 /* xcb_render_create_picture_value_list_t.clipmask */
866 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask;
867 xcb_block_len += sizeof(xcb_pixmap_t);
868 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
869 xcb_parts_idx++;
870 xcb_align_to = ALIGNOF(xcb_pixmap_t);
871 }
872 if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
873 /* xcb_render_create_picture_value_list_t.graphicsexposure */
874 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure;
875 xcb_block_len += sizeof(uint32_t);
876 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
877 xcb_parts_idx++;
878 xcb_align_to = ALIGNOF(uint32_t);
879 }
880 if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
881 /* xcb_render_create_picture_value_list_t.subwindowmode */
882 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode;
883 xcb_block_len += sizeof(uint32_t);
884 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
885 xcb_parts_idx++;
886 xcb_align_to = ALIGNOF(uint32_t);
887 }
888 if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
889 /* xcb_render_create_picture_value_list_t.polyedge */
890 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge;
891 xcb_block_len += sizeof(uint32_t);
892 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
893 xcb_parts_idx++;
894 xcb_align_to = ALIGNOF(uint32_t);
895 }
896 if(value_mask & XCB_RENDER_CP_POLY_MODE) {
897 /* xcb_render_create_picture_value_list_t.polymode */
898 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode;
899 xcb_block_len += sizeof(uint32_t);
900 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
901 xcb_parts_idx++;
902 xcb_align_to = ALIGNOF(uint32_t);
903 }
904 if(value_mask & XCB_RENDER_CP_DITHER) {
905 /* xcb_render_create_picture_value_list_t.dither */
906 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither;
907 xcb_block_len += sizeof(xcb_atom_t);
908 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
909 xcb_parts_idx++;
910 xcb_align_to = ALIGNOF(xcb_atom_t);
911 }
912 if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
913 /* xcb_render_create_picture_value_list_t.componentalpha */
914 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha;
915 xcb_block_len += sizeof(uint32_t);
916 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
917 xcb_parts_idx++;
918 xcb_align_to = ALIGNOF(uint32_t);
919 }
920 /* insert padding */
921 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
922 xcb_buffer_len += xcb_block_len + xcb_pad;
923 if (0 != xcb_pad) {
924 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
925 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
926 xcb_parts_idx++;
927 xcb_pad = 0;
928 }
929 xcb_block_len = 0;
930 xcb_padding_offset = 0;
931
932 if (NULL == xcb_out) {
933 /* allocate memory */
934 xcb_out = malloc(xcb_buffer_len);
935 *_buffer = xcb_out;
936 }
937
938 xcb_tmp = xcb_out;
939 for(i=0; i<xcb_parts_idx; i++) {
940 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
941 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
942 if (0 != xcb_parts[i].iov_len)
943 xcb_tmp += xcb_parts[i].iov_len;
944 }
945
946 return xcb_buffer_len;
947 }
948
949 int
xcb_render_create_picture_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_render_create_picture_value_list_t * _aux)950 xcb_render_create_picture_value_list_unpack (const void *_buffer,
951 uint32_t value_mask,
952 xcb_render_create_picture_value_list_t *_aux)
953 {
954 char *xcb_tmp = (char *)_buffer;
955 unsigned int xcb_buffer_len = 0;
956 unsigned int xcb_block_len = 0;
957 unsigned int xcb_pad = 0;
958 unsigned int xcb_align_to = 0;
959 unsigned int xcb_padding_offset = 0;
960
961
962 if(value_mask & XCB_RENDER_CP_REPEAT) {
963 /* xcb_render_create_picture_value_list_t.repeat */
964 _aux->repeat = *(uint32_t *)xcb_tmp;
965 xcb_block_len += sizeof(uint32_t);
966 xcb_tmp += sizeof(uint32_t);
967 xcb_align_to = ALIGNOF(uint32_t);
968 }
969 if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
970 /* xcb_render_create_picture_value_list_t.alphamap */
971 _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp;
972 xcb_block_len += sizeof(xcb_render_picture_t);
973 xcb_tmp += sizeof(xcb_render_picture_t);
974 xcb_align_to = ALIGNOF(xcb_render_picture_t);
975 }
976 if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
977 /* xcb_render_create_picture_value_list_t.alphaxorigin */
978 _aux->alphaxorigin = *(int32_t *)xcb_tmp;
979 xcb_block_len += sizeof(int32_t);
980 xcb_tmp += sizeof(int32_t);
981 xcb_align_to = ALIGNOF(int32_t);
982 }
983 if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
984 /* xcb_render_create_picture_value_list_t.alphayorigin */
985 _aux->alphayorigin = *(int32_t *)xcb_tmp;
986 xcb_block_len += sizeof(int32_t);
987 xcb_tmp += sizeof(int32_t);
988 xcb_align_to = ALIGNOF(int32_t);
989 }
990 if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
991 /* xcb_render_create_picture_value_list_t.clipxorigin */
992 _aux->clipxorigin = *(int32_t *)xcb_tmp;
993 xcb_block_len += sizeof(int32_t);
994 xcb_tmp += sizeof(int32_t);
995 xcb_align_to = ALIGNOF(int32_t);
996 }
997 if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
998 /* xcb_render_create_picture_value_list_t.clipyorigin */
999 _aux->clipyorigin = *(int32_t *)xcb_tmp;
1000 xcb_block_len += sizeof(int32_t);
1001 xcb_tmp += sizeof(int32_t);
1002 xcb_align_to = ALIGNOF(int32_t);
1003 }
1004 if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
1005 /* xcb_render_create_picture_value_list_t.clipmask */
1006 _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp;
1007 xcb_block_len += sizeof(xcb_pixmap_t);
1008 xcb_tmp += sizeof(xcb_pixmap_t);
1009 xcb_align_to = ALIGNOF(xcb_pixmap_t);
1010 }
1011 if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
1012 /* xcb_render_create_picture_value_list_t.graphicsexposure */
1013 _aux->graphicsexposure = *(uint32_t *)xcb_tmp;
1014 xcb_block_len += sizeof(uint32_t);
1015 xcb_tmp += sizeof(uint32_t);
1016 xcb_align_to = ALIGNOF(uint32_t);
1017 }
1018 if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
1019 /* xcb_render_create_picture_value_list_t.subwindowmode */
1020 _aux->subwindowmode = *(uint32_t *)xcb_tmp;
1021 xcb_block_len += sizeof(uint32_t);
1022 xcb_tmp += sizeof(uint32_t);
1023 xcb_align_to = ALIGNOF(uint32_t);
1024 }
1025 if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
1026 /* xcb_render_create_picture_value_list_t.polyedge */
1027 _aux->polyedge = *(uint32_t *)xcb_tmp;
1028 xcb_block_len += sizeof(uint32_t);
1029 xcb_tmp += sizeof(uint32_t);
1030 xcb_align_to = ALIGNOF(uint32_t);
1031 }
1032 if(value_mask & XCB_RENDER_CP_POLY_MODE) {
1033 /* xcb_render_create_picture_value_list_t.polymode */
1034 _aux->polymode = *(uint32_t *)xcb_tmp;
1035 xcb_block_len += sizeof(uint32_t);
1036 xcb_tmp += sizeof(uint32_t);
1037 xcb_align_to = ALIGNOF(uint32_t);
1038 }
1039 if(value_mask & XCB_RENDER_CP_DITHER) {
1040 /* xcb_render_create_picture_value_list_t.dither */
1041 _aux->dither = *(xcb_atom_t *)xcb_tmp;
1042 xcb_block_len += sizeof(xcb_atom_t);
1043 xcb_tmp += sizeof(xcb_atom_t);
1044 xcb_align_to = ALIGNOF(xcb_atom_t);
1045 }
1046 if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
1047 /* xcb_render_create_picture_value_list_t.componentalpha */
1048 _aux->componentalpha = *(uint32_t *)xcb_tmp;
1049 xcb_block_len += sizeof(uint32_t);
1050 xcb_tmp += sizeof(uint32_t);
1051 xcb_align_to = ALIGNOF(uint32_t);
1052 }
1053 /* insert padding */
1054 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1055 xcb_buffer_len += xcb_block_len + xcb_pad;
1056 if (0 != xcb_pad) {
1057 xcb_tmp += xcb_pad;
1058 xcb_pad = 0;
1059 }
1060 xcb_block_len = 0;
1061 xcb_padding_offset = 0;
1062
1063 return xcb_buffer_len;
1064 }
1065
1066 int
xcb_render_create_picture_value_list_sizeof(const void * _buffer,uint32_t value_mask)1067 xcb_render_create_picture_value_list_sizeof (const void *_buffer,
1068 uint32_t value_mask)
1069 {
1070 xcb_render_create_picture_value_list_t _aux;
1071 return xcb_render_create_picture_value_list_unpack(_buffer, value_mask, &_aux);
1072 }
1073
1074 int
xcb_render_create_picture_sizeof(const void * _buffer)1075 xcb_render_create_picture_sizeof (const void *_buffer)
1076 {
1077 char *xcb_tmp = (char *)_buffer;
1078 const xcb_render_create_picture_request_t *_aux = (xcb_render_create_picture_request_t *)_buffer;
1079 unsigned int xcb_buffer_len = 0;
1080 unsigned int xcb_block_len = 0;
1081 unsigned int xcb_pad = 0;
1082 unsigned int xcb_align_to = 0;
1083
1084
1085 xcb_block_len += sizeof(xcb_render_create_picture_request_t);
1086 xcb_tmp += xcb_block_len;
1087 xcb_buffer_len += xcb_block_len;
1088 xcb_block_len = 0;
1089 /* value_list */
1090 xcb_block_len += xcb_render_create_picture_value_list_sizeof(xcb_tmp, _aux->value_mask);
1091 xcb_tmp += xcb_block_len;
1092 xcb_align_to = ALIGNOF(char);
1093 /* insert padding */
1094 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1095 xcb_buffer_len += xcb_block_len + xcb_pad;
1096 if (0 != xcb_pad) {
1097 xcb_tmp += xcb_pad;
1098 xcb_pad = 0;
1099 }
1100 xcb_block_len = 0;
1101
1102 return xcb_buffer_len;
1103 }
1104
1105 xcb_void_cookie_t
xcb_render_create_picture_checked(xcb_connection_t * c,xcb_render_picture_t pid,xcb_drawable_t drawable,xcb_render_pictformat_t format,uint32_t value_mask,const void * value_list)1106 xcb_render_create_picture_checked (xcb_connection_t *c,
1107 xcb_render_picture_t pid,
1108 xcb_drawable_t drawable,
1109 xcb_render_pictformat_t format,
1110 uint32_t value_mask,
1111 const void *value_list)
1112 {
1113 static const xcb_protocol_request_t xcb_req = {
1114 .count = 3,
1115 .ext = &xcb_render_id,
1116 .opcode = XCB_RENDER_CREATE_PICTURE,
1117 .isvoid = 1
1118 };
1119
1120 struct iovec xcb_parts[5];
1121 xcb_void_cookie_t xcb_ret;
1122 xcb_render_create_picture_request_t xcb_out;
1123
1124 xcb_out.pid = pid;
1125 xcb_out.drawable = drawable;
1126 xcb_out.format = format;
1127 xcb_out.value_mask = value_mask;
1128
1129 xcb_parts[2].iov_base = (char *) &xcb_out;
1130 xcb_parts[2].iov_len = sizeof(xcb_out);
1131 xcb_parts[3].iov_base = 0;
1132 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1133 /* xcb_render_create_picture_value_list_t value_list */
1134 xcb_parts[4].iov_base = (char *) value_list;
1135 xcb_parts[4].iov_len =
1136 xcb_render_create_picture_value_list_sizeof (value_list, value_mask);
1137
1138 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1139 return xcb_ret;
1140 }
1141
1142 xcb_void_cookie_t
xcb_render_create_picture(xcb_connection_t * c,xcb_render_picture_t pid,xcb_drawable_t drawable,xcb_render_pictformat_t format,uint32_t value_mask,const void * value_list)1143 xcb_render_create_picture (xcb_connection_t *c,
1144 xcb_render_picture_t pid,
1145 xcb_drawable_t drawable,
1146 xcb_render_pictformat_t format,
1147 uint32_t value_mask,
1148 const void *value_list)
1149 {
1150 static const xcb_protocol_request_t xcb_req = {
1151 .count = 3,
1152 .ext = &xcb_render_id,
1153 .opcode = XCB_RENDER_CREATE_PICTURE,
1154 .isvoid = 1
1155 };
1156
1157 struct iovec xcb_parts[5];
1158 xcb_void_cookie_t xcb_ret;
1159 xcb_render_create_picture_request_t xcb_out;
1160
1161 xcb_out.pid = pid;
1162 xcb_out.drawable = drawable;
1163 xcb_out.format = format;
1164 xcb_out.value_mask = value_mask;
1165
1166 xcb_parts[2].iov_base = (char *) &xcb_out;
1167 xcb_parts[2].iov_len = sizeof(xcb_out);
1168 xcb_parts[3].iov_base = 0;
1169 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1170 /* xcb_render_create_picture_value_list_t value_list */
1171 xcb_parts[4].iov_base = (char *) value_list;
1172 xcb_parts[4].iov_len =
1173 xcb_render_create_picture_value_list_sizeof (value_list, value_mask);
1174
1175 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1176 return xcb_ret;
1177 }
1178
1179 xcb_void_cookie_t
xcb_render_create_picture_aux_checked(xcb_connection_t * c,xcb_render_picture_t pid,xcb_drawable_t drawable,xcb_render_pictformat_t format,uint32_t value_mask,const xcb_render_create_picture_value_list_t * value_list)1180 xcb_render_create_picture_aux_checked (xcb_connection_t *c,
1181 xcb_render_picture_t pid,
1182 xcb_drawable_t drawable,
1183 xcb_render_pictformat_t format,
1184 uint32_t value_mask,
1185 const xcb_render_create_picture_value_list_t *value_list)
1186 {
1187 static const xcb_protocol_request_t xcb_req = {
1188 .count = 3,
1189 .ext = &xcb_render_id,
1190 .opcode = XCB_RENDER_CREATE_PICTURE,
1191 .isvoid = 1
1192 };
1193
1194 struct iovec xcb_parts[5];
1195 xcb_void_cookie_t xcb_ret;
1196 xcb_render_create_picture_request_t xcb_out;
1197 void *xcb_aux0 = 0;
1198
1199 xcb_out.pid = pid;
1200 xcb_out.drawable = drawable;
1201 xcb_out.format = format;
1202 xcb_out.value_mask = value_mask;
1203
1204 xcb_parts[2].iov_base = (char *) &xcb_out;
1205 xcb_parts[2].iov_len = sizeof(xcb_out);
1206 xcb_parts[3].iov_base = 0;
1207 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1208 /* xcb_render_create_picture_value_list_t value_list */
1209 xcb_parts[4].iov_len =
1210 xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
1211 xcb_parts[4].iov_base = xcb_aux0;
1212
1213 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1214 free(xcb_aux0);
1215 return xcb_ret;
1216 }
1217
1218 xcb_void_cookie_t
xcb_render_create_picture_aux(xcb_connection_t * c,xcb_render_picture_t pid,xcb_drawable_t drawable,xcb_render_pictformat_t format,uint32_t value_mask,const xcb_render_create_picture_value_list_t * value_list)1219 xcb_render_create_picture_aux (xcb_connection_t *c,
1220 xcb_render_picture_t pid,
1221 xcb_drawable_t drawable,
1222 xcb_render_pictformat_t format,
1223 uint32_t value_mask,
1224 const xcb_render_create_picture_value_list_t *value_list)
1225 {
1226 static const xcb_protocol_request_t xcb_req = {
1227 .count = 3,
1228 .ext = &xcb_render_id,
1229 .opcode = XCB_RENDER_CREATE_PICTURE,
1230 .isvoid = 1
1231 };
1232
1233 struct iovec xcb_parts[5];
1234 xcb_void_cookie_t xcb_ret;
1235 xcb_render_create_picture_request_t xcb_out;
1236 void *xcb_aux0 = 0;
1237
1238 xcb_out.pid = pid;
1239 xcb_out.drawable = drawable;
1240 xcb_out.format = format;
1241 xcb_out.value_mask = value_mask;
1242
1243 xcb_parts[2].iov_base = (char *) &xcb_out;
1244 xcb_parts[2].iov_len = sizeof(xcb_out);
1245 xcb_parts[3].iov_base = 0;
1246 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1247 /* xcb_render_create_picture_value_list_t value_list */
1248 xcb_parts[4].iov_len =
1249 xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
1250 xcb_parts[4].iov_base = xcb_aux0;
1251
1252 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1253 free(xcb_aux0);
1254 return xcb_ret;
1255 }
1256
1257 void *
xcb_render_create_picture_value_list(const xcb_render_create_picture_request_t * R)1258 xcb_render_create_picture_value_list (const xcb_render_create_picture_request_t *R)
1259 {
1260 return (void *) (R + 1);
1261 }
1262
1263 int
xcb_render_change_picture_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_render_change_picture_value_list_t * _aux)1264 xcb_render_change_picture_value_list_serialize (void **_buffer,
1265 uint32_t value_mask,
1266 const xcb_render_change_picture_value_list_t *_aux)
1267 {
1268 char *xcb_out = *_buffer;
1269 unsigned int xcb_buffer_len = 0;
1270 unsigned int xcb_align_to = 0;
1271 unsigned int xcb_padding_offset = 0;
1272
1273 unsigned int xcb_pad = 0;
1274 char xcb_pad0[3] = {0, 0, 0};
1275 struct iovec xcb_parts[14];
1276 unsigned int xcb_parts_idx = 0;
1277 unsigned int xcb_block_len = 0;
1278 unsigned int i;
1279 char *xcb_tmp;
1280
1281 if(value_mask & XCB_RENDER_CP_REPEAT) {
1282 /* xcb_render_change_picture_value_list_t.repeat */
1283 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat;
1284 xcb_block_len += sizeof(uint32_t);
1285 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1286 xcb_parts_idx++;
1287 xcb_align_to = ALIGNOF(uint32_t);
1288 }
1289 if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
1290 /* xcb_render_change_picture_value_list_t.alphamap */
1291 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap;
1292 xcb_block_len += sizeof(xcb_render_picture_t);
1293 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t);
1294 xcb_parts_idx++;
1295 xcb_align_to = ALIGNOF(xcb_render_picture_t);
1296 }
1297 if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
1298 /* xcb_render_change_picture_value_list_t.alphaxorigin */
1299 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin;
1300 xcb_block_len += sizeof(int32_t);
1301 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
1302 xcb_parts_idx++;
1303 xcb_align_to = ALIGNOF(int32_t);
1304 }
1305 if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
1306 /* xcb_render_change_picture_value_list_t.alphayorigin */
1307 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin;
1308 xcb_block_len += sizeof(int32_t);
1309 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
1310 xcb_parts_idx++;
1311 xcb_align_to = ALIGNOF(int32_t);
1312 }
1313 if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
1314 /* xcb_render_change_picture_value_list_t.clipxorigin */
1315 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin;
1316 xcb_block_len += sizeof(int32_t);
1317 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
1318 xcb_parts_idx++;
1319 xcb_align_to = ALIGNOF(int32_t);
1320 }
1321 if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
1322 /* xcb_render_change_picture_value_list_t.clipyorigin */
1323 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin;
1324 xcb_block_len += sizeof(int32_t);
1325 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
1326 xcb_parts_idx++;
1327 xcb_align_to = ALIGNOF(int32_t);
1328 }
1329 if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
1330 /* xcb_render_change_picture_value_list_t.clipmask */
1331 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask;
1332 xcb_block_len += sizeof(xcb_pixmap_t);
1333 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
1334 xcb_parts_idx++;
1335 xcb_align_to = ALIGNOF(xcb_pixmap_t);
1336 }
1337 if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
1338 /* xcb_render_change_picture_value_list_t.graphicsexposure */
1339 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure;
1340 xcb_block_len += sizeof(uint32_t);
1341 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1342 xcb_parts_idx++;
1343 xcb_align_to = ALIGNOF(uint32_t);
1344 }
1345 if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
1346 /* xcb_render_change_picture_value_list_t.subwindowmode */
1347 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode;
1348 xcb_block_len += sizeof(uint32_t);
1349 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1350 xcb_parts_idx++;
1351 xcb_align_to = ALIGNOF(uint32_t);
1352 }
1353 if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
1354 /* xcb_render_change_picture_value_list_t.polyedge */
1355 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge;
1356 xcb_block_len += sizeof(uint32_t);
1357 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1358 xcb_parts_idx++;
1359 xcb_align_to = ALIGNOF(uint32_t);
1360 }
1361 if(value_mask & XCB_RENDER_CP_POLY_MODE) {
1362 /* xcb_render_change_picture_value_list_t.polymode */
1363 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode;
1364 xcb_block_len += sizeof(uint32_t);
1365 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1366 xcb_parts_idx++;
1367 xcb_align_to = ALIGNOF(uint32_t);
1368 }
1369 if(value_mask & XCB_RENDER_CP_DITHER) {
1370 /* xcb_render_change_picture_value_list_t.dither */
1371 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither;
1372 xcb_block_len += sizeof(xcb_atom_t);
1373 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
1374 xcb_parts_idx++;
1375 xcb_align_to = ALIGNOF(xcb_atom_t);
1376 }
1377 if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
1378 /* xcb_render_change_picture_value_list_t.componentalpha */
1379 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha;
1380 xcb_block_len += sizeof(uint32_t);
1381 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1382 xcb_parts_idx++;
1383 xcb_align_to = ALIGNOF(uint32_t);
1384 }
1385 /* insert padding */
1386 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1387 xcb_buffer_len += xcb_block_len + xcb_pad;
1388 if (0 != xcb_pad) {
1389 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
1390 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
1391 xcb_parts_idx++;
1392 xcb_pad = 0;
1393 }
1394 xcb_block_len = 0;
1395 xcb_padding_offset = 0;
1396
1397 if (NULL == xcb_out) {
1398 /* allocate memory */
1399 xcb_out = malloc(xcb_buffer_len);
1400 *_buffer = xcb_out;
1401 }
1402
1403 xcb_tmp = xcb_out;
1404 for(i=0; i<xcb_parts_idx; i++) {
1405 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
1406 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
1407 if (0 != xcb_parts[i].iov_len)
1408 xcb_tmp += xcb_parts[i].iov_len;
1409 }
1410
1411 return xcb_buffer_len;
1412 }
1413
1414 int
xcb_render_change_picture_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_render_change_picture_value_list_t * _aux)1415 xcb_render_change_picture_value_list_unpack (const void *_buffer,
1416 uint32_t value_mask,
1417 xcb_render_change_picture_value_list_t *_aux)
1418 {
1419 char *xcb_tmp = (char *)_buffer;
1420 unsigned int xcb_buffer_len = 0;
1421 unsigned int xcb_block_len = 0;
1422 unsigned int xcb_pad = 0;
1423 unsigned int xcb_align_to = 0;
1424 unsigned int xcb_padding_offset = 0;
1425
1426
1427 if(value_mask & XCB_RENDER_CP_REPEAT) {
1428 /* xcb_render_change_picture_value_list_t.repeat */
1429 _aux->repeat = *(uint32_t *)xcb_tmp;
1430 xcb_block_len += sizeof(uint32_t);
1431 xcb_tmp += sizeof(uint32_t);
1432 xcb_align_to = ALIGNOF(uint32_t);
1433 }
1434 if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
1435 /* xcb_render_change_picture_value_list_t.alphamap */
1436 _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp;
1437 xcb_block_len += sizeof(xcb_render_picture_t);
1438 xcb_tmp += sizeof(xcb_render_picture_t);
1439 xcb_align_to = ALIGNOF(xcb_render_picture_t);
1440 }
1441 if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
1442 /* xcb_render_change_picture_value_list_t.alphaxorigin */
1443 _aux->alphaxorigin = *(int32_t *)xcb_tmp;
1444 xcb_block_len += sizeof(int32_t);
1445 xcb_tmp += sizeof(int32_t);
1446 xcb_align_to = ALIGNOF(int32_t);
1447 }
1448 if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
1449 /* xcb_render_change_picture_value_list_t.alphayorigin */
1450 _aux->alphayorigin = *(int32_t *)xcb_tmp;
1451 xcb_block_len += sizeof(int32_t);
1452 xcb_tmp += sizeof(int32_t);
1453 xcb_align_to = ALIGNOF(int32_t);
1454 }
1455 if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
1456 /* xcb_render_change_picture_value_list_t.clipxorigin */
1457 _aux->clipxorigin = *(int32_t *)xcb_tmp;
1458 xcb_block_len += sizeof(int32_t);
1459 xcb_tmp += sizeof(int32_t);
1460 xcb_align_to = ALIGNOF(int32_t);
1461 }
1462 if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
1463 /* xcb_render_change_picture_value_list_t.clipyorigin */
1464 _aux->clipyorigin = *(int32_t *)xcb_tmp;
1465 xcb_block_len += sizeof(int32_t);
1466 xcb_tmp += sizeof(int32_t);
1467 xcb_align_to = ALIGNOF(int32_t);
1468 }
1469 if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
1470 /* xcb_render_change_picture_value_list_t.clipmask */
1471 _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp;
1472 xcb_block_len += sizeof(xcb_pixmap_t);
1473 xcb_tmp += sizeof(xcb_pixmap_t);
1474 xcb_align_to = ALIGNOF(xcb_pixmap_t);
1475 }
1476 if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
1477 /* xcb_render_change_picture_value_list_t.graphicsexposure */
1478 _aux->graphicsexposure = *(uint32_t *)xcb_tmp;
1479 xcb_block_len += sizeof(uint32_t);
1480 xcb_tmp += sizeof(uint32_t);
1481 xcb_align_to = ALIGNOF(uint32_t);
1482 }
1483 if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
1484 /* xcb_render_change_picture_value_list_t.subwindowmode */
1485 _aux->subwindowmode = *(uint32_t *)xcb_tmp;
1486 xcb_block_len += sizeof(uint32_t);
1487 xcb_tmp += sizeof(uint32_t);
1488 xcb_align_to = ALIGNOF(uint32_t);
1489 }
1490 if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
1491 /* xcb_render_change_picture_value_list_t.polyedge */
1492 _aux->polyedge = *(uint32_t *)xcb_tmp;
1493 xcb_block_len += sizeof(uint32_t);
1494 xcb_tmp += sizeof(uint32_t);
1495 xcb_align_to = ALIGNOF(uint32_t);
1496 }
1497 if(value_mask & XCB_RENDER_CP_POLY_MODE) {
1498 /* xcb_render_change_picture_value_list_t.polymode */
1499 _aux->polymode = *(uint32_t *)xcb_tmp;
1500 xcb_block_len += sizeof(uint32_t);
1501 xcb_tmp += sizeof(uint32_t);
1502 xcb_align_to = ALIGNOF(uint32_t);
1503 }
1504 if(value_mask & XCB_RENDER_CP_DITHER) {
1505 /* xcb_render_change_picture_value_list_t.dither */
1506 _aux->dither = *(xcb_atom_t *)xcb_tmp;
1507 xcb_block_len += sizeof(xcb_atom_t);
1508 xcb_tmp += sizeof(xcb_atom_t);
1509 xcb_align_to = ALIGNOF(xcb_atom_t);
1510 }
1511 if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
1512 /* xcb_render_change_picture_value_list_t.componentalpha */
1513 _aux->componentalpha = *(uint32_t *)xcb_tmp;
1514 xcb_block_len += sizeof(uint32_t);
1515 xcb_tmp += sizeof(uint32_t);
1516 xcb_align_to = ALIGNOF(uint32_t);
1517 }
1518 /* insert padding */
1519 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1520 xcb_buffer_len += xcb_block_len + xcb_pad;
1521 if (0 != xcb_pad) {
1522 xcb_tmp += xcb_pad;
1523 xcb_pad = 0;
1524 }
1525 xcb_block_len = 0;
1526 xcb_padding_offset = 0;
1527
1528 return xcb_buffer_len;
1529 }
1530
1531 int
xcb_render_change_picture_value_list_sizeof(const void * _buffer,uint32_t value_mask)1532 xcb_render_change_picture_value_list_sizeof (const void *_buffer,
1533 uint32_t value_mask)
1534 {
1535 xcb_render_change_picture_value_list_t _aux;
1536 return xcb_render_change_picture_value_list_unpack(_buffer, value_mask, &_aux);
1537 }
1538
1539 int
xcb_render_change_picture_sizeof(const void * _buffer)1540 xcb_render_change_picture_sizeof (const void *_buffer)
1541 {
1542 char *xcb_tmp = (char *)_buffer;
1543 const xcb_render_change_picture_request_t *_aux = (xcb_render_change_picture_request_t *)_buffer;
1544 unsigned int xcb_buffer_len = 0;
1545 unsigned int xcb_block_len = 0;
1546 unsigned int xcb_pad = 0;
1547 unsigned int xcb_align_to = 0;
1548
1549
1550 xcb_block_len += sizeof(xcb_render_change_picture_request_t);
1551 xcb_tmp += xcb_block_len;
1552 xcb_buffer_len += xcb_block_len;
1553 xcb_block_len = 0;
1554 /* value_list */
1555 xcb_block_len += xcb_render_change_picture_value_list_sizeof(xcb_tmp, _aux->value_mask);
1556 xcb_tmp += xcb_block_len;
1557 xcb_align_to = ALIGNOF(char);
1558 /* insert padding */
1559 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1560 xcb_buffer_len += xcb_block_len + xcb_pad;
1561 if (0 != xcb_pad) {
1562 xcb_tmp += xcb_pad;
1563 xcb_pad = 0;
1564 }
1565 xcb_block_len = 0;
1566
1567 return xcb_buffer_len;
1568 }
1569
1570 xcb_void_cookie_t
xcb_render_change_picture_checked(xcb_connection_t * c,xcb_render_picture_t picture,uint32_t value_mask,const void * value_list)1571 xcb_render_change_picture_checked (xcb_connection_t *c,
1572 xcb_render_picture_t picture,
1573 uint32_t value_mask,
1574 const void *value_list)
1575 {
1576 static const xcb_protocol_request_t xcb_req = {
1577 .count = 3,
1578 .ext = &xcb_render_id,
1579 .opcode = XCB_RENDER_CHANGE_PICTURE,
1580 .isvoid = 1
1581 };
1582
1583 struct iovec xcb_parts[5];
1584 xcb_void_cookie_t xcb_ret;
1585 xcb_render_change_picture_request_t xcb_out;
1586
1587 xcb_out.picture = picture;
1588 xcb_out.value_mask = value_mask;
1589
1590 xcb_parts[2].iov_base = (char *) &xcb_out;
1591 xcb_parts[2].iov_len = sizeof(xcb_out);
1592 xcb_parts[3].iov_base = 0;
1593 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1594 /* xcb_render_change_picture_value_list_t value_list */
1595 xcb_parts[4].iov_base = (char *) value_list;
1596 xcb_parts[4].iov_len =
1597 xcb_render_change_picture_value_list_sizeof (value_list, value_mask);
1598
1599 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1600 return xcb_ret;
1601 }
1602
1603 xcb_void_cookie_t
xcb_render_change_picture(xcb_connection_t * c,xcb_render_picture_t picture,uint32_t value_mask,const void * value_list)1604 xcb_render_change_picture (xcb_connection_t *c,
1605 xcb_render_picture_t picture,
1606 uint32_t value_mask,
1607 const void *value_list)
1608 {
1609 static const xcb_protocol_request_t xcb_req = {
1610 .count = 3,
1611 .ext = &xcb_render_id,
1612 .opcode = XCB_RENDER_CHANGE_PICTURE,
1613 .isvoid = 1
1614 };
1615
1616 struct iovec xcb_parts[5];
1617 xcb_void_cookie_t xcb_ret;
1618 xcb_render_change_picture_request_t xcb_out;
1619
1620 xcb_out.picture = picture;
1621 xcb_out.value_mask = value_mask;
1622
1623 xcb_parts[2].iov_base = (char *) &xcb_out;
1624 xcb_parts[2].iov_len = sizeof(xcb_out);
1625 xcb_parts[3].iov_base = 0;
1626 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1627 /* xcb_render_change_picture_value_list_t value_list */
1628 xcb_parts[4].iov_base = (char *) value_list;
1629 xcb_parts[4].iov_len =
1630 xcb_render_change_picture_value_list_sizeof (value_list, value_mask);
1631
1632 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1633 return xcb_ret;
1634 }
1635
1636 xcb_void_cookie_t
xcb_render_change_picture_aux_checked(xcb_connection_t * c,xcb_render_picture_t picture,uint32_t value_mask,const xcb_render_change_picture_value_list_t * value_list)1637 xcb_render_change_picture_aux_checked (xcb_connection_t *c,
1638 xcb_render_picture_t picture,
1639 uint32_t value_mask,
1640 const xcb_render_change_picture_value_list_t *value_list)
1641 {
1642 static const xcb_protocol_request_t xcb_req = {
1643 .count = 3,
1644 .ext = &xcb_render_id,
1645 .opcode = XCB_RENDER_CHANGE_PICTURE,
1646 .isvoid = 1
1647 };
1648
1649 struct iovec xcb_parts[5];
1650 xcb_void_cookie_t xcb_ret;
1651 xcb_render_change_picture_request_t xcb_out;
1652 void *xcb_aux0 = 0;
1653
1654 xcb_out.picture = picture;
1655 xcb_out.value_mask = value_mask;
1656
1657 xcb_parts[2].iov_base = (char *) &xcb_out;
1658 xcb_parts[2].iov_len = sizeof(xcb_out);
1659 xcb_parts[3].iov_base = 0;
1660 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1661 /* xcb_render_change_picture_value_list_t value_list */
1662 xcb_parts[4].iov_len =
1663 xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
1664 xcb_parts[4].iov_base = xcb_aux0;
1665
1666 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1667 free(xcb_aux0);
1668 return xcb_ret;
1669 }
1670
1671 xcb_void_cookie_t
xcb_render_change_picture_aux(xcb_connection_t * c,xcb_render_picture_t picture,uint32_t value_mask,const xcb_render_change_picture_value_list_t * value_list)1672 xcb_render_change_picture_aux (xcb_connection_t *c,
1673 xcb_render_picture_t picture,
1674 uint32_t value_mask,
1675 const xcb_render_change_picture_value_list_t *value_list)
1676 {
1677 static const xcb_protocol_request_t xcb_req = {
1678 .count = 3,
1679 .ext = &xcb_render_id,
1680 .opcode = XCB_RENDER_CHANGE_PICTURE,
1681 .isvoid = 1
1682 };
1683
1684 struct iovec xcb_parts[5];
1685 xcb_void_cookie_t xcb_ret;
1686 xcb_render_change_picture_request_t xcb_out;
1687 void *xcb_aux0 = 0;
1688
1689 xcb_out.picture = picture;
1690 xcb_out.value_mask = value_mask;
1691
1692 xcb_parts[2].iov_base = (char *) &xcb_out;
1693 xcb_parts[2].iov_len = sizeof(xcb_out);
1694 xcb_parts[3].iov_base = 0;
1695 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1696 /* xcb_render_change_picture_value_list_t value_list */
1697 xcb_parts[4].iov_len =
1698 xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
1699 xcb_parts[4].iov_base = xcb_aux0;
1700
1701 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1702 free(xcb_aux0);
1703 return xcb_ret;
1704 }
1705
1706 void *
xcb_render_change_picture_value_list(const xcb_render_change_picture_request_t * R)1707 xcb_render_change_picture_value_list (const xcb_render_change_picture_request_t *R)
1708 {
1709 return (void *) (R + 1);
1710 }
1711
1712 int
xcb_render_set_picture_clip_rectangles_sizeof(const void * _buffer,uint32_t rectangles_len)1713 xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer,
1714 uint32_t rectangles_len)
1715 {
1716 char *xcb_tmp = (char *)_buffer;
1717 unsigned int xcb_buffer_len = 0;
1718 unsigned int xcb_block_len = 0;
1719 unsigned int xcb_pad = 0;
1720 unsigned int xcb_align_to = 0;
1721
1722
1723 xcb_block_len += sizeof(xcb_render_set_picture_clip_rectangles_request_t);
1724 xcb_tmp += xcb_block_len;
1725 xcb_buffer_len += xcb_block_len;
1726 xcb_block_len = 0;
1727 /* rectangles */
1728 xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
1729 xcb_tmp += xcb_block_len;
1730 xcb_align_to = ALIGNOF(xcb_rectangle_t);
1731 /* insert padding */
1732 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1733 xcb_buffer_len += xcb_block_len + xcb_pad;
1734 if (0 != xcb_pad) {
1735 xcb_tmp += xcb_pad;
1736 xcb_pad = 0;
1737 }
1738 xcb_block_len = 0;
1739
1740 return xcb_buffer_len;
1741 }
1742
1743 xcb_void_cookie_t
xcb_render_set_picture_clip_rectangles_checked(xcb_connection_t * c,xcb_render_picture_t picture,int16_t clip_x_origin,int16_t clip_y_origin,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)1744 xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c,
1745 xcb_render_picture_t picture,
1746 int16_t clip_x_origin,
1747 int16_t clip_y_origin,
1748 uint32_t rectangles_len,
1749 const xcb_rectangle_t *rectangles)
1750 {
1751 static const xcb_protocol_request_t xcb_req = {
1752 .count = 4,
1753 .ext = &xcb_render_id,
1754 .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
1755 .isvoid = 1
1756 };
1757
1758 struct iovec xcb_parts[6];
1759 xcb_void_cookie_t xcb_ret;
1760 xcb_render_set_picture_clip_rectangles_request_t xcb_out;
1761
1762 xcb_out.picture = picture;
1763 xcb_out.clip_x_origin = clip_x_origin;
1764 xcb_out.clip_y_origin = clip_y_origin;
1765
1766 xcb_parts[2].iov_base = (char *) &xcb_out;
1767 xcb_parts[2].iov_len = sizeof(xcb_out);
1768 xcb_parts[3].iov_base = 0;
1769 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1770 /* xcb_rectangle_t rectangles */
1771 xcb_parts[4].iov_base = (char *) rectangles;
1772 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
1773 xcb_parts[5].iov_base = 0;
1774 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1775
1776 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1777 return xcb_ret;
1778 }
1779
1780 xcb_void_cookie_t
xcb_render_set_picture_clip_rectangles(xcb_connection_t * c,xcb_render_picture_t picture,int16_t clip_x_origin,int16_t clip_y_origin,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)1781 xcb_render_set_picture_clip_rectangles (xcb_connection_t *c,
1782 xcb_render_picture_t picture,
1783 int16_t clip_x_origin,
1784 int16_t clip_y_origin,
1785 uint32_t rectangles_len,
1786 const xcb_rectangle_t *rectangles)
1787 {
1788 static const xcb_protocol_request_t xcb_req = {
1789 .count = 4,
1790 .ext = &xcb_render_id,
1791 .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
1792 .isvoid = 1
1793 };
1794
1795 struct iovec xcb_parts[6];
1796 xcb_void_cookie_t xcb_ret;
1797 xcb_render_set_picture_clip_rectangles_request_t xcb_out;
1798
1799 xcb_out.picture = picture;
1800 xcb_out.clip_x_origin = clip_x_origin;
1801 xcb_out.clip_y_origin = clip_y_origin;
1802
1803 xcb_parts[2].iov_base = (char *) &xcb_out;
1804 xcb_parts[2].iov_len = sizeof(xcb_out);
1805 xcb_parts[3].iov_base = 0;
1806 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1807 /* xcb_rectangle_t rectangles */
1808 xcb_parts[4].iov_base = (char *) rectangles;
1809 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
1810 xcb_parts[5].iov_base = 0;
1811 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1812
1813 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1814 return xcb_ret;
1815 }
1816
1817 xcb_rectangle_t *
xcb_render_set_picture_clip_rectangles_rectangles(const xcb_render_set_picture_clip_rectangles_request_t * R)1818 xcb_render_set_picture_clip_rectangles_rectangles (const xcb_render_set_picture_clip_rectangles_request_t *R)
1819 {
1820 return (xcb_rectangle_t *) (R + 1);
1821 }
1822
1823 int
xcb_render_set_picture_clip_rectangles_rectangles_length(const xcb_render_set_picture_clip_rectangles_request_t * R)1824 xcb_render_set_picture_clip_rectangles_rectangles_length (const xcb_render_set_picture_clip_rectangles_request_t *R)
1825 {
1826 return (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
1827 }
1828
1829 xcb_rectangle_iterator_t
xcb_render_set_picture_clip_rectangles_rectangles_iterator(const xcb_render_set_picture_clip_rectangles_request_t * R)1830 xcb_render_set_picture_clip_rectangles_rectangles_iterator (const xcb_render_set_picture_clip_rectangles_request_t *R)
1831 {
1832 xcb_rectangle_iterator_t i;
1833 i.data = (xcb_rectangle_t *) (R + 1);
1834 i.rem = (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
1835 i.index = (char *) i.data - (char *) R;
1836 return i;
1837 }
1838
1839 xcb_void_cookie_t
xcb_render_free_picture_checked(xcb_connection_t * c,xcb_render_picture_t picture)1840 xcb_render_free_picture_checked (xcb_connection_t *c,
1841 xcb_render_picture_t picture)
1842 {
1843 static const xcb_protocol_request_t xcb_req = {
1844 .count = 2,
1845 .ext = &xcb_render_id,
1846 .opcode = XCB_RENDER_FREE_PICTURE,
1847 .isvoid = 1
1848 };
1849
1850 struct iovec xcb_parts[4];
1851 xcb_void_cookie_t xcb_ret;
1852 xcb_render_free_picture_request_t xcb_out;
1853
1854 xcb_out.picture = picture;
1855
1856 xcb_parts[2].iov_base = (char *) &xcb_out;
1857 xcb_parts[2].iov_len = sizeof(xcb_out);
1858 xcb_parts[3].iov_base = 0;
1859 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1860
1861 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1862 return xcb_ret;
1863 }
1864
1865 xcb_void_cookie_t
xcb_render_free_picture(xcb_connection_t * c,xcb_render_picture_t picture)1866 xcb_render_free_picture (xcb_connection_t *c,
1867 xcb_render_picture_t picture)
1868 {
1869 static const xcb_protocol_request_t xcb_req = {
1870 .count = 2,
1871 .ext = &xcb_render_id,
1872 .opcode = XCB_RENDER_FREE_PICTURE,
1873 .isvoid = 1
1874 };
1875
1876 struct iovec xcb_parts[4];
1877 xcb_void_cookie_t xcb_ret;
1878 xcb_render_free_picture_request_t xcb_out;
1879
1880 xcb_out.picture = picture;
1881
1882 xcb_parts[2].iov_base = (char *) &xcb_out;
1883 xcb_parts[2].iov_len = sizeof(xcb_out);
1884 xcb_parts[3].iov_base = 0;
1885 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1886
1887 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1888 return xcb_ret;
1889 }
1890
1891 xcb_void_cookie_t
xcb_render_composite_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t mask,xcb_render_picture_t dst,int16_t src_x,int16_t src_y,int16_t mask_x,int16_t mask_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height)1892 xcb_render_composite_checked (xcb_connection_t *c,
1893 uint8_t op,
1894 xcb_render_picture_t src,
1895 xcb_render_picture_t mask,
1896 xcb_render_picture_t dst,
1897 int16_t src_x,
1898 int16_t src_y,
1899 int16_t mask_x,
1900 int16_t mask_y,
1901 int16_t dst_x,
1902 int16_t dst_y,
1903 uint16_t width,
1904 uint16_t height)
1905 {
1906 static const xcb_protocol_request_t xcb_req = {
1907 .count = 2,
1908 .ext = &xcb_render_id,
1909 .opcode = XCB_RENDER_COMPOSITE,
1910 .isvoid = 1
1911 };
1912
1913 struct iovec xcb_parts[4];
1914 xcb_void_cookie_t xcb_ret;
1915 xcb_render_composite_request_t xcb_out;
1916
1917 xcb_out.op = op;
1918 memset(xcb_out.pad0, 0, 3);
1919 xcb_out.src = src;
1920 xcb_out.mask = mask;
1921 xcb_out.dst = dst;
1922 xcb_out.src_x = src_x;
1923 xcb_out.src_y = src_y;
1924 xcb_out.mask_x = mask_x;
1925 xcb_out.mask_y = mask_y;
1926 xcb_out.dst_x = dst_x;
1927 xcb_out.dst_y = dst_y;
1928 xcb_out.width = width;
1929 xcb_out.height = height;
1930
1931 xcb_parts[2].iov_base = (char *) &xcb_out;
1932 xcb_parts[2].iov_len = sizeof(xcb_out);
1933 xcb_parts[3].iov_base = 0;
1934 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1935
1936 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1937 return xcb_ret;
1938 }
1939
1940 xcb_void_cookie_t
xcb_render_composite(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t mask,xcb_render_picture_t dst,int16_t src_x,int16_t src_y,int16_t mask_x,int16_t mask_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height)1941 xcb_render_composite (xcb_connection_t *c,
1942 uint8_t op,
1943 xcb_render_picture_t src,
1944 xcb_render_picture_t mask,
1945 xcb_render_picture_t dst,
1946 int16_t src_x,
1947 int16_t src_y,
1948 int16_t mask_x,
1949 int16_t mask_y,
1950 int16_t dst_x,
1951 int16_t dst_y,
1952 uint16_t width,
1953 uint16_t height)
1954 {
1955 static const xcb_protocol_request_t xcb_req = {
1956 .count = 2,
1957 .ext = &xcb_render_id,
1958 .opcode = XCB_RENDER_COMPOSITE,
1959 .isvoid = 1
1960 };
1961
1962 struct iovec xcb_parts[4];
1963 xcb_void_cookie_t xcb_ret;
1964 xcb_render_composite_request_t xcb_out;
1965
1966 xcb_out.op = op;
1967 memset(xcb_out.pad0, 0, 3);
1968 xcb_out.src = src;
1969 xcb_out.mask = mask;
1970 xcb_out.dst = dst;
1971 xcb_out.src_x = src_x;
1972 xcb_out.src_y = src_y;
1973 xcb_out.mask_x = mask_x;
1974 xcb_out.mask_y = mask_y;
1975 xcb_out.dst_x = dst_x;
1976 xcb_out.dst_y = dst_y;
1977 xcb_out.width = width;
1978 xcb_out.height = height;
1979
1980 xcb_parts[2].iov_base = (char *) &xcb_out;
1981 xcb_parts[2].iov_len = sizeof(xcb_out);
1982 xcb_parts[3].iov_base = 0;
1983 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1984
1985 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1986 return xcb_ret;
1987 }
1988
1989 int
xcb_render_trapezoids_sizeof(const void * _buffer,uint32_t traps_len)1990 xcb_render_trapezoids_sizeof (const void *_buffer,
1991 uint32_t traps_len)
1992 {
1993 char *xcb_tmp = (char *)_buffer;
1994 unsigned int xcb_buffer_len = 0;
1995 unsigned int xcb_block_len = 0;
1996 unsigned int xcb_pad = 0;
1997 unsigned int xcb_align_to = 0;
1998
1999
2000 xcb_block_len += sizeof(xcb_render_trapezoids_request_t);
2001 xcb_tmp += xcb_block_len;
2002 xcb_buffer_len += xcb_block_len;
2003 xcb_block_len = 0;
2004 /* traps */
2005 xcb_block_len += traps_len * sizeof(xcb_render_trapezoid_t);
2006 xcb_tmp += xcb_block_len;
2007 xcb_align_to = ALIGNOF(xcb_render_trapezoid_t);
2008 /* insert padding */
2009 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2010 xcb_buffer_len += xcb_block_len + xcb_pad;
2011 if (0 != xcb_pad) {
2012 xcb_tmp += xcb_pad;
2013 xcb_pad = 0;
2014 }
2015 xcb_block_len = 0;
2016
2017 return xcb_buffer_len;
2018 }
2019
2020 xcb_void_cookie_t
xcb_render_trapezoids_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t traps_len,const xcb_render_trapezoid_t * traps)2021 xcb_render_trapezoids_checked (xcb_connection_t *c,
2022 uint8_t op,
2023 xcb_render_picture_t src,
2024 xcb_render_picture_t dst,
2025 xcb_render_pictformat_t mask_format,
2026 int16_t src_x,
2027 int16_t src_y,
2028 uint32_t traps_len,
2029 const xcb_render_trapezoid_t *traps)
2030 {
2031 static const xcb_protocol_request_t xcb_req = {
2032 .count = 4,
2033 .ext = &xcb_render_id,
2034 .opcode = XCB_RENDER_TRAPEZOIDS,
2035 .isvoid = 1
2036 };
2037
2038 struct iovec xcb_parts[6];
2039 xcb_void_cookie_t xcb_ret;
2040 xcb_render_trapezoids_request_t xcb_out;
2041
2042 xcb_out.op = op;
2043 memset(xcb_out.pad0, 0, 3);
2044 xcb_out.src = src;
2045 xcb_out.dst = dst;
2046 xcb_out.mask_format = mask_format;
2047 xcb_out.src_x = src_x;
2048 xcb_out.src_y = src_y;
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 /* xcb_render_trapezoid_t traps */
2055 xcb_parts[4].iov_base = (char *) traps;
2056 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_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, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2061 return xcb_ret;
2062 }
2063
2064 xcb_void_cookie_t
xcb_render_trapezoids(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t traps_len,const xcb_render_trapezoid_t * traps)2065 xcb_render_trapezoids (xcb_connection_t *c,
2066 uint8_t op,
2067 xcb_render_picture_t src,
2068 xcb_render_picture_t dst,
2069 xcb_render_pictformat_t mask_format,
2070 int16_t src_x,
2071 int16_t src_y,
2072 uint32_t traps_len,
2073 const xcb_render_trapezoid_t *traps)
2074 {
2075 static const xcb_protocol_request_t xcb_req = {
2076 .count = 4,
2077 .ext = &xcb_render_id,
2078 .opcode = XCB_RENDER_TRAPEZOIDS,
2079 .isvoid = 1
2080 };
2081
2082 struct iovec xcb_parts[6];
2083 xcb_void_cookie_t xcb_ret;
2084 xcb_render_trapezoids_request_t xcb_out;
2085
2086 xcb_out.op = op;
2087 memset(xcb_out.pad0, 0, 3);
2088 xcb_out.src = src;
2089 xcb_out.dst = dst;
2090 xcb_out.mask_format = mask_format;
2091 xcb_out.src_x = src_x;
2092 xcb_out.src_y = src_y;
2093
2094 xcb_parts[2].iov_base = (char *) &xcb_out;
2095 xcb_parts[2].iov_len = sizeof(xcb_out);
2096 xcb_parts[3].iov_base = 0;
2097 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2098 /* xcb_render_trapezoid_t traps */
2099 xcb_parts[4].iov_base = (char *) traps;
2100 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t);
2101 xcb_parts[5].iov_base = 0;
2102 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2103
2104 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2105 return xcb_ret;
2106 }
2107
2108 xcb_render_trapezoid_t *
xcb_render_trapezoids_traps(const xcb_render_trapezoids_request_t * R)2109 xcb_render_trapezoids_traps (const xcb_render_trapezoids_request_t *R)
2110 {
2111 return (xcb_render_trapezoid_t *) (R + 1);
2112 }
2113
2114 int
xcb_render_trapezoids_traps_length(const xcb_render_trapezoids_request_t * R)2115 xcb_render_trapezoids_traps_length (const xcb_render_trapezoids_request_t *R)
2116 {
2117 return (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t));
2118 }
2119
2120 xcb_render_trapezoid_iterator_t
xcb_render_trapezoids_traps_iterator(const xcb_render_trapezoids_request_t * R)2121 xcb_render_trapezoids_traps_iterator (const xcb_render_trapezoids_request_t *R)
2122 {
2123 xcb_render_trapezoid_iterator_t i;
2124 i.data = (xcb_render_trapezoid_t *) (R + 1);
2125 i.rem = (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t));
2126 i.index = (char *) i.data - (char *) R;
2127 return i;
2128 }
2129
2130 int
xcb_render_triangles_sizeof(const void * _buffer,uint32_t triangles_len)2131 xcb_render_triangles_sizeof (const void *_buffer,
2132 uint32_t triangles_len)
2133 {
2134 char *xcb_tmp = (char *)_buffer;
2135 unsigned int xcb_buffer_len = 0;
2136 unsigned int xcb_block_len = 0;
2137 unsigned int xcb_pad = 0;
2138 unsigned int xcb_align_to = 0;
2139
2140
2141 xcb_block_len += sizeof(xcb_render_triangles_request_t);
2142 xcb_tmp += xcb_block_len;
2143 xcb_buffer_len += xcb_block_len;
2144 xcb_block_len = 0;
2145 /* triangles */
2146 xcb_block_len += triangles_len * sizeof(xcb_render_triangle_t);
2147 xcb_tmp += xcb_block_len;
2148 xcb_align_to = ALIGNOF(xcb_render_triangle_t);
2149 /* insert padding */
2150 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2151 xcb_buffer_len += xcb_block_len + xcb_pad;
2152 if (0 != xcb_pad) {
2153 xcb_tmp += xcb_pad;
2154 xcb_pad = 0;
2155 }
2156 xcb_block_len = 0;
2157
2158 return xcb_buffer_len;
2159 }
2160
2161 xcb_void_cookie_t
xcb_render_triangles_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t triangles_len,const xcb_render_triangle_t * triangles)2162 xcb_render_triangles_checked (xcb_connection_t *c,
2163 uint8_t op,
2164 xcb_render_picture_t src,
2165 xcb_render_picture_t dst,
2166 xcb_render_pictformat_t mask_format,
2167 int16_t src_x,
2168 int16_t src_y,
2169 uint32_t triangles_len,
2170 const xcb_render_triangle_t *triangles)
2171 {
2172 static const xcb_protocol_request_t xcb_req = {
2173 .count = 4,
2174 .ext = &xcb_render_id,
2175 .opcode = XCB_RENDER_TRIANGLES,
2176 .isvoid = 1
2177 };
2178
2179 struct iovec xcb_parts[6];
2180 xcb_void_cookie_t xcb_ret;
2181 xcb_render_triangles_request_t xcb_out;
2182
2183 xcb_out.op = op;
2184 memset(xcb_out.pad0, 0, 3);
2185 xcb_out.src = src;
2186 xcb_out.dst = dst;
2187 xcb_out.mask_format = mask_format;
2188 xcb_out.src_x = src_x;
2189 xcb_out.src_y = src_y;
2190
2191 xcb_parts[2].iov_base = (char *) &xcb_out;
2192 xcb_parts[2].iov_len = sizeof(xcb_out);
2193 xcb_parts[3].iov_base = 0;
2194 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2195 /* xcb_render_triangle_t triangles */
2196 xcb_parts[4].iov_base = (char *) triangles;
2197 xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
2198 xcb_parts[5].iov_base = 0;
2199 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2200
2201 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2202 return xcb_ret;
2203 }
2204
2205 xcb_void_cookie_t
xcb_render_triangles(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t triangles_len,const xcb_render_triangle_t * triangles)2206 xcb_render_triangles (xcb_connection_t *c,
2207 uint8_t op,
2208 xcb_render_picture_t src,
2209 xcb_render_picture_t dst,
2210 xcb_render_pictformat_t mask_format,
2211 int16_t src_x,
2212 int16_t src_y,
2213 uint32_t triangles_len,
2214 const xcb_render_triangle_t *triangles)
2215 {
2216 static const xcb_protocol_request_t xcb_req = {
2217 .count = 4,
2218 .ext = &xcb_render_id,
2219 .opcode = XCB_RENDER_TRIANGLES,
2220 .isvoid = 1
2221 };
2222
2223 struct iovec xcb_parts[6];
2224 xcb_void_cookie_t xcb_ret;
2225 xcb_render_triangles_request_t xcb_out;
2226
2227 xcb_out.op = op;
2228 memset(xcb_out.pad0, 0, 3);
2229 xcb_out.src = src;
2230 xcb_out.dst = dst;
2231 xcb_out.mask_format = mask_format;
2232 xcb_out.src_x = src_x;
2233 xcb_out.src_y = src_y;
2234
2235 xcb_parts[2].iov_base = (char *) &xcb_out;
2236 xcb_parts[2].iov_len = sizeof(xcb_out);
2237 xcb_parts[3].iov_base = 0;
2238 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2239 /* xcb_render_triangle_t triangles */
2240 xcb_parts[4].iov_base = (char *) triangles;
2241 xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
2242 xcb_parts[5].iov_base = 0;
2243 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2244
2245 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2246 return xcb_ret;
2247 }
2248
2249 xcb_render_triangle_t *
xcb_render_triangles_triangles(const xcb_render_triangles_request_t * R)2250 xcb_render_triangles_triangles (const xcb_render_triangles_request_t *R)
2251 {
2252 return (xcb_render_triangle_t *) (R + 1);
2253 }
2254
2255 int
xcb_render_triangles_triangles_length(const xcb_render_triangles_request_t * R)2256 xcb_render_triangles_triangles_length (const xcb_render_triangles_request_t *R)
2257 {
2258 return (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t));
2259 }
2260
2261 xcb_render_triangle_iterator_t
xcb_render_triangles_triangles_iterator(const xcb_render_triangles_request_t * R)2262 xcb_render_triangles_triangles_iterator (const xcb_render_triangles_request_t *R)
2263 {
2264 xcb_render_triangle_iterator_t i;
2265 i.data = (xcb_render_triangle_t *) (R + 1);
2266 i.rem = (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t));
2267 i.index = (char *) i.data - (char *) R;
2268 return i;
2269 }
2270
2271 int
xcb_render_tri_strip_sizeof(const void * _buffer,uint32_t points_len)2272 xcb_render_tri_strip_sizeof (const void *_buffer,
2273 uint32_t points_len)
2274 {
2275 char *xcb_tmp = (char *)_buffer;
2276 unsigned int xcb_buffer_len = 0;
2277 unsigned int xcb_block_len = 0;
2278 unsigned int xcb_pad = 0;
2279 unsigned int xcb_align_to = 0;
2280
2281
2282 xcb_block_len += sizeof(xcb_render_tri_strip_request_t);
2283 xcb_tmp += xcb_block_len;
2284 xcb_buffer_len += xcb_block_len;
2285 xcb_block_len = 0;
2286 /* points */
2287 xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
2288 xcb_tmp += xcb_block_len;
2289 xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
2290 /* insert padding */
2291 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2292 xcb_buffer_len += xcb_block_len + xcb_pad;
2293 if (0 != xcb_pad) {
2294 xcb_tmp += xcb_pad;
2295 xcb_pad = 0;
2296 }
2297 xcb_block_len = 0;
2298
2299 return xcb_buffer_len;
2300 }
2301
2302 xcb_void_cookie_t
xcb_render_tri_strip_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t points_len,const xcb_render_pointfix_t * points)2303 xcb_render_tri_strip_checked (xcb_connection_t *c,
2304 uint8_t op,
2305 xcb_render_picture_t src,
2306 xcb_render_picture_t dst,
2307 xcb_render_pictformat_t mask_format,
2308 int16_t src_x,
2309 int16_t src_y,
2310 uint32_t points_len,
2311 const xcb_render_pointfix_t *points)
2312 {
2313 static const xcb_protocol_request_t xcb_req = {
2314 .count = 4,
2315 .ext = &xcb_render_id,
2316 .opcode = XCB_RENDER_TRI_STRIP,
2317 .isvoid = 1
2318 };
2319
2320 struct iovec xcb_parts[6];
2321 xcb_void_cookie_t xcb_ret;
2322 xcb_render_tri_strip_request_t xcb_out;
2323
2324 xcb_out.op = op;
2325 memset(xcb_out.pad0, 0, 3);
2326 xcb_out.src = src;
2327 xcb_out.dst = dst;
2328 xcb_out.mask_format = mask_format;
2329 xcb_out.src_x = src_x;
2330 xcb_out.src_y = src_y;
2331
2332 xcb_parts[2].iov_base = (char *) &xcb_out;
2333 xcb_parts[2].iov_len = sizeof(xcb_out);
2334 xcb_parts[3].iov_base = 0;
2335 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2336 /* xcb_render_pointfix_t points */
2337 xcb_parts[4].iov_base = (char *) points;
2338 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
2339 xcb_parts[5].iov_base = 0;
2340 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2341
2342 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2343 return xcb_ret;
2344 }
2345
2346 xcb_void_cookie_t
xcb_render_tri_strip(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t points_len,const xcb_render_pointfix_t * points)2347 xcb_render_tri_strip (xcb_connection_t *c,
2348 uint8_t op,
2349 xcb_render_picture_t src,
2350 xcb_render_picture_t dst,
2351 xcb_render_pictformat_t mask_format,
2352 int16_t src_x,
2353 int16_t src_y,
2354 uint32_t points_len,
2355 const xcb_render_pointfix_t *points)
2356 {
2357 static const xcb_protocol_request_t xcb_req = {
2358 .count = 4,
2359 .ext = &xcb_render_id,
2360 .opcode = XCB_RENDER_TRI_STRIP,
2361 .isvoid = 1
2362 };
2363
2364 struct iovec xcb_parts[6];
2365 xcb_void_cookie_t xcb_ret;
2366 xcb_render_tri_strip_request_t xcb_out;
2367
2368 xcb_out.op = op;
2369 memset(xcb_out.pad0, 0, 3);
2370 xcb_out.src = src;
2371 xcb_out.dst = dst;
2372 xcb_out.mask_format = mask_format;
2373 xcb_out.src_x = src_x;
2374 xcb_out.src_y = src_y;
2375
2376 xcb_parts[2].iov_base = (char *) &xcb_out;
2377 xcb_parts[2].iov_len = sizeof(xcb_out);
2378 xcb_parts[3].iov_base = 0;
2379 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2380 /* xcb_render_pointfix_t points */
2381 xcb_parts[4].iov_base = (char *) points;
2382 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
2383 xcb_parts[5].iov_base = 0;
2384 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2385
2386 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2387 return xcb_ret;
2388 }
2389
2390 xcb_render_pointfix_t *
xcb_render_tri_strip_points(const xcb_render_tri_strip_request_t * R)2391 xcb_render_tri_strip_points (const xcb_render_tri_strip_request_t *R)
2392 {
2393 return (xcb_render_pointfix_t *) (R + 1);
2394 }
2395
2396 int
xcb_render_tri_strip_points_length(const xcb_render_tri_strip_request_t * R)2397 xcb_render_tri_strip_points_length (const xcb_render_tri_strip_request_t *R)
2398 {
2399 return (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t));
2400 }
2401
2402 xcb_render_pointfix_iterator_t
xcb_render_tri_strip_points_iterator(const xcb_render_tri_strip_request_t * R)2403 xcb_render_tri_strip_points_iterator (const xcb_render_tri_strip_request_t *R)
2404 {
2405 xcb_render_pointfix_iterator_t i;
2406 i.data = (xcb_render_pointfix_t *) (R + 1);
2407 i.rem = (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t));
2408 i.index = (char *) i.data - (char *) R;
2409 return i;
2410 }
2411
2412 int
xcb_render_tri_fan_sizeof(const void * _buffer,uint32_t points_len)2413 xcb_render_tri_fan_sizeof (const void *_buffer,
2414 uint32_t points_len)
2415 {
2416 char *xcb_tmp = (char *)_buffer;
2417 unsigned int xcb_buffer_len = 0;
2418 unsigned int xcb_block_len = 0;
2419 unsigned int xcb_pad = 0;
2420 unsigned int xcb_align_to = 0;
2421
2422
2423 xcb_block_len += sizeof(xcb_render_tri_fan_request_t);
2424 xcb_tmp += xcb_block_len;
2425 xcb_buffer_len += xcb_block_len;
2426 xcb_block_len = 0;
2427 /* points */
2428 xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
2429 xcb_tmp += xcb_block_len;
2430 xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
2431 /* insert padding */
2432 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2433 xcb_buffer_len += xcb_block_len + xcb_pad;
2434 if (0 != xcb_pad) {
2435 xcb_tmp += xcb_pad;
2436 xcb_pad = 0;
2437 }
2438 xcb_block_len = 0;
2439
2440 return xcb_buffer_len;
2441 }
2442
2443 xcb_void_cookie_t
xcb_render_tri_fan_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t points_len,const xcb_render_pointfix_t * points)2444 xcb_render_tri_fan_checked (xcb_connection_t *c,
2445 uint8_t op,
2446 xcb_render_picture_t src,
2447 xcb_render_picture_t dst,
2448 xcb_render_pictformat_t mask_format,
2449 int16_t src_x,
2450 int16_t src_y,
2451 uint32_t points_len,
2452 const xcb_render_pointfix_t *points)
2453 {
2454 static const xcb_protocol_request_t xcb_req = {
2455 .count = 4,
2456 .ext = &xcb_render_id,
2457 .opcode = XCB_RENDER_TRI_FAN,
2458 .isvoid = 1
2459 };
2460
2461 struct iovec xcb_parts[6];
2462 xcb_void_cookie_t xcb_ret;
2463 xcb_render_tri_fan_request_t xcb_out;
2464
2465 xcb_out.op = op;
2466 memset(xcb_out.pad0, 0, 3);
2467 xcb_out.src = src;
2468 xcb_out.dst = dst;
2469 xcb_out.mask_format = mask_format;
2470 xcb_out.src_x = src_x;
2471 xcb_out.src_y = src_y;
2472
2473 xcb_parts[2].iov_base = (char *) &xcb_out;
2474 xcb_parts[2].iov_len = sizeof(xcb_out);
2475 xcb_parts[3].iov_base = 0;
2476 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2477 /* xcb_render_pointfix_t points */
2478 xcb_parts[4].iov_base = (char *) points;
2479 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
2480 xcb_parts[5].iov_base = 0;
2481 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2482
2483 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2484 return xcb_ret;
2485 }
2486
2487 xcb_void_cookie_t
xcb_render_tri_fan(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,int16_t src_x,int16_t src_y,uint32_t points_len,const xcb_render_pointfix_t * points)2488 xcb_render_tri_fan (xcb_connection_t *c,
2489 uint8_t op,
2490 xcb_render_picture_t src,
2491 xcb_render_picture_t dst,
2492 xcb_render_pictformat_t mask_format,
2493 int16_t src_x,
2494 int16_t src_y,
2495 uint32_t points_len,
2496 const xcb_render_pointfix_t *points)
2497 {
2498 static const xcb_protocol_request_t xcb_req = {
2499 .count = 4,
2500 .ext = &xcb_render_id,
2501 .opcode = XCB_RENDER_TRI_FAN,
2502 .isvoid = 1
2503 };
2504
2505 struct iovec xcb_parts[6];
2506 xcb_void_cookie_t xcb_ret;
2507 xcb_render_tri_fan_request_t xcb_out;
2508
2509 xcb_out.op = op;
2510 memset(xcb_out.pad0, 0, 3);
2511 xcb_out.src = src;
2512 xcb_out.dst = dst;
2513 xcb_out.mask_format = mask_format;
2514 xcb_out.src_x = src_x;
2515 xcb_out.src_y = src_y;
2516
2517 xcb_parts[2].iov_base = (char *) &xcb_out;
2518 xcb_parts[2].iov_len = sizeof(xcb_out);
2519 xcb_parts[3].iov_base = 0;
2520 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2521 /* xcb_render_pointfix_t points */
2522 xcb_parts[4].iov_base = (char *) points;
2523 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
2524 xcb_parts[5].iov_base = 0;
2525 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2526
2527 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2528 return xcb_ret;
2529 }
2530
2531 xcb_render_pointfix_t *
xcb_render_tri_fan_points(const xcb_render_tri_fan_request_t * R)2532 xcb_render_tri_fan_points (const xcb_render_tri_fan_request_t *R)
2533 {
2534 return (xcb_render_pointfix_t *) (R + 1);
2535 }
2536
2537 int
xcb_render_tri_fan_points_length(const xcb_render_tri_fan_request_t * R)2538 xcb_render_tri_fan_points_length (const xcb_render_tri_fan_request_t *R)
2539 {
2540 return (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t));
2541 }
2542
2543 xcb_render_pointfix_iterator_t
xcb_render_tri_fan_points_iterator(const xcb_render_tri_fan_request_t * R)2544 xcb_render_tri_fan_points_iterator (const xcb_render_tri_fan_request_t *R)
2545 {
2546 xcb_render_pointfix_iterator_t i;
2547 i.data = (xcb_render_pointfix_t *) (R + 1);
2548 i.rem = (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t));
2549 i.index = (char *) i.data - (char *) R;
2550 return i;
2551 }
2552
2553 xcb_void_cookie_t
xcb_render_create_glyph_set_checked(xcb_connection_t * c,xcb_render_glyphset_t gsid,xcb_render_pictformat_t format)2554 xcb_render_create_glyph_set_checked (xcb_connection_t *c,
2555 xcb_render_glyphset_t gsid,
2556 xcb_render_pictformat_t format)
2557 {
2558 static const xcb_protocol_request_t xcb_req = {
2559 .count = 2,
2560 .ext = &xcb_render_id,
2561 .opcode = XCB_RENDER_CREATE_GLYPH_SET,
2562 .isvoid = 1
2563 };
2564
2565 struct iovec xcb_parts[4];
2566 xcb_void_cookie_t xcb_ret;
2567 xcb_render_create_glyph_set_request_t xcb_out;
2568
2569 xcb_out.gsid = gsid;
2570 xcb_out.format = format;
2571
2572 xcb_parts[2].iov_base = (char *) &xcb_out;
2573 xcb_parts[2].iov_len = sizeof(xcb_out);
2574 xcb_parts[3].iov_base = 0;
2575 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2576
2577 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2578 return xcb_ret;
2579 }
2580
2581 xcb_void_cookie_t
xcb_render_create_glyph_set(xcb_connection_t * c,xcb_render_glyphset_t gsid,xcb_render_pictformat_t format)2582 xcb_render_create_glyph_set (xcb_connection_t *c,
2583 xcb_render_glyphset_t gsid,
2584 xcb_render_pictformat_t format)
2585 {
2586 static const xcb_protocol_request_t xcb_req = {
2587 .count = 2,
2588 .ext = &xcb_render_id,
2589 .opcode = XCB_RENDER_CREATE_GLYPH_SET,
2590 .isvoid = 1
2591 };
2592
2593 struct iovec xcb_parts[4];
2594 xcb_void_cookie_t xcb_ret;
2595 xcb_render_create_glyph_set_request_t xcb_out;
2596
2597 xcb_out.gsid = gsid;
2598 xcb_out.format = format;
2599
2600 xcb_parts[2].iov_base = (char *) &xcb_out;
2601 xcb_parts[2].iov_len = sizeof(xcb_out);
2602 xcb_parts[3].iov_base = 0;
2603 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2604
2605 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2606 return xcb_ret;
2607 }
2608
2609 xcb_void_cookie_t
xcb_render_reference_glyph_set_checked(xcb_connection_t * c,xcb_render_glyphset_t gsid,xcb_render_glyphset_t existing)2610 xcb_render_reference_glyph_set_checked (xcb_connection_t *c,
2611 xcb_render_glyphset_t gsid,
2612 xcb_render_glyphset_t existing)
2613 {
2614 static const xcb_protocol_request_t xcb_req = {
2615 .count = 2,
2616 .ext = &xcb_render_id,
2617 .opcode = XCB_RENDER_REFERENCE_GLYPH_SET,
2618 .isvoid = 1
2619 };
2620
2621 struct iovec xcb_parts[4];
2622 xcb_void_cookie_t xcb_ret;
2623 xcb_render_reference_glyph_set_request_t xcb_out;
2624
2625 xcb_out.gsid = gsid;
2626 xcb_out.existing = existing;
2627
2628 xcb_parts[2].iov_base = (char *) &xcb_out;
2629 xcb_parts[2].iov_len = sizeof(xcb_out);
2630 xcb_parts[3].iov_base = 0;
2631 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2632
2633 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2634 return xcb_ret;
2635 }
2636
2637 xcb_void_cookie_t
xcb_render_reference_glyph_set(xcb_connection_t * c,xcb_render_glyphset_t gsid,xcb_render_glyphset_t existing)2638 xcb_render_reference_glyph_set (xcb_connection_t *c,
2639 xcb_render_glyphset_t gsid,
2640 xcb_render_glyphset_t existing)
2641 {
2642 static const xcb_protocol_request_t xcb_req = {
2643 .count = 2,
2644 .ext = &xcb_render_id,
2645 .opcode = XCB_RENDER_REFERENCE_GLYPH_SET,
2646 .isvoid = 1
2647 };
2648
2649 struct iovec xcb_parts[4];
2650 xcb_void_cookie_t xcb_ret;
2651 xcb_render_reference_glyph_set_request_t xcb_out;
2652
2653 xcb_out.gsid = gsid;
2654 xcb_out.existing = existing;
2655
2656 xcb_parts[2].iov_base = (char *) &xcb_out;
2657 xcb_parts[2].iov_len = sizeof(xcb_out);
2658 xcb_parts[3].iov_base = 0;
2659 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2660
2661 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2662 return xcb_ret;
2663 }
2664
2665 xcb_void_cookie_t
xcb_render_free_glyph_set_checked(xcb_connection_t * c,xcb_render_glyphset_t glyphset)2666 xcb_render_free_glyph_set_checked (xcb_connection_t *c,
2667 xcb_render_glyphset_t glyphset)
2668 {
2669 static const xcb_protocol_request_t xcb_req = {
2670 .count = 2,
2671 .ext = &xcb_render_id,
2672 .opcode = XCB_RENDER_FREE_GLYPH_SET,
2673 .isvoid = 1
2674 };
2675
2676 struct iovec xcb_parts[4];
2677 xcb_void_cookie_t xcb_ret;
2678 xcb_render_free_glyph_set_request_t xcb_out;
2679
2680 xcb_out.glyphset = glyphset;
2681
2682 xcb_parts[2].iov_base = (char *) &xcb_out;
2683 xcb_parts[2].iov_len = sizeof(xcb_out);
2684 xcb_parts[3].iov_base = 0;
2685 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2686
2687 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2688 return xcb_ret;
2689 }
2690
2691 xcb_void_cookie_t
xcb_render_free_glyph_set(xcb_connection_t * c,xcb_render_glyphset_t glyphset)2692 xcb_render_free_glyph_set (xcb_connection_t *c,
2693 xcb_render_glyphset_t glyphset)
2694 {
2695 static const xcb_protocol_request_t xcb_req = {
2696 .count = 2,
2697 .ext = &xcb_render_id,
2698 .opcode = XCB_RENDER_FREE_GLYPH_SET,
2699 .isvoid = 1
2700 };
2701
2702 struct iovec xcb_parts[4];
2703 xcb_void_cookie_t xcb_ret;
2704 xcb_render_free_glyph_set_request_t xcb_out;
2705
2706 xcb_out.glyphset = glyphset;
2707
2708 xcb_parts[2].iov_base = (char *) &xcb_out;
2709 xcb_parts[2].iov_len = sizeof(xcb_out);
2710 xcb_parts[3].iov_base = 0;
2711 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2712
2713 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2714 return xcb_ret;
2715 }
2716
2717 int
xcb_render_add_glyphs_sizeof(const void * _buffer,uint32_t data_len)2718 xcb_render_add_glyphs_sizeof (const void *_buffer,
2719 uint32_t data_len)
2720 {
2721 char *xcb_tmp = (char *)_buffer;
2722 const xcb_render_add_glyphs_request_t *_aux = (xcb_render_add_glyphs_request_t *)_buffer;
2723 unsigned int xcb_buffer_len = 0;
2724 unsigned int xcb_block_len = 0;
2725 unsigned int xcb_pad = 0;
2726 unsigned int xcb_align_to = 0;
2727
2728
2729 xcb_block_len += sizeof(xcb_render_add_glyphs_request_t);
2730 xcb_tmp += xcb_block_len;
2731 xcb_buffer_len += xcb_block_len;
2732 xcb_block_len = 0;
2733 /* glyphids */
2734 xcb_block_len += _aux->glyphs_len * sizeof(uint32_t);
2735 xcb_tmp += xcb_block_len;
2736 xcb_align_to = ALIGNOF(uint32_t);
2737 /* insert padding */
2738 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2739 xcb_buffer_len += xcb_block_len + xcb_pad;
2740 if (0 != xcb_pad) {
2741 xcb_tmp += xcb_pad;
2742 xcb_pad = 0;
2743 }
2744 xcb_block_len = 0;
2745 /* glyphs */
2746 xcb_block_len += _aux->glyphs_len * sizeof(xcb_render_glyphinfo_t);
2747 xcb_tmp += xcb_block_len;
2748 xcb_align_to = ALIGNOF(xcb_render_glyphinfo_t);
2749 /* insert padding */
2750 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2751 xcb_buffer_len += xcb_block_len + xcb_pad;
2752 if (0 != xcb_pad) {
2753 xcb_tmp += xcb_pad;
2754 xcb_pad = 0;
2755 }
2756 xcb_block_len = 0;
2757 /* data */
2758 xcb_block_len += data_len * sizeof(uint8_t);
2759 xcb_tmp += xcb_block_len;
2760 xcb_align_to = ALIGNOF(uint8_t);
2761 /* insert padding */
2762 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2763 xcb_buffer_len += xcb_block_len + xcb_pad;
2764 if (0 != xcb_pad) {
2765 xcb_tmp += xcb_pad;
2766 xcb_pad = 0;
2767 }
2768 xcb_block_len = 0;
2769
2770 return xcb_buffer_len;
2771 }
2772
2773 xcb_void_cookie_t
xcb_render_add_glyphs_checked(xcb_connection_t * c,xcb_render_glyphset_t glyphset,uint32_t glyphs_len,const uint32_t * glyphids,const xcb_render_glyphinfo_t * glyphs,uint32_t data_len,const uint8_t * data)2774 xcb_render_add_glyphs_checked (xcb_connection_t *c,
2775 xcb_render_glyphset_t glyphset,
2776 uint32_t glyphs_len,
2777 const uint32_t *glyphids,
2778 const xcb_render_glyphinfo_t *glyphs,
2779 uint32_t data_len,
2780 const uint8_t *data)
2781 {
2782 static const xcb_protocol_request_t xcb_req = {
2783 .count = 8,
2784 .ext = &xcb_render_id,
2785 .opcode = XCB_RENDER_ADD_GLYPHS,
2786 .isvoid = 1
2787 };
2788
2789 struct iovec xcb_parts[10];
2790 xcb_void_cookie_t xcb_ret;
2791 xcb_render_add_glyphs_request_t xcb_out;
2792
2793 xcb_out.glyphset = glyphset;
2794 xcb_out.glyphs_len = glyphs_len;
2795
2796 xcb_parts[2].iov_base = (char *) &xcb_out;
2797 xcb_parts[2].iov_len = sizeof(xcb_out);
2798 xcb_parts[3].iov_base = 0;
2799 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2800 /* uint32_t glyphids */
2801 xcb_parts[4].iov_base = (char *) glyphids;
2802 xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
2803 xcb_parts[5].iov_base = 0;
2804 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2805 /* xcb_render_glyphinfo_t glyphs */
2806 xcb_parts[6].iov_base = (char *) glyphs;
2807 xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
2808 xcb_parts[7].iov_base = 0;
2809 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
2810 /* uint8_t data */
2811 xcb_parts[8].iov_base = (char *) data;
2812 xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
2813 xcb_parts[9].iov_base = 0;
2814 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
2815
2816 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2817 return xcb_ret;
2818 }
2819
2820 xcb_void_cookie_t
xcb_render_add_glyphs(xcb_connection_t * c,xcb_render_glyphset_t glyphset,uint32_t glyphs_len,const uint32_t * glyphids,const xcb_render_glyphinfo_t * glyphs,uint32_t data_len,const uint8_t * data)2821 xcb_render_add_glyphs (xcb_connection_t *c,
2822 xcb_render_glyphset_t glyphset,
2823 uint32_t glyphs_len,
2824 const uint32_t *glyphids,
2825 const xcb_render_glyphinfo_t *glyphs,
2826 uint32_t data_len,
2827 const uint8_t *data)
2828 {
2829 static const xcb_protocol_request_t xcb_req = {
2830 .count = 8,
2831 .ext = &xcb_render_id,
2832 .opcode = XCB_RENDER_ADD_GLYPHS,
2833 .isvoid = 1
2834 };
2835
2836 struct iovec xcb_parts[10];
2837 xcb_void_cookie_t xcb_ret;
2838 xcb_render_add_glyphs_request_t xcb_out;
2839
2840 xcb_out.glyphset = glyphset;
2841 xcb_out.glyphs_len = glyphs_len;
2842
2843 xcb_parts[2].iov_base = (char *) &xcb_out;
2844 xcb_parts[2].iov_len = sizeof(xcb_out);
2845 xcb_parts[3].iov_base = 0;
2846 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2847 /* uint32_t glyphids */
2848 xcb_parts[4].iov_base = (char *) glyphids;
2849 xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
2850 xcb_parts[5].iov_base = 0;
2851 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2852 /* xcb_render_glyphinfo_t glyphs */
2853 xcb_parts[6].iov_base = (char *) glyphs;
2854 xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
2855 xcb_parts[7].iov_base = 0;
2856 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
2857 /* uint8_t data */
2858 xcb_parts[8].iov_base = (char *) data;
2859 xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
2860 xcb_parts[9].iov_base = 0;
2861 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
2862
2863 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2864 return xcb_ret;
2865 }
2866
2867 uint32_t *
xcb_render_add_glyphs_glyphids(const xcb_render_add_glyphs_request_t * R)2868 xcb_render_add_glyphs_glyphids (const xcb_render_add_glyphs_request_t *R)
2869 {
2870 return (uint32_t *) (R + 1);
2871 }
2872
2873 int
xcb_render_add_glyphs_glyphids_length(const xcb_render_add_glyphs_request_t * R)2874 xcb_render_add_glyphs_glyphids_length (const xcb_render_add_glyphs_request_t *R)
2875 {
2876 return R->glyphs_len;
2877 }
2878
2879 xcb_generic_iterator_t
xcb_render_add_glyphs_glyphids_end(const xcb_render_add_glyphs_request_t * R)2880 xcb_render_add_glyphs_glyphids_end (const xcb_render_add_glyphs_request_t *R)
2881 {
2882 xcb_generic_iterator_t i;
2883 i.data = ((uint32_t *) (R + 1)) + (R->glyphs_len);
2884 i.rem = 0;
2885 i.index = (char *) i.data - (char *) R;
2886 return i;
2887 }
2888
2889 xcb_render_glyphinfo_t *
xcb_render_add_glyphs_glyphs(const xcb_render_add_glyphs_request_t * R)2890 xcb_render_add_glyphs_glyphs (const xcb_render_add_glyphs_request_t *R)
2891 {
2892 xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R);
2893 return (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index) + 0);
2894 }
2895
2896 int
xcb_render_add_glyphs_glyphs_length(const xcb_render_add_glyphs_request_t * R)2897 xcb_render_add_glyphs_glyphs_length (const xcb_render_add_glyphs_request_t *R)
2898 {
2899 return R->glyphs_len;
2900 }
2901
2902 xcb_render_glyphinfo_iterator_t
xcb_render_add_glyphs_glyphs_iterator(const xcb_render_add_glyphs_request_t * R)2903 xcb_render_add_glyphs_glyphs_iterator (const xcb_render_add_glyphs_request_t *R)
2904 {
2905 xcb_render_glyphinfo_iterator_t i;
2906 xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R);
2907 i.data = (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index));
2908 i.rem = R->glyphs_len;
2909 i.index = (char *) i.data - (char *) R;
2910 return i;
2911 }
2912
2913 uint8_t *
xcb_render_add_glyphs_data(const xcb_render_add_glyphs_request_t * R)2914 xcb_render_add_glyphs_data (const xcb_render_add_glyphs_request_t *R)
2915 {
2916 xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R));
2917 return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
2918 }
2919
2920 int
xcb_render_add_glyphs_data_length(const xcb_render_add_glyphs_request_t * R)2921 xcb_render_add_glyphs_data_length (const xcb_render_add_glyphs_request_t *R)
2922 {
2923 return ((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t);
2924 }
2925
2926 xcb_generic_iterator_t
xcb_render_add_glyphs_data_end(const xcb_render_add_glyphs_request_t * R)2927 xcb_render_add_glyphs_data_end (const xcb_render_add_glyphs_request_t *R)
2928 {
2929 xcb_generic_iterator_t i;
2930 xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R));
2931 i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t));
2932 i.rem = 0;
2933 i.index = (char *) i.data - (char *) R;
2934 return i;
2935 }
2936
2937 int
xcb_render_free_glyphs_sizeof(const void * _buffer,uint32_t glyphs_len)2938 xcb_render_free_glyphs_sizeof (const void *_buffer,
2939 uint32_t glyphs_len)
2940 {
2941 char *xcb_tmp = (char *)_buffer;
2942 unsigned int xcb_buffer_len = 0;
2943 unsigned int xcb_block_len = 0;
2944 unsigned int xcb_pad = 0;
2945 unsigned int xcb_align_to = 0;
2946
2947
2948 xcb_block_len += sizeof(xcb_render_free_glyphs_request_t);
2949 xcb_tmp += xcb_block_len;
2950 xcb_buffer_len += xcb_block_len;
2951 xcb_block_len = 0;
2952 /* glyphs */
2953 xcb_block_len += glyphs_len * sizeof(xcb_render_glyph_t);
2954 xcb_tmp += xcb_block_len;
2955 xcb_align_to = ALIGNOF(xcb_render_glyph_t);
2956 /* insert padding */
2957 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2958 xcb_buffer_len += xcb_block_len + xcb_pad;
2959 if (0 != xcb_pad) {
2960 xcb_tmp += xcb_pad;
2961 xcb_pad = 0;
2962 }
2963 xcb_block_len = 0;
2964
2965 return xcb_buffer_len;
2966 }
2967
2968 xcb_void_cookie_t
xcb_render_free_glyphs_checked(xcb_connection_t * c,xcb_render_glyphset_t glyphset,uint32_t glyphs_len,const xcb_render_glyph_t * glyphs)2969 xcb_render_free_glyphs_checked (xcb_connection_t *c,
2970 xcb_render_glyphset_t glyphset,
2971 uint32_t glyphs_len,
2972 const xcb_render_glyph_t *glyphs)
2973 {
2974 static const xcb_protocol_request_t xcb_req = {
2975 .count = 4,
2976 .ext = &xcb_render_id,
2977 .opcode = XCB_RENDER_FREE_GLYPHS,
2978 .isvoid = 1
2979 };
2980
2981 struct iovec xcb_parts[6];
2982 xcb_void_cookie_t xcb_ret;
2983 xcb_render_free_glyphs_request_t xcb_out;
2984
2985 xcb_out.glyphset = glyphset;
2986
2987 xcb_parts[2].iov_base = (char *) &xcb_out;
2988 xcb_parts[2].iov_len = sizeof(xcb_out);
2989 xcb_parts[3].iov_base = 0;
2990 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2991 /* xcb_render_glyph_t glyphs */
2992 xcb_parts[4].iov_base = (char *) glyphs;
2993 xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
2994 xcb_parts[5].iov_base = 0;
2995 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2996
2997 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2998 return xcb_ret;
2999 }
3000
3001 xcb_void_cookie_t
xcb_render_free_glyphs(xcb_connection_t * c,xcb_render_glyphset_t glyphset,uint32_t glyphs_len,const xcb_render_glyph_t * glyphs)3002 xcb_render_free_glyphs (xcb_connection_t *c,
3003 xcb_render_glyphset_t glyphset,
3004 uint32_t glyphs_len,
3005 const xcb_render_glyph_t *glyphs)
3006 {
3007 static const xcb_protocol_request_t xcb_req = {
3008 .count = 4,
3009 .ext = &xcb_render_id,
3010 .opcode = XCB_RENDER_FREE_GLYPHS,
3011 .isvoid = 1
3012 };
3013
3014 struct iovec xcb_parts[6];
3015 xcb_void_cookie_t xcb_ret;
3016 xcb_render_free_glyphs_request_t xcb_out;
3017
3018 xcb_out.glyphset = glyphset;
3019
3020 xcb_parts[2].iov_base = (char *) &xcb_out;
3021 xcb_parts[2].iov_len = sizeof(xcb_out);
3022 xcb_parts[3].iov_base = 0;
3023 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3024 /* xcb_render_glyph_t glyphs */
3025 xcb_parts[4].iov_base = (char *) glyphs;
3026 xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
3027 xcb_parts[5].iov_base = 0;
3028 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3029
3030 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3031 return xcb_ret;
3032 }
3033
3034 xcb_render_glyph_t *
xcb_render_free_glyphs_glyphs(const xcb_render_free_glyphs_request_t * R)3035 xcb_render_free_glyphs_glyphs (const xcb_render_free_glyphs_request_t *R)
3036 {
3037 return (xcb_render_glyph_t *) (R + 1);
3038 }
3039
3040 int
xcb_render_free_glyphs_glyphs_length(const xcb_render_free_glyphs_request_t * R)3041 xcb_render_free_glyphs_glyphs_length (const xcb_render_free_glyphs_request_t *R)
3042 {
3043 return (((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t));
3044 }
3045
3046 xcb_generic_iterator_t
xcb_render_free_glyphs_glyphs_end(const xcb_render_free_glyphs_request_t * R)3047 xcb_render_free_glyphs_glyphs_end (const xcb_render_free_glyphs_request_t *R)
3048 {
3049 xcb_generic_iterator_t i;
3050 i.data = ((xcb_render_glyph_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t)));
3051 i.rem = 0;
3052 i.index = (char *) i.data - (char *) R;
3053 return i;
3054 }
3055
3056 int
xcb_render_composite_glyphs_8_sizeof(const void * _buffer,uint32_t glyphcmds_len)3057 xcb_render_composite_glyphs_8_sizeof (const void *_buffer,
3058 uint32_t glyphcmds_len)
3059 {
3060 char *xcb_tmp = (char *)_buffer;
3061 unsigned int xcb_buffer_len = 0;
3062 unsigned int xcb_block_len = 0;
3063 unsigned int xcb_pad = 0;
3064 unsigned int xcb_align_to = 0;
3065
3066
3067 xcb_block_len += sizeof(xcb_render_composite_glyphs_8_request_t);
3068 xcb_tmp += xcb_block_len;
3069 xcb_buffer_len += xcb_block_len;
3070 xcb_block_len = 0;
3071 /* glyphcmds */
3072 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
3073 xcb_tmp += xcb_block_len;
3074 xcb_align_to = ALIGNOF(uint8_t);
3075 /* insert padding */
3076 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3077 xcb_buffer_len += xcb_block_len + xcb_pad;
3078 if (0 != xcb_pad) {
3079 xcb_tmp += xcb_pad;
3080 xcb_pad = 0;
3081 }
3082 xcb_block_len = 0;
3083
3084 return xcb_buffer_len;
3085 }
3086
3087 xcb_void_cookie_t
xcb_render_composite_glyphs_8_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3088 xcb_render_composite_glyphs_8_checked (xcb_connection_t *c,
3089 uint8_t op,
3090 xcb_render_picture_t src,
3091 xcb_render_picture_t dst,
3092 xcb_render_pictformat_t mask_format,
3093 xcb_render_glyphset_t glyphset,
3094 int16_t src_x,
3095 int16_t src_y,
3096 uint32_t glyphcmds_len,
3097 const uint8_t *glyphcmds)
3098 {
3099 static const xcb_protocol_request_t xcb_req = {
3100 .count = 4,
3101 .ext = &xcb_render_id,
3102 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8,
3103 .isvoid = 1
3104 };
3105
3106 struct iovec xcb_parts[6];
3107 xcb_void_cookie_t xcb_ret;
3108 xcb_render_composite_glyphs_8_request_t xcb_out;
3109
3110 xcb_out.op = op;
3111 memset(xcb_out.pad0, 0, 3);
3112 xcb_out.src = src;
3113 xcb_out.dst = dst;
3114 xcb_out.mask_format = mask_format;
3115 xcb_out.glyphset = glyphset;
3116 xcb_out.src_x = src_x;
3117 xcb_out.src_y = src_y;
3118
3119 xcb_parts[2].iov_base = (char *) &xcb_out;
3120 xcb_parts[2].iov_len = sizeof(xcb_out);
3121 xcb_parts[3].iov_base = 0;
3122 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3123 /* uint8_t glyphcmds */
3124 xcb_parts[4].iov_base = (char *) glyphcmds;
3125 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3126 xcb_parts[5].iov_base = 0;
3127 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3128
3129 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3130 return xcb_ret;
3131 }
3132
3133 xcb_void_cookie_t
xcb_render_composite_glyphs_8(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3134 xcb_render_composite_glyphs_8 (xcb_connection_t *c,
3135 uint8_t op,
3136 xcb_render_picture_t src,
3137 xcb_render_picture_t dst,
3138 xcb_render_pictformat_t mask_format,
3139 xcb_render_glyphset_t glyphset,
3140 int16_t src_x,
3141 int16_t src_y,
3142 uint32_t glyphcmds_len,
3143 const uint8_t *glyphcmds)
3144 {
3145 static const xcb_protocol_request_t xcb_req = {
3146 .count = 4,
3147 .ext = &xcb_render_id,
3148 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8,
3149 .isvoid = 1
3150 };
3151
3152 struct iovec xcb_parts[6];
3153 xcb_void_cookie_t xcb_ret;
3154 xcb_render_composite_glyphs_8_request_t xcb_out;
3155
3156 xcb_out.op = op;
3157 memset(xcb_out.pad0, 0, 3);
3158 xcb_out.src = src;
3159 xcb_out.dst = dst;
3160 xcb_out.mask_format = mask_format;
3161 xcb_out.glyphset = glyphset;
3162 xcb_out.src_x = src_x;
3163 xcb_out.src_y = src_y;
3164
3165 xcb_parts[2].iov_base = (char *) &xcb_out;
3166 xcb_parts[2].iov_len = sizeof(xcb_out);
3167 xcb_parts[3].iov_base = 0;
3168 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3169 /* uint8_t glyphcmds */
3170 xcb_parts[4].iov_base = (char *) glyphcmds;
3171 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3172 xcb_parts[5].iov_base = 0;
3173 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3174
3175 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3176 return xcb_ret;
3177 }
3178
3179 uint8_t *
xcb_render_composite_glyphs_8_glyphcmds(const xcb_render_composite_glyphs_8_request_t * R)3180 xcb_render_composite_glyphs_8_glyphcmds (const xcb_render_composite_glyphs_8_request_t *R)
3181 {
3182 return (uint8_t *) (R + 1);
3183 }
3184
3185 int
xcb_render_composite_glyphs_8_glyphcmds_length(const xcb_render_composite_glyphs_8_request_t * R)3186 xcb_render_composite_glyphs_8_glyphcmds_length (const xcb_render_composite_glyphs_8_request_t *R)
3187 {
3188 return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t));
3189 }
3190
3191 xcb_generic_iterator_t
xcb_render_composite_glyphs_8_glyphcmds_end(const xcb_render_composite_glyphs_8_request_t * R)3192 xcb_render_composite_glyphs_8_glyphcmds_end (const xcb_render_composite_glyphs_8_request_t *R)
3193 {
3194 xcb_generic_iterator_t i;
3195 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t)));
3196 i.rem = 0;
3197 i.index = (char *) i.data - (char *) R;
3198 return i;
3199 }
3200
3201 int
xcb_render_composite_glyphs_16_sizeof(const void * _buffer,uint32_t glyphcmds_len)3202 xcb_render_composite_glyphs_16_sizeof (const void *_buffer,
3203 uint32_t glyphcmds_len)
3204 {
3205 char *xcb_tmp = (char *)_buffer;
3206 unsigned int xcb_buffer_len = 0;
3207 unsigned int xcb_block_len = 0;
3208 unsigned int xcb_pad = 0;
3209 unsigned int xcb_align_to = 0;
3210
3211
3212 xcb_block_len += sizeof(xcb_render_composite_glyphs_16_request_t);
3213 xcb_tmp += xcb_block_len;
3214 xcb_buffer_len += xcb_block_len;
3215 xcb_block_len = 0;
3216 /* glyphcmds */
3217 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
3218 xcb_tmp += xcb_block_len;
3219 xcb_align_to = ALIGNOF(uint8_t);
3220 /* insert padding */
3221 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3222 xcb_buffer_len += xcb_block_len + xcb_pad;
3223 if (0 != xcb_pad) {
3224 xcb_tmp += xcb_pad;
3225 xcb_pad = 0;
3226 }
3227 xcb_block_len = 0;
3228
3229 return xcb_buffer_len;
3230 }
3231
3232 xcb_void_cookie_t
xcb_render_composite_glyphs_16_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3233 xcb_render_composite_glyphs_16_checked (xcb_connection_t *c,
3234 uint8_t op,
3235 xcb_render_picture_t src,
3236 xcb_render_picture_t dst,
3237 xcb_render_pictformat_t mask_format,
3238 xcb_render_glyphset_t glyphset,
3239 int16_t src_x,
3240 int16_t src_y,
3241 uint32_t glyphcmds_len,
3242 const uint8_t *glyphcmds)
3243 {
3244 static const xcb_protocol_request_t xcb_req = {
3245 .count = 4,
3246 .ext = &xcb_render_id,
3247 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16,
3248 .isvoid = 1
3249 };
3250
3251 struct iovec xcb_parts[6];
3252 xcb_void_cookie_t xcb_ret;
3253 xcb_render_composite_glyphs_16_request_t xcb_out;
3254
3255 xcb_out.op = op;
3256 memset(xcb_out.pad0, 0, 3);
3257 xcb_out.src = src;
3258 xcb_out.dst = dst;
3259 xcb_out.mask_format = mask_format;
3260 xcb_out.glyphset = glyphset;
3261 xcb_out.src_x = src_x;
3262 xcb_out.src_y = src_y;
3263
3264 xcb_parts[2].iov_base = (char *) &xcb_out;
3265 xcb_parts[2].iov_len = sizeof(xcb_out);
3266 xcb_parts[3].iov_base = 0;
3267 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3268 /* uint8_t glyphcmds */
3269 xcb_parts[4].iov_base = (char *) glyphcmds;
3270 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3271 xcb_parts[5].iov_base = 0;
3272 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3273
3274 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3275 return xcb_ret;
3276 }
3277
3278 xcb_void_cookie_t
xcb_render_composite_glyphs_16(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3279 xcb_render_composite_glyphs_16 (xcb_connection_t *c,
3280 uint8_t op,
3281 xcb_render_picture_t src,
3282 xcb_render_picture_t dst,
3283 xcb_render_pictformat_t mask_format,
3284 xcb_render_glyphset_t glyphset,
3285 int16_t src_x,
3286 int16_t src_y,
3287 uint32_t glyphcmds_len,
3288 const uint8_t *glyphcmds)
3289 {
3290 static const xcb_protocol_request_t xcb_req = {
3291 .count = 4,
3292 .ext = &xcb_render_id,
3293 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16,
3294 .isvoid = 1
3295 };
3296
3297 struct iovec xcb_parts[6];
3298 xcb_void_cookie_t xcb_ret;
3299 xcb_render_composite_glyphs_16_request_t xcb_out;
3300
3301 xcb_out.op = op;
3302 memset(xcb_out.pad0, 0, 3);
3303 xcb_out.src = src;
3304 xcb_out.dst = dst;
3305 xcb_out.mask_format = mask_format;
3306 xcb_out.glyphset = glyphset;
3307 xcb_out.src_x = src_x;
3308 xcb_out.src_y = src_y;
3309
3310 xcb_parts[2].iov_base = (char *) &xcb_out;
3311 xcb_parts[2].iov_len = sizeof(xcb_out);
3312 xcb_parts[3].iov_base = 0;
3313 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3314 /* uint8_t glyphcmds */
3315 xcb_parts[4].iov_base = (char *) glyphcmds;
3316 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3317 xcb_parts[5].iov_base = 0;
3318 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3319
3320 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3321 return xcb_ret;
3322 }
3323
3324 uint8_t *
xcb_render_composite_glyphs_16_glyphcmds(const xcb_render_composite_glyphs_16_request_t * R)3325 xcb_render_composite_glyphs_16_glyphcmds (const xcb_render_composite_glyphs_16_request_t *R)
3326 {
3327 return (uint8_t *) (R + 1);
3328 }
3329
3330 int
xcb_render_composite_glyphs_16_glyphcmds_length(const xcb_render_composite_glyphs_16_request_t * R)3331 xcb_render_composite_glyphs_16_glyphcmds_length (const xcb_render_composite_glyphs_16_request_t *R)
3332 {
3333 return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t));
3334 }
3335
3336 xcb_generic_iterator_t
xcb_render_composite_glyphs_16_glyphcmds_end(const xcb_render_composite_glyphs_16_request_t * R)3337 xcb_render_composite_glyphs_16_glyphcmds_end (const xcb_render_composite_glyphs_16_request_t *R)
3338 {
3339 xcb_generic_iterator_t i;
3340 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t)));
3341 i.rem = 0;
3342 i.index = (char *) i.data - (char *) R;
3343 return i;
3344 }
3345
3346 int
xcb_render_composite_glyphs_32_sizeof(const void * _buffer,uint32_t glyphcmds_len)3347 xcb_render_composite_glyphs_32_sizeof (const void *_buffer,
3348 uint32_t glyphcmds_len)
3349 {
3350 char *xcb_tmp = (char *)_buffer;
3351 unsigned int xcb_buffer_len = 0;
3352 unsigned int xcb_block_len = 0;
3353 unsigned int xcb_pad = 0;
3354 unsigned int xcb_align_to = 0;
3355
3356
3357 xcb_block_len += sizeof(xcb_render_composite_glyphs_32_request_t);
3358 xcb_tmp += xcb_block_len;
3359 xcb_buffer_len += xcb_block_len;
3360 xcb_block_len = 0;
3361 /* glyphcmds */
3362 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
3363 xcb_tmp += xcb_block_len;
3364 xcb_align_to = ALIGNOF(uint8_t);
3365 /* insert padding */
3366 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3367 xcb_buffer_len += xcb_block_len + xcb_pad;
3368 if (0 != xcb_pad) {
3369 xcb_tmp += xcb_pad;
3370 xcb_pad = 0;
3371 }
3372 xcb_block_len = 0;
3373
3374 return xcb_buffer_len;
3375 }
3376
3377 xcb_void_cookie_t
xcb_render_composite_glyphs_32_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3378 xcb_render_composite_glyphs_32_checked (xcb_connection_t *c,
3379 uint8_t op,
3380 xcb_render_picture_t src,
3381 xcb_render_picture_t dst,
3382 xcb_render_pictformat_t mask_format,
3383 xcb_render_glyphset_t glyphset,
3384 int16_t src_x,
3385 int16_t src_y,
3386 uint32_t glyphcmds_len,
3387 const uint8_t *glyphcmds)
3388 {
3389 static const xcb_protocol_request_t xcb_req = {
3390 .count = 4,
3391 .ext = &xcb_render_id,
3392 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32,
3393 .isvoid = 1
3394 };
3395
3396 struct iovec xcb_parts[6];
3397 xcb_void_cookie_t xcb_ret;
3398 xcb_render_composite_glyphs_32_request_t xcb_out;
3399
3400 xcb_out.op = op;
3401 memset(xcb_out.pad0, 0, 3);
3402 xcb_out.src = src;
3403 xcb_out.dst = dst;
3404 xcb_out.mask_format = mask_format;
3405 xcb_out.glyphset = glyphset;
3406 xcb_out.src_x = src_x;
3407 xcb_out.src_y = src_y;
3408
3409 xcb_parts[2].iov_base = (char *) &xcb_out;
3410 xcb_parts[2].iov_len = sizeof(xcb_out);
3411 xcb_parts[3].iov_base = 0;
3412 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3413 /* uint8_t glyphcmds */
3414 xcb_parts[4].iov_base = (char *) glyphcmds;
3415 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3416 xcb_parts[5].iov_base = 0;
3417 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3418
3419 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3420 return xcb_ret;
3421 }
3422
3423 xcb_void_cookie_t
xcb_render_composite_glyphs_32(xcb_connection_t * c,uint8_t op,xcb_render_picture_t src,xcb_render_picture_t dst,xcb_render_pictformat_t mask_format,xcb_render_glyphset_t glyphset,int16_t src_x,int16_t src_y,uint32_t glyphcmds_len,const uint8_t * glyphcmds)3424 xcb_render_composite_glyphs_32 (xcb_connection_t *c,
3425 uint8_t op,
3426 xcb_render_picture_t src,
3427 xcb_render_picture_t dst,
3428 xcb_render_pictformat_t mask_format,
3429 xcb_render_glyphset_t glyphset,
3430 int16_t src_x,
3431 int16_t src_y,
3432 uint32_t glyphcmds_len,
3433 const uint8_t *glyphcmds)
3434 {
3435 static const xcb_protocol_request_t xcb_req = {
3436 .count = 4,
3437 .ext = &xcb_render_id,
3438 .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32,
3439 .isvoid = 1
3440 };
3441
3442 struct iovec xcb_parts[6];
3443 xcb_void_cookie_t xcb_ret;
3444 xcb_render_composite_glyphs_32_request_t xcb_out;
3445
3446 xcb_out.op = op;
3447 memset(xcb_out.pad0, 0, 3);
3448 xcb_out.src = src;
3449 xcb_out.dst = dst;
3450 xcb_out.mask_format = mask_format;
3451 xcb_out.glyphset = glyphset;
3452 xcb_out.src_x = src_x;
3453 xcb_out.src_y = src_y;
3454
3455 xcb_parts[2].iov_base = (char *) &xcb_out;
3456 xcb_parts[2].iov_len = sizeof(xcb_out);
3457 xcb_parts[3].iov_base = 0;
3458 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3459 /* uint8_t glyphcmds */
3460 xcb_parts[4].iov_base = (char *) glyphcmds;
3461 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
3462 xcb_parts[5].iov_base = 0;
3463 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3464
3465 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3466 return xcb_ret;
3467 }
3468
3469 uint8_t *
xcb_render_composite_glyphs_32_glyphcmds(const xcb_render_composite_glyphs_32_request_t * R)3470 xcb_render_composite_glyphs_32_glyphcmds (const xcb_render_composite_glyphs_32_request_t *R)
3471 {
3472 return (uint8_t *) (R + 1);
3473 }
3474
3475 int
xcb_render_composite_glyphs_32_glyphcmds_length(const xcb_render_composite_glyphs_32_request_t * R)3476 xcb_render_composite_glyphs_32_glyphcmds_length (const xcb_render_composite_glyphs_32_request_t *R)
3477 {
3478 return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t));
3479 }
3480
3481 xcb_generic_iterator_t
xcb_render_composite_glyphs_32_glyphcmds_end(const xcb_render_composite_glyphs_32_request_t * R)3482 xcb_render_composite_glyphs_32_glyphcmds_end (const xcb_render_composite_glyphs_32_request_t *R)
3483 {
3484 xcb_generic_iterator_t i;
3485 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t)));
3486 i.rem = 0;
3487 i.index = (char *) i.data - (char *) R;
3488 return i;
3489 }
3490
3491 int
xcb_render_fill_rectangles_sizeof(const void * _buffer,uint32_t rects_len)3492 xcb_render_fill_rectangles_sizeof (const void *_buffer,
3493 uint32_t rects_len)
3494 {
3495 char *xcb_tmp = (char *)_buffer;
3496 unsigned int xcb_buffer_len = 0;
3497 unsigned int xcb_block_len = 0;
3498 unsigned int xcb_pad = 0;
3499 unsigned int xcb_align_to = 0;
3500
3501
3502 xcb_block_len += sizeof(xcb_render_fill_rectangles_request_t);
3503 xcb_tmp += xcb_block_len;
3504 xcb_buffer_len += xcb_block_len;
3505 xcb_block_len = 0;
3506 /* rects */
3507 xcb_block_len += rects_len * sizeof(xcb_rectangle_t);
3508 xcb_tmp += xcb_block_len;
3509 xcb_align_to = ALIGNOF(xcb_rectangle_t);
3510 /* insert padding */
3511 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3512 xcb_buffer_len += xcb_block_len + xcb_pad;
3513 if (0 != xcb_pad) {
3514 xcb_tmp += xcb_pad;
3515 xcb_pad = 0;
3516 }
3517 xcb_block_len = 0;
3518
3519 return xcb_buffer_len;
3520 }
3521
3522 xcb_void_cookie_t
xcb_render_fill_rectangles_checked(xcb_connection_t * c,uint8_t op,xcb_render_picture_t dst,xcb_render_color_t color,uint32_t rects_len,const xcb_rectangle_t * rects)3523 xcb_render_fill_rectangles_checked (xcb_connection_t *c,
3524 uint8_t op,
3525 xcb_render_picture_t dst,
3526 xcb_render_color_t color,
3527 uint32_t rects_len,
3528 const xcb_rectangle_t *rects)
3529 {
3530 static const xcb_protocol_request_t xcb_req = {
3531 .count = 4,
3532 .ext = &xcb_render_id,
3533 .opcode = XCB_RENDER_FILL_RECTANGLES,
3534 .isvoid = 1
3535 };
3536
3537 struct iovec xcb_parts[6];
3538 xcb_void_cookie_t xcb_ret;
3539 xcb_render_fill_rectangles_request_t xcb_out;
3540
3541 xcb_out.op = op;
3542 memset(xcb_out.pad0, 0, 3);
3543 xcb_out.dst = dst;
3544 xcb_out.color = color;
3545
3546 xcb_parts[2].iov_base = (char *) &xcb_out;
3547 xcb_parts[2].iov_len = sizeof(xcb_out);
3548 xcb_parts[3].iov_base = 0;
3549 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3550 /* xcb_rectangle_t rects */
3551 xcb_parts[4].iov_base = (char *) rects;
3552 xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
3553 xcb_parts[5].iov_base = 0;
3554 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3555
3556 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3557 return xcb_ret;
3558 }
3559
3560 xcb_void_cookie_t
xcb_render_fill_rectangles(xcb_connection_t * c,uint8_t op,xcb_render_picture_t dst,xcb_render_color_t color,uint32_t rects_len,const xcb_rectangle_t * rects)3561 xcb_render_fill_rectangles (xcb_connection_t *c,
3562 uint8_t op,
3563 xcb_render_picture_t dst,
3564 xcb_render_color_t color,
3565 uint32_t rects_len,
3566 const xcb_rectangle_t *rects)
3567 {
3568 static const xcb_protocol_request_t xcb_req = {
3569 .count = 4,
3570 .ext = &xcb_render_id,
3571 .opcode = XCB_RENDER_FILL_RECTANGLES,
3572 .isvoid = 1
3573 };
3574
3575 struct iovec xcb_parts[6];
3576 xcb_void_cookie_t xcb_ret;
3577 xcb_render_fill_rectangles_request_t xcb_out;
3578
3579 xcb_out.op = op;
3580 memset(xcb_out.pad0, 0, 3);
3581 xcb_out.dst = dst;
3582 xcb_out.color = color;
3583
3584 xcb_parts[2].iov_base = (char *) &xcb_out;
3585 xcb_parts[2].iov_len = sizeof(xcb_out);
3586 xcb_parts[3].iov_base = 0;
3587 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3588 /* xcb_rectangle_t rects */
3589 xcb_parts[4].iov_base = (char *) rects;
3590 xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
3591 xcb_parts[5].iov_base = 0;
3592 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3593
3594 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3595 return xcb_ret;
3596 }
3597
3598 xcb_rectangle_t *
xcb_render_fill_rectangles_rects(const xcb_render_fill_rectangles_request_t * R)3599 xcb_render_fill_rectangles_rects (const xcb_render_fill_rectangles_request_t *R)
3600 {
3601 return (xcb_rectangle_t *) (R + 1);
3602 }
3603
3604 int
xcb_render_fill_rectangles_rects_length(const xcb_render_fill_rectangles_request_t * R)3605 xcb_render_fill_rectangles_rects_length (const xcb_render_fill_rectangles_request_t *R)
3606 {
3607 return (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t));
3608 }
3609
3610 xcb_rectangle_iterator_t
xcb_render_fill_rectangles_rects_iterator(const xcb_render_fill_rectangles_request_t * R)3611 xcb_render_fill_rectangles_rects_iterator (const xcb_render_fill_rectangles_request_t *R)
3612 {
3613 xcb_rectangle_iterator_t i;
3614 i.data = (xcb_rectangle_t *) (R + 1);
3615 i.rem = (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t));
3616 i.index = (char *) i.data - (char *) R;
3617 return i;
3618 }
3619
3620 xcb_void_cookie_t
xcb_render_create_cursor_checked(xcb_connection_t * c,xcb_cursor_t cid,xcb_render_picture_t source,uint16_t x,uint16_t y)3621 xcb_render_create_cursor_checked (xcb_connection_t *c,
3622 xcb_cursor_t cid,
3623 xcb_render_picture_t source,
3624 uint16_t x,
3625 uint16_t y)
3626 {
3627 static const xcb_protocol_request_t xcb_req = {
3628 .count = 2,
3629 .ext = &xcb_render_id,
3630 .opcode = XCB_RENDER_CREATE_CURSOR,
3631 .isvoid = 1
3632 };
3633
3634 struct iovec xcb_parts[4];
3635 xcb_void_cookie_t xcb_ret;
3636 xcb_render_create_cursor_request_t xcb_out;
3637
3638 xcb_out.cid = cid;
3639 xcb_out.source = source;
3640 xcb_out.x = x;
3641 xcb_out.y = y;
3642
3643 xcb_parts[2].iov_base = (char *) &xcb_out;
3644 xcb_parts[2].iov_len = sizeof(xcb_out);
3645 xcb_parts[3].iov_base = 0;
3646 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3647
3648 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3649 return xcb_ret;
3650 }
3651
3652 xcb_void_cookie_t
xcb_render_create_cursor(xcb_connection_t * c,xcb_cursor_t cid,xcb_render_picture_t source,uint16_t x,uint16_t y)3653 xcb_render_create_cursor (xcb_connection_t *c,
3654 xcb_cursor_t cid,
3655 xcb_render_picture_t source,
3656 uint16_t x,
3657 uint16_t y)
3658 {
3659 static const xcb_protocol_request_t xcb_req = {
3660 .count = 2,
3661 .ext = &xcb_render_id,
3662 .opcode = XCB_RENDER_CREATE_CURSOR,
3663 .isvoid = 1
3664 };
3665
3666 struct iovec xcb_parts[4];
3667 xcb_void_cookie_t xcb_ret;
3668 xcb_render_create_cursor_request_t xcb_out;
3669
3670 xcb_out.cid = cid;
3671 xcb_out.source = source;
3672 xcb_out.x = x;
3673 xcb_out.y = y;
3674
3675 xcb_parts[2].iov_base = (char *) &xcb_out;
3676 xcb_parts[2].iov_len = sizeof(xcb_out);
3677 xcb_parts[3].iov_base = 0;
3678 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3679
3680 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3681 return xcb_ret;
3682 }
3683
3684 void
xcb_render_transform_next(xcb_render_transform_iterator_t * i)3685 xcb_render_transform_next (xcb_render_transform_iterator_t *i)
3686 {
3687 --i->rem;
3688 ++i->data;
3689 i->index += sizeof(xcb_render_transform_t);
3690 }
3691
3692 xcb_generic_iterator_t
xcb_render_transform_end(xcb_render_transform_iterator_t i)3693 xcb_render_transform_end (xcb_render_transform_iterator_t i)
3694 {
3695 xcb_generic_iterator_t ret;
3696 ret.data = i.data + i.rem;
3697 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3698 ret.rem = 0;
3699 return ret;
3700 }
3701
3702 xcb_void_cookie_t
xcb_render_set_picture_transform_checked(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_transform_t transform)3703 xcb_render_set_picture_transform_checked (xcb_connection_t *c,
3704 xcb_render_picture_t picture,
3705 xcb_render_transform_t transform)
3706 {
3707 static const xcb_protocol_request_t xcb_req = {
3708 .count = 2,
3709 .ext = &xcb_render_id,
3710 .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM,
3711 .isvoid = 1
3712 };
3713
3714 struct iovec xcb_parts[4];
3715 xcb_void_cookie_t xcb_ret;
3716 xcb_render_set_picture_transform_request_t xcb_out;
3717
3718 xcb_out.picture = picture;
3719 xcb_out.transform = transform;
3720
3721 xcb_parts[2].iov_base = (char *) &xcb_out;
3722 xcb_parts[2].iov_len = sizeof(xcb_out);
3723 xcb_parts[3].iov_base = 0;
3724 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3725
3726 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3727 return xcb_ret;
3728 }
3729
3730 xcb_void_cookie_t
xcb_render_set_picture_transform(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_transform_t transform)3731 xcb_render_set_picture_transform (xcb_connection_t *c,
3732 xcb_render_picture_t picture,
3733 xcb_render_transform_t transform)
3734 {
3735 static const xcb_protocol_request_t xcb_req = {
3736 .count = 2,
3737 .ext = &xcb_render_id,
3738 .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM,
3739 .isvoid = 1
3740 };
3741
3742 struct iovec xcb_parts[4];
3743 xcb_void_cookie_t xcb_ret;
3744 xcb_render_set_picture_transform_request_t xcb_out;
3745
3746 xcb_out.picture = picture;
3747 xcb_out.transform = transform;
3748
3749 xcb_parts[2].iov_base = (char *) &xcb_out;
3750 xcb_parts[2].iov_len = sizeof(xcb_out);
3751 xcb_parts[3].iov_base = 0;
3752 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3753
3754 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3755 return xcb_ret;
3756 }
3757
3758 int
xcb_render_query_filters_sizeof(const void * _buffer)3759 xcb_render_query_filters_sizeof (const void *_buffer)
3760 {
3761 char *xcb_tmp = (char *)_buffer;
3762 const xcb_render_query_filters_reply_t *_aux = (xcb_render_query_filters_reply_t *)_buffer;
3763 unsigned int xcb_buffer_len = 0;
3764 unsigned int xcb_block_len = 0;
3765 unsigned int xcb_pad = 0;
3766 unsigned int xcb_align_to = 0;
3767
3768 unsigned int i;
3769 unsigned int xcb_tmp_len;
3770
3771 xcb_block_len += sizeof(xcb_render_query_filters_reply_t);
3772 xcb_tmp += xcb_block_len;
3773 xcb_buffer_len += xcb_block_len;
3774 xcb_block_len = 0;
3775 /* aliases */
3776 xcb_block_len += _aux->num_aliases * sizeof(uint16_t);
3777 xcb_tmp += xcb_block_len;
3778 xcb_align_to = ALIGNOF(uint16_t);
3779 /* insert padding */
3780 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3781 xcb_buffer_len += xcb_block_len + xcb_pad;
3782 if (0 != xcb_pad) {
3783 xcb_tmp += xcb_pad;
3784 xcb_pad = 0;
3785 }
3786 xcb_block_len = 0;
3787 /* filters */
3788 for(i=0; i<_aux->num_filters; i++) {
3789 xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
3790 xcb_block_len += xcb_tmp_len;
3791 xcb_tmp += xcb_tmp_len;
3792 }
3793 xcb_align_to = ALIGNOF(xcb_str_t);
3794 /* insert padding */
3795 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3796 xcb_buffer_len += xcb_block_len + xcb_pad;
3797 if (0 != xcb_pad) {
3798 xcb_tmp += xcb_pad;
3799 xcb_pad = 0;
3800 }
3801 xcb_block_len = 0;
3802
3803 return xcb_buffer_len;
3804 }
3805
3806 xcb_render_query_filters_cookie_t
xcb_render_query_filters(xcb_connection_t * c,xcb_drawable_t drawable)3807 xcb_render_query_filters (xcb_connection_t *c,
3808 xcb_drawable_t drawable)
3809 {
3810 static const xcb_protocol_request_t xcb_req = {
3811 .count = 2,
3812 .ext = &xcb_render_id,
3813 .opcode = XCB_RENDER_QUERY_FILTERS,
3814 .isvoid = 0
3815 };
3816
3817 struct iovec xcb_parts[4];
3818 xcb_render_query_filters_cookie_t xcb_ret;
3819 xcb_render_query_filters_request_t xcb_out;
3820
3821 xcb_out.drawable = drawable;
3822
3823 xcb_parts[2].iov_base = (char *) &xcb_out;
3824 xcb_parts[2].iov_len = sizeof(xcb_out);
3825 xcb_parts[3].iov_base = 0;
3826 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3827
3828 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3829 return xcb_ret;
3830 }
3831
3832 xcb_render_query_filters_cookie_t
xcb_render_query_filters_unchecked(xcb_connection_t * c,xcb_drawable_t drawable)3833 xcb_render_query_filters_unchecked (xcb_connection_t *c,
3834 xcb_drawable_t drawable)
3835 {
3836 static const xcb_protocol_request_t xcb_req = {
3837 .count = 2,
3838 .ext = &xcb_render_id,
3839 .opcode = XCB_RENDER_QUERY_FILTERS,
3840 .isvoid = 0
3841 };
3842
3843 struct iovec xcb_parts[4];
3844 xcb_render_query_filters_cookie_t xcb_ret;
3845 xcb_render_query_filters_request_t xcb_out;
3846
3847 xcb_out.drawable = drawable;
3848
3849 xcb_parts[2].iov_base = (char *) &xcb_out;
3850 xcb_parts[2].iov_len = sizeof(xcb_out);
3851 xcb_parts[3].iov_base = 0;
3852 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3853
3854 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3855 return xcb_ret;
3856 }
3857
3858 uint16_t *
xcb_render_query_filters_aliases(const xcb_render_query_filters_reply_t * R)3859 xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R)
3860 {
3861 return (uint16_t *) (R + 1);
3862 }
3863
3864 int
xcb_render_query_filters_aliases_length(const xcb_render_query_filters_reply_t * R)3865 xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R)
3866 {
3867 return R->num_aliases;
3868 }
3869
3870 xcb_generic_iterator_t
xcb_render_query_filters_aliases_end(const xcb_render_query_filters_reply_t * R)3871 xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R)
3872 {
3873 xcb_generic_iterator_t i;
3874 i.data = ((uint16_t *) (R + 1)) + (R->num_aliases);
3875 i.rem = 0;
3876 i.index = (char *) i.data - (char *) R;
3877 return i;
3878 }
3879
3880 int
xcb_render_query_filters_filters_length(const xcb_render_query_filters_reply_t * R)3881 xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R)
3882 {
3883 return R->num_filters;
3884 }
3885
3886 xcb_str_iterator_t
xcb_render_query_filters_filters_iterator(const xcb_render_query_filters_reply_t * R)3887 xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R)
3888 {
3889 xcb_str_iterator_t i;
3890 xcb_generic_iterator_t prev = xcb_render_query_filters_aliases_end(R);
3891 i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index));
3892 i.rem = R->num_filters;
3893 i.index = (char *) i.data - (char *) R;
3894 return i;
3895 }
3896
3897 xcb_render_query_filters_reply_t *
xcb_render_query_filters_reply(xcb_connection_t * c,xcb_render_query_filters_cookie_t cookie,xcb_generic_error_t ** e)3898 xcb_render_query_filters_reply (xcb_connection_t *c,
3899 xcb_render_query_filters_cookie_t cookie /**< */,
3900 xcb_generic_error_t **e)
3901 {
3902 return (xcb_render_query_filters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3903 }
3904
3905 int
xcb_render_set_picture_filter_sizeof(const void * _buffer,uint32_t values_len)3906 xcb_render_set_picture_filter_sizeof (const void *_buffer,
3907 uint32_t values_len)
3908 {
3909 char *xcb_tmp = (char *)_buffer;
3910 const xcb_render_set_picture_filter_request_t *_aux = (xcb_render_set_picture_filter_request_t *)_buffer;
3911 unsigned int xcb_buffer_len = 0;
3912 unsigned int xcb_block_len = 0;
3913 unsigned int xcb_pad = 0;
3914 unsigned int xcb_align_to = 0;
3915
3916
3917 xcb_block_len += sizeof(xcb_render_set_picture_filter_request_t);
3918 xcb_tmp += xcb_block_len;
3919 xcb_buffer_len += xcb_block_len;
3920 xcb_block_len = 0;
3921 /* filter */
3922 xcb_block_len += _aux->filter_len * sizeof(char);
3923 xcb_tmp += xcb_block_len;
3924 xcb_align_to = ALIGNOF(char);
3925 xcb_align_to = 4;
3926 /* insert padding */
3927 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3928 xcb_buffer_len += xcb_block_len + xcb_pad;
3929 if (0 != xcb_pad) {
3930 xcb_tmp += xcb_pad;
3931 xcb_pad = 0;
3932 }
3933 xcb_block_len = 0;
3934 /* insert padding */
3935 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3936 xcb_buffer_len += xcb_block_len + xcb_pad;
3937 if (0 != xcb_pad) {
3938 xcb_tmp += xcb_pad;
3939 xcb_pad = 0;
3940 }
3941 xcb_block_len = 0;
3942 /* values */
3943 xcb_block_len += values_len * sizeof(xcb_render_fixed_t);
3944 xcb_tmp += xcb_block_len;
3945 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
3946 /* insert padding */
3947 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3948 xcb_buffer_len += xcb_block_len + xcb_pad;
3949 if (0 != xcb_pad) {
3950 xcb_tmp += xcb_pad;
3951 xcb_pad = 0;
3952 }
3953 xcb_block_len = 0;
3954
3955 return xcb_buffer_len;
3956 }
3957
3958 xcb_void_cookie_t
xcb_render_set_picture_filter_checked(xcb_connection_t * c,xcb_render_picture_t picture,uint16_t filter_len,const char * filter,uint32_t values_len,const xcb_render_fixed_t * values)3959 xcb_render_set_picture_filter_checked (xcb_connection_t *c,
3960 xcb_render_picture_t picture,
3961 uint16_t filter_len,
3962 const char *filter,
3963 uint32_t values_len,
3964 const xcb_render_fixed_t *values)
3965 {
3966 static const xcb_protocol_request_t xcb_req = {
3967 .count = 6,
3968 .ext = &xcb_render_id,
3969 .opcode = XCB_RENDER_SET_PICTURE_FILTER,
3970 .isvoid = 1
3971 };
3972
3973 struct iovec xcb_parts[8];
3974 xcb_void_cookie_t xcb_ret;
3975 xcb_render_set_picture_filter_request_t xcb_out;
3976
3977 xcb_out.picture = picture;
3978 xcb_out.filter_len = filter_len;
3979 memset(xcb_out.pad0, 0, 2);
3980
3981 xcb_parts[2].iov_base = (char *) &xcb_out;
3982 xcb_parts[2].iov_len = sizeof(xcb_out);
3983 xcb_parts[3].iov_base = 0;
3984 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3985 /* char filter */
3986 xcb_parts[4].iov_base = (char *) filter;
3987 xcb_parts[4].iov_len = filter_len * sizeof(char);
3988 xcb_parts[5].iov_base = 0;
3989 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3990 /* xcb_render_fixed_t values */
3991 xcb_parts[6].iov_base = (char *) values;
3992 xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
3993 xcb_parts[7].iov_base = 0;
3994 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3995
3996 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3997 return xcb_ret;
3998 }
3999
4000 xcb_void_cookie_t
xcb_render_set_picture_filter(xcb_connection_t * c,xcb_render_picture_t picture,uint16_t filter_len,const char * filter,uint32_t values_len,const xcb_render_fixed_t * values)4001 xcb_render_set_picture_filter (xcb_connection_t *c,
4002 xcb_render_picture_t picture,
4003 uint16_t filter_len,
4004 const char *filter,
4005 uint32_t values_len,
4006 const xcb_render_fixed_t *values)
4007 {
4008 static const xcb_protocol_request_t xcb_req = {
4009 .count = 6,
4010 .ext = &xcb_render_id,
4011 .opcode = XCB_RENDER_SET_PICTURE_FILTER,
4012 .isvoid = 1
4013 };
4014
4015 struct iovec xcb_parts[8];
4016 xcb_void_cookie_t xcb_ret;
4017 xcb_render_set_picture_filter_request_t xcb_out;
4018
4019 xcb_out.picture = picture;
4020 xcb_out.filter_len = filter_len;
4021 memset(xcb_out.pad0, 0, 2);
4022
4023 xcb_parts[2].iov_base = (char *) &xcb_out;
4024 xcb_parts[2].iov_len = sizeof(xcb_out);
4025 xcb_parts[3].iov_base = 0;
4026 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4027 /* char filter */
4028 xcb_parts[4].iov_base = (char *) filter;
4029 xcb_parts[4].iov_len = filter_len * sizeof(char);
4030 xcb_parts[5].iov_base = 0;
4031 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4032 /* xcb_render_fixed_t values */
4033 xcb_parts[6].iov_base = (char *) values;
4034 xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
4035 xcb_parts[7].iov_base = 0;
4036 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4037
4038 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4039 return xcb_ret;
4040 }
4041
4042 char *
xcb_render_set_picture_filter_filter(const xcb_render_set_picture_filter_request_t * R)4043 xcb_render_set_picture_filter_filter (const xcb_render_set_picture_filter_request_t *R)
4044 {
4045 return (char *) (R + 1);
4046 }
4047
4048 int
xcb_render_set_picture_filter_filter_length(const xcb_render_set_picture_filter_request_t * R)4049 xcb_render_set_picture_filter_filter_length (const xcb_render_set_picture_filter_request_t *R)
4050 {
4051 return R->filter_len;
4052 }
4053
4054 xcb_generic_iterator_t
xcb_render_set_picture_filter_filter_end(const xcb_render_set_picture_filter_request_t * R)4055 xcb_render_set_picture_filter_filter_end (const xcb_render_set_picture_filter_request_t *R)
4056 {
4057 xcb_generic_iterator_t i;
4058 i.data = ((char *) (R + 1)) + (R->filter_len);
4059 i.rem = 0;
4060 i.index = (char *) i.data - (char *) R;
4061 return i;
4062 }
4063
4064 xcb_render_fixed_t *
xcb_render_set_picture_filter_values(const xcb_render_set_picture_filter_request_t * R)4065 xcb_render_set_picture_filter_values (const xcb_render_set_picture_filter_request_t *R)
4066 {
4067 xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R);
4068 return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
4069 }
4070
4071 int
xcb_render_set_picture_filter_values_length(const xcb_render_set_picture_filter_request_t * R)4072 xcb_render_set_picture_filter_values_length (const xcb_render_set_picture_filter_request_t *R)
4073 {
4074 return ((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t);
4075 }
4076
4077 xcb_generic_iterator_t
xcb_render_set_picture_filter_values_end(const xcb_render_set_picture_filter_request_t * R)4078 xcb_render_set_picture_filter_values_end (const xcb_render_set_picture_filter_request_t *R)
4079 {
4080 xcb_generic_iterator_t i;
4081 xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R);
4082 i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t));
4083 i.rem = 0;
4084 i.index = (char *) i.data - (char *) R;
4085 return i;
4086 }
4087
4088 void
xcb_render_animcursorelt_next(xcb_render_animcursorelt_iterator_t * i)4089 xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i)
4090 {
4091 --i->rem;
4092 ++i->data;
4093 i->index += sizeof(xcb_render_animcursorelt_t);
4094 }
4095
4096 xcb_generic_iterator_t
xcb_render_animcursorelt_end(xcb_render_animcursorelt_iterator_t i)4097 xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i)
4098 {
4099 xcb_generic_iterator_t ret;
4100 ret.data = i.data + i.rem;
4101 ret.index = i.index + ((char *) ret.data - (char *) i.data);
4102 ret.rem = 0;
4103 return ret;
4104 }
4105
4106 int
xcb_render_create_anim_cursor_sizeof(const void * _buffer,uint32_t cursors_len)4107 xcb_render_create_anim_cursor_sizeof (const void *_buffer,
4108 uint32_t cursors_len)
4109 {
4110 char *xcb_tmp = (char *)_buffer;
4111 unsigned int xcb_buffer_len = 0;
4112 unsigned int xcb_block_len = 0;
4113 unsigned int xcb_pad = 0;
4114 unsigned int xcb_align_to = 0;
4115
4116
4117 xcb_block_len += sizeof(xcb_render_create_anim_cursor_request_t);
4118 xcb_tmp += xcb_block_len;
4119 xcb_buffer_len += xcb_block_len;
4120 xcb_block_len = 0;
4121 /* cursors */
4122 xcb_block_len += cursors_len * sizeof(xcb_render_animcursorelt_t);
4123 xcb_tmp += xcb_block_len;
4124 xcb_align_to = ALIGNOF(xcb_render_animcursorelt_t);
4125 /* insert padding */
4126 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4127 xcb_buffer_len += xcb_block_len + xcb_pad;
4128 if (0 != xcb_pad) {
4129 xcb_tmp += xcb_pad;
4130 xcb_pad = 0;
4131 }
4132 xcb_block_len = 0;
4133
4134 return xcb_buffer_len;
4135 }
4136
4137 xcb_void_cookie_t
xcb_render_create_anim_cursor_checked(xcb_connection_t * c,xcb_cursor_t cid,uint32_t cursors_len,const xcb_render_animcursorelt_t * cursors)4138 xcb_render_create_anim_cursor_checked (xcb_connection_t *c,
4139 xcb_cursor_t cid,
4140 uint32_t cursors_len,
4141 const xcb_render_animcursorelt_t *cursors)
4142 {
4143 static const xcb_protocol_request_t xcb_req = {
4144 .count = 4,
4145 .ext = &xcb_render_id,
4146 .opcode = XCB_RENDER_CREATE_ANIM_CURSOR,
4147 .isvoid = 1
4148 };
4149
4150 struct iovec xcb_parts[6];
4151 xcb_void_cookie_t xcb_ret;
4152 xcb_render_create_anim_cursor_request_t xcb_out;
4153
4154 xcb_out.cid = cid;
4155
4156 xcb_parts[2].iov_base = (char *) &xcb_out;
4157 xcb_parts[2].iov_len = sizeof(xcb_out);
4158 xcb_parts[3].iov_base = 0;
4159 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4160 /* xcb_render_animcursorelt_t cursors */
4161 xcb_parts[4].iov_base = (char *) cursors;
4162 xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
4163 xcb_parts[5].iov_base = 0;
4164 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4165
4166 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4167 return xcb_ret;
4168 }
4169
4170 xcb_void_cookie_t
xcb_render_create_anim_cursor(xcb_connection_t * c,xcb_cursor_t cid,uint32_t cursors_len,const xcb_render_animcursorelt_t * cursors)4171 xcb_render_create_anim_cursor (xcb_connection_t *c,
4172 xcb_cursor_t cid,
4173 uint32_t cursors_len,
4174 const xcb_render_animcursorelt_t *cursors)
4175 {
4176 static const xcb_protocol_request_t xcb_req = {
4177 .count = 4,
4178 .ext = &xcb_render_id,
4179 .opcode = XCB_RENDER_CREATE_ANIM_CURSOR,
4180 .isvoid = 1
4181 };
4182
4183 struct iovec xcb_parts[6];
4184 xcb_void_cookie_t xcb_ret;
4185 xcb_render_create_anim_cursor_request_t xcb_out;
4186
4187 xcb_out.cid = cid;
4188
4189 xcb_parts[2].iov_base = (char *) &xcb_out;
4190 xcb_parts[2].iov_len = sizeof(xcb_out);
4191 xcb_parts[3].iov_base = 0;
4192 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4193 /* xcb_render_animcursorelt_t cursors */
4194 xcb_parts[4].iov_base = (char *) cursors;
4195 xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
4196 xcb_parts[5].iov_base = 0;
4197 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4198
4199 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4200 return xcb_ret;
4201 }
4202
4203 xcb_render_animcursorelt_t *
xcb_render_create_anim_cursor_cursors(const xcb_render_create_anim_cursor_request_t * R)4204 xcb_render_create_anim_cursor_cursors (const xcb_render_create_anim_cursor_request_t *R)
4205 {
4206 return (xcb_render_animcursorelt_t *) (R + 1);
4207 }
4208
4209 int
xcb_render_create_anim_cursor_cursors_length(const xcb_render_create_anim_cursor_request_t * R)4210 xcb_render_create_anim_cursor_cursors_length (const xcb_render_create_anim_cursor_request_t *R)
4211 {
4212 return (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t));
4213 }
4214
4215 xcb_render_animcursorelt_iterator_t
xcb_render_create_anim_cursor_cursors_iterator(const xcb_render_create_anim_cursor_request_t * R)4216 xcb_render_create_anim_cursor_cursors_iterator (const xcb_render_create_anim_cursor_request_t *R)
4217 {
4218 xcb_render_animcursorelt_iterator_t i;
4219 i.data = (xcb_render_animcursorelt_t *) (R + 1);
4220 i.rem = (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t));
4221 i.index = (char *) i.data - (char *) R;
4222 return i;
4223 }
4224
4225 void
xcb_render_spanfix_next(xcb_render_spanfix_iterator_t * i)4226 xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i)
4227 {
4228 --i->rem;
4229 ++i->data;
4230 i->index += sizeof(xcb_render_spanfix_t);
4231 }
4232
4233 xcb_generic_iterator_t
xcb_render_spanfix_end(xcb_render_spanfix_iterator_t i)4234 xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i)
4235 {
4236 xcb_generic_iterator_t ret;
4237 ret.data = i.data + i.rem;
4238 ret.index = i.index + ((char *) ret.data - (char *) i.data);
4239 ret.rem = 0;
4240 return ret;
4241 }
4242
4243 void
xcb_render_trap_next(xcb_render_trap_iterator_t * i)4244 xcb_render_trap_next (xcb_render_trap_iterator_t *i)
4245 {
4246 --i->rem;
4247 ++i->data;
4248 i->index += sizeof(xcb_render_trap_t);
4249 }
4250
4251 xcb_generic_iterator_t
xcb_render_trap_end(xcb_render_trap_iterator_t i)4252 xcb_render_trap_end (xcb_render_trap_iterator_t i)
4253 {
4254 xcb_generic_iterator_t ret;
4255 ret.data = i.data + i.rem;
4256 ret.index = i.index + ((char *) ret.data - (char *) i.data);
4257 ret.rem = 0;
4258 return ret;
4259 }
4260
4261 int
xcb_render_add_traps_sizeof(const void * _buffer,uint32_t traps_len)4262 xcb_render_add_traps_sizeof (const void *_buffer,
4263 uint32_t traps_len)
4264 {
4265 char *xcb_tmp = (char *)_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_render_add_traps_request_t);
4273 xcb_tmp += xcb_block_len;
4274 xcb_buffer_len += xcb_block_len;
4275 xcb_block_len = 0;
4276 /* traps */
4277 xcb_block_len += traps_len * sizeof(xcb_render_trap_t);
4278 xcb_tmp += xcb_block_len;
4279 xcb_align_to = ALIGNOF(xcb_render_trap_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_void_cookie_t
xcb_render_add_traps_checked(xcb_connection_t * c,xcb_render_picture_t picture,int16_t x_off,int16_t y_off,uint32_t traps_len,const xcb_render_trap_t * traps)4293 xcb_render_add_traps_checked (xcb_connection_t *c,
4294 xcb_render_picture_t picture,
4295 int16_t x_off,
4296 int16_t y_off,
4297 uint32_t traps_len,
4298 const xcb_render_trap_t *traps)
4299 {
4300 static const xcb_protocol_request_t xcb_req = {
4301 .count = 4,
4302 .ext = &xcb_render_id,
4303 .opcode = XCB_RENDER_ADD_TRAPS,
4304 .isvoid = 1
4305 };
4306
4307 struct iovec xcb_parts[6];
4308 xcb_void_cookie_t xcb_ret;
4309 xcb_render_add_traps_request_t xcb_out;
4310
4311 xcb_out.picture = picture;
4312 xcb_out.x_off = x_off;
4313 xcb_out.y_off = y_off;
4314
4315 xcb_parts[2].iov_base = (char *) &xcb_out;
4316 xcb_parts[2].iov_len = sizeof(xcb_out);
4317 xcb_parts[3].iov_base = 0;
4318 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4319 /* xcb_render_trap_t traps */
4320 xcb_parts[4].iov_base = (char *) traps;
4321 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
4322 xcb_parts[5].iov_base = 0;
4323 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4324
4325 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4326 return xcb_ret;
4327 }
4328
4329 xcb_void_cookie_t
xcb_render_add_traps(xcb_connection_t * c,xcb_render_picture_t picture,int16_t x_off,int16_t y_off,uint32_t traps_len,const xcb_render_trap_t * traps)4330 xcb_render_add_traps (xcb_connection_t *c,
4331 xcb_render_picture_t picture,
4332 int16_t x_off,
4333 int16_t y_off,
4334 uint32_t traps_len,
4335 const xcb_render_trap_t *traps)
4336 {
4337 static const xcb_protocol_request_t xcb_req = {
4338 .count = 4,
4339 .ext = &xcb_render_id,
4340 .opcode = XCB_RENDER_ADD_TRAPS,
4341 .isvoid = 1
4342 };
4343
4344 struct iovec xcb_parts[6];
4345 xcb_void_cookie_t xcb_ret;
4346 xcb_render_add_traps_request_t xcb_out;
4347
4348 xcb_out.picture = picture;
4349 xcb_out.x_off = x_off;
4350 xcb_out.y_off = y_off;
4351
4352 xcb_parts[2].iov_base = (char *) &xcb_out;
4353 xcb_parts[2].iov_len = sizeof(xcb_out);
4354 xcb_parts[3].iov_base = 0;
4355 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4356 /* xcb_render_trap_t traps */
4357 xcb_parts[4].iov_base = (char *) traps;
4358 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
4359 xcb_parts[5].iov_base = 0;
4360 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4361
4362 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4363 return xcb_ret;
4364 }
4365
4366 xcb_render_trap_t *
xcb_render_add_traps_traps(const xcb_render_add_traps_request_t * R)4367 xcb_render_add_traps_traps (const xcb_render_add_traps_request_t *R)
4368 {
4369 return (xcb_render_trap_t *) (R + 1);
4370 }
4371
4372 int
xcb_render_add_traps_traps_length(const xcb_render_add_traps_request_t * R)4373 xcb_render_add_traps_traps_length (const xcb_render_add_traps_request_t *R)
4374 {
4375 return (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t));
4376 }
4377
4378 xcb_render_trap_iterator_t
xcb_render_add_traps_traps_iterator(const xcb_render_add_traps_request_t * R)4379 xcb_render_add_traps_traps_iterator (const xcb_render_add_traps_request_t *R)
4380 {
4381 xcb_render_trap_iterator_t i;
4382 i.data = (xcb_render_trap_t *) (R + 1);
4383 i.rem = (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t));
4384 i.index = (char *) i.data - (char *) R;
4385 return i;
4386 }
4387
4388 xcb_void_cookie_t
xcb_render_create_solid_fill_checked(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_color_t color)4389 xcb_render_create_solid_fill_checked (xcb_connection_t *c,
4390 xcb_render_picture_t picture,
4391 xcb_render_color_t color)
4392 {
4393 static const xcb_protocol_request_t xcb_req = {
4394 .count = 2,
4395 .ext = &xcb_render_id,
4396 .opcode = XCB_RENDER_CREATE_SOLID_FILL,
4397 .isvoid = 1
4398 };
4399
4400 struct iovec xcb_parts[4];
4401 xcb_void_cookie_t xcb_ret;
4402 xcb_render_create_solid_fill_request_t xcb_out;
4403
4404 xcb_out.picture = picture;
4405 xcb_out.color = color;
4406
4407 xcb_parts[2].iov_base = (char *) &xcb_out;
4408 xcb_parts[2].iov_len = sizeof(xcb_out);
4409 xcb_parts[3].iov_base = 0;
4410 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4411
4412 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4413 return xcb_ret;
4414 }
4415
4416 xcb_void_cookie_t
xcb_render_create_solid_fill(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_color_t color)4417 xcb_render_create_solid_fill (xcb_connection_t *c,
4418 xcb_render_picture_t picture,
4419 xcb_render_color_t color)
4420 {
4421 static const xcb_protocol_request_t xcb_req = {
4422 .count = 2,
4423 .ext = &xcb_render_id,
4424 .opcode = XCB_RENDER_CREATE_SOLID_FILL,
4425 .isvoid = 1
4426 };
4427
4428 struct iovec xcb_parts[4];
4429 xcb_void_cookie_t xcb_ret;
4430 xcb_render_create_solid_fill_request_t xcb_out;
4431
4432 xcb_out.picture = picture;
4433 xcb_out.color = color;
4434
4435 xcb_parts[2].iov_base = (char *) &xcb_out;
4436 xcb_parts[2].iov_len = sizeof(xcb_out);
4437 xcb_parts[3].iov_base = 0;
4438 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4439
4440 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4441 return xcb_ret;
4442 }
4443
4444 int
xcb_render_create_linear_gradient_sizeof(const void * _buffer)4445 xcb_render_create_linear_gradient_sizeof (const void *_buffer)
4446 {
4447 char *xcb_tmp = (char *)_buffer;
4448 const xcb_render_create_linear_gradient_request_t *_aux = (xcb_render_create_linear_gradient_request_t *)_buffer;
4449 unsigned int xcb_buffer_len = 0;
4450 unsigned int xcb_block_len = 0;
4451 unsigned int xcb_pad = 0;
4452 unsigned int xcb_align_to = 0;
4453
4454
4455 xcb_block_len += sizeof(xcb_render_create_linear_gradient_request_t);
4456 xcb_tmp += xcb_block_len;
4457 xcb_buffer_len += xcb_block_len;
4458 xcb_block_len = 0;
4459 /* stops */
4460 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
4461 xcb_tmp += xcb_block_len;
4462 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
4463 /* insert padding */
4464 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4465 xcb_buffer_len += xcb_block_len + xcb_pad;
4466 if (0 != xcb_pad) {
4467 xcb_tmp += xcb_pad;
4468 xcb_pad = 0;
4469 }
4470 xcb_block_len = 0;
4471 /* colors */
4472 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
4473 xcb_tmp += xcb_block_len;
4474 xcb_align_to = ALIGNOF(xcb_render_color_t);
4475 /* insert padding */
4476 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4477 xcb_buffer_len += xcb_block_len + xcb_pad;
4478 if (0 != xcb_pad) {
4479 xcb_tmp += xcb_pad;
4480 xcb_pad = 0;
4481 }
4482 xcb_block_len = 0;
4483
4484 return xcb_buffer_len;
4485 }
4486
4487 xcb_void_cookie_t
xcb_render_create_linear_gradient_checked(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t p1,xcb_render_pointfix_t p2,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4488 xcb_render_create_linear_gradient_checked (xcb_connection_t *c,
4489 xcb_render_picture_t picture,
4490 xcb_render_pointfix_t p1,
4491 xcb_render_pointfix_t p2,
4492 uint32_t num_stops,
4493 const xcb_render_fixed_t *stops,
4494 const xcb_render_color_t *colors)
4495 {
4496 static const xcb_protocol_request_t xcb_req = {
4497 .count = 6,
4498 .ext = &xcb_render_id,
4499 .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT,
4500 .isvoid = 1
4501 };
4502
4503 struct iovec xcb_parts[8];
4504 xcb_void_cookie_t xcb_ret;
4505 xcb_render_create_linear_gradient_request_t xcb_out;
4506
4507 xcb_out.picture = picture;
4508 xcb_out.p1 = p1;
4509 xcb_out.p2 = p2;
4510 xcb_out.num_stops = num_stops;
4511
4512 xcb_parts[2].iov_base = (char *) &xcb_out;
4513 xcb_parts[2].iov_len = sizeof(xcb_out);
4514 xcb_parts[3].iov_base = 0;
4515 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4516 /* xcb_render_fixed_t stops */
4517 xcb_parts[4].iov_base = (char *) stops;
4518 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4519 xcb_parts[5].iov_base = 0;
4520 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4521 /* xcb_render_color_t colors */
4522 xcb_parts[6].iov_base = (char *) colors;
4523 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4524 xcb_parts[7].iov_base = 0;
4525 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4526
4527 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4528 return xcb_ret;
4529 }
4530
4531 xcb_void_cookie_t
xcb_render_create_linear_gradient(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t p1,xcb_render_pointfix_t p2,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4532 xcb_render_create_linear_gradient (xcb_connection_t *c,
4533 xcb_render_picture_t picture,
4534 xcb_render_pointfix_t p1,
4535 xcb_render_pointfix_t p2,
4536 uint32_t num_stops,
4537 const xcb_render_fixed_t *stops,
4538 const xcb_render_color_t *colors)
4539 {
4540 static const xcb_protocol_request_t xcb_req = {
4541 .count = 6,
4542 .ext = &xcb_render_id,
4543 .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT,
4544 .isvoid = 1
4545 };
4546
4547 struct iovec xcb_parts[8];
4548 xcb_void_cookie_t xcb_ret;
4549 xcb_render_create_linear_gradient_request_t xcb_out;
4550
4551 xcb_out.picture = picture;
4552 xcb_out.p1 = p1;
4553 xcb_out.p2 = p2;
4554 xcb_out.num_stops = num_stops;
4555
4556 xcb_parts[2].iov_base = (char *) &xcb_out;
4557 xcb_parts[2].iov_len = sizeof(xcb_out);
4558 xcb_parts[3].iov_base = 0;
4559 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4560 /* xcb_render_fixed_t stops */
4561 xcb_parts[4].iov_base = (char *) stops;
4562 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4563 xcb_parts[5].iov_base = 0;
4564 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4565 /* xcb_render_color_t colors */
4566 xcb_parts[6].iov_base = (char *) colors;
4567 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4568 xcb_parts[7].iov_base = 0;
4569 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4570
4571 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4572 return xcb_ret;
4573 }
4574
4575 xcb_render_fixed_t *
xcb_render_create_linear_gradient_stops(const xcb_render_create_linear_gradient_request_t * R)4576 xcb_render_create_linear_gradient_stops (const xcb_render_create_linear_gradient_request_t *R)
4577 {
4578 return (xcb_render_fixed_t *) (R + 1);
4579 }
4580
4581 int
xcb_render_create_linear_gradient_stops_length(const xcb_render_create_linear_gradient_request_t * R)4582 xcb_render_create_linear_gradient_stops_length (const xcb_render_create_linear_gradient_request_t *R)
4583 {
4584 return R->num_stops;
4585 }
4586
4587 xcb_generic_iterator_t
xcb_render_create_linear_gradient_stops_end(const xcb_render_create_linear_gradient_request_t * R)4588 xcb_render_create_linear_gradient_stops_end (const xcb_render_create_linear_gradient_request_t *R)
4589 {
4590 xcb_generic_iterator_t i;
4591 i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
4592 i.rem = 0;
4593 i.index = (char *) i.data - (char *) R;
4594 return i;
4595 }
4596
4597 xcb_render_color_t *
xcb_render_create_linear_gradient_colors(const xcb_render_create_linear_gradient_request_t * R)4598 xcb_render_create_linear_gradient_colors (const xcb_render_create_linear_gradient_request_t *R)
4599 {
4600 xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R);
4601 return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
4602 }
4603
4604 int
xcb_render_create_linear_gradient_colors_length(const xcb_render_create_linear_gradient_request_t * R)4605 xcb_render_create_linear_gradient_colors_length (const xcb_render_create_linear_gradient_request_t *R)
4606 {
4607 return R->num_stops;
4608 }
4609
4610 xcb_render_color_iterator_t
xcb_render_create_linear_gradient_colors_iterator(const xcb_render_create_linear_gradient_request_t * R)4611 xcb_render_create_linear_gradient_colors_iterator (const xcb_render_create_linear_gradient_request_t *R)
4612 {
4613 xcb_render_color_iterator_t i;
4614 xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R);
4615 i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
4616 i.rem = R->num_stops;
4617 i.index = (char *) i.data - (char *) R;
4618 return i;
4619 }
4620
4621 int
xcb_render_create_radial_gradient_sizeof(const void * _buffer)4622 xcb_render_create_radial_gradient_sizeof (const void *_buffer)
4623 {
4624 char *xcb_tmp = (char *)_buffer;
4625 const xcb_render_create_radial_gradient_request_t *_aux = (xcb_render_create_radial_gradient_request_t *)_buffer;
4626 unsigned int xcb_buffer_len = 0;
4627 unsigned int xcb_block_len = 0;
4628 unsigned int xcb_pad = 0;
4629 unsigned int xcb_align_to = 0;
4630
4631
4632 xcb_block_len += sizeof(xcb_render_create_radial_gradient_request_t);
4633 xcb_tmp += xcb_block_len;
4634 xcb_buffer_len += xcb_block_len;
4635 xcb_block_len = 0;
4636 /* stops */
4637 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
4638 xcb_tmp += xcb_block_len;
4639 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
4640 /* insert padding */
4641 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4642 xcb_buffer_len += xcb_block_len + xcb_pad;
4643 if (0 != xcb_pad) {
4644 xcb_tmp += xcb_pad;
4645 xcb_pad = 0;
4646 }
4647 xcb_block_len = 0;
4648 /* colors */
4649 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
4650 xcb_tmp += xcb_block_len;
4651 xcb_align_to = ALIGNOF(xcb_render_color_t);
4652 /* insert padding */
4653 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4654 xcb_buffer_len += xcb_block_len + xcb_pad;
4655 if (0 != xcb_pad) {
4656 xcb_tmp += xcb_pad;
4657 xcb_pad = 0;
4658 }
4659 xcb_block_len = 0;
4660
4661 return xcb_buffer_len;
4662 }
4663
4664 xcb_void_cookie_t
xcb_render_create_radial_gradient_checked(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t inner,xcb_render_pointfix_t outer,xcb_render_fixed_t inner_radius,xcb_render_fixed_t outer_radius,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4665 xcb_render_create_radial_gradient_checked (xcb_connection_t *c,
4666 xcb_render_picture_t picture,
4667 xcb_render_pointfix_t inner,
4668 xcb_render_pointfix_t outer,
4669 xcb_render_fixed_t inner_radius,
4670 xcb_render_fixed_t outer_radius,
4671 uint32_t num_stops,
4672 const xcb_render_fixed_t *stops,
4673 const xcb_render_color_t *colors)
4674 {
4675 static const xcb_protocol_request_t xcb_req = {
4676 .count = 6,
4677 .ext = &xcb_render_id,
4678 .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT,
4679 .isvoid = 1
4680 };
4681
4682 struct iovec xcb_parts[8];
4683 xcb_void_cookie_t xcb_ret;
4684 xcb_render_create_radial_gradient_request_t xcb_out;
4685
4686 xcb_out.picture = picture;
4687 xcb_out.inner = inner;
4688 xcb_out.outer = outer;
4689 xcb_out.inner_radius = inner_radius;
4690 xcb_out.outer_radius = outer_radius;
4691 xcb_out.num_stops = num_stops;
4692
4693 xcb_parts[2].iov_base = (char *) &xcb_out;
4694 xcb_parts[2].iov_len = sizeof(xcb_out);
4695 xcb_parts[3].iov_base = 0;
4696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4697 /* xcb_render_fixed_t stops */
4698 xcb_parts[4].iov_base = (char *) stops;
4699 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4700 xcb_parts[5].iov_base = 0;
4701 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4702 /* xcb_render_color_t colors */
4703 xcb_parts[6].iov_base = (char *) colors;
4704 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4705 xcb_parts[7].iov_base = 0;
4706 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4707
4708 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4709 return xcb_ret;
4710 }
4711
4712 xcb_void_cookie_t
xcb_render_create_radial_gradient(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t inner,xcb_render_pointfix_t outer,xcb_render_fixed_t inner_radius,xcb_render_fixed_t outer_radius,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4713 xcb_render_create_radial_gradient (xcb_connection_t *c,
4714 xcb_render_picture_t picture,
4715 xcb_render_pointfix_t inner,
4716 xcb_render_pointfix_t outer,
4717 xcb_render_fixed_t inner_radius,
4718 xcb_render_fixed_t outer_radius,
4719 uint32_t num_stops,
4720 const xcb_render_fixed_t *stops,
4721 const xcb_render_color_t *colors)
4722 {
4723 static const xcb_protocol_request_t xcb_req = {
4724 .count = 6,
4725 .ext = &xcb_render_id,
4726 .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT,
4727 .isvoid = 1
4728 };
4729
4730 struct iovec xcb_parts[8];
4731 xcb_void_cookie_t xcb_ret;
4732 xcb_render_create_radial_gradient_request_t xcb_out;
4733
4734 xcb_out.picture = picture;
4735 xcb_out.inner = inner;
4736 xcb_out.outer = outer;
4737 xcb_out.inner_radius = inner_radius;
4738 xcb_out.outer_radius = outer_radius;
4739 xcb_out.num_stops = num_stops;
4740
4741 xcb_parts[2].iov_base = (char *) &xcb_out;
4742 xcb_parts[2].iov_len = sizeof(xcb_out);
4743 xcb_parts[3].iov_base = 0;
4744 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4745 /* xcb_render_fixed_t stops */
4746 xcb_parts[4].iov_base = (char *) stops;
4747 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4748 xcb_parts[5].iov_base = 0;
4749 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4750 /* xcb_render_color_t colors */
4751 xcb_parts[6].iov_base = (char *) colors;
4752 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4753 xcb_parts[7].iov_base = 0;
4754 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4755
4756 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4757 return xcb_ret;
4758 }
4759
4760 xcb_render_fixed_t *
xcb_render_create_radial_gradient_stops(const xcb_render_create_radial_gradient_request_t * R)4761 xcb_render_create_radial_gradient_stops (const xcb_render_create_radial_gradient_request_t *R)
4762 {
4763 return (xcb_render_fixed_t *) (R + 1);
4764 }
4765
4766 int
xcb_render_create_radial_gradient_stops_length(const xcb_render_create_radial_gradient_request_t * R)4767 xcb_render_create_radial_gradient_stops_length (const xcb_render_create_radial_gradient_request_t *R)
4768 {
4769 return R->num_stops;
4770 }
4771
4772 xcb_generic_iterator_t
xcb_render_create_radial_gradient_stops_end(const xcb_render_create_radial_gradient_request_t * R)4773 xcb_render_create_radial_gradient_stops_end (const xcb_render_create_radial_gradient_request_t *R)
4774 {
4775 xcb_generic_iterator_t i;
4776 i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
4777 i.rem = 0;
4778 i.index = (char *) i.data - (char *) R;
4779 return i;
4780 }
4781
4782 xcb_render_color_t *
xcb_render_create_radial_gradient_colors(const xcb_render_create_radial_gradient_request_t * R)4783 xcb_render_create_radial_gradient_colors (const xcb_render_create_radial_gradient_request_t *R)
4784 {
4785 xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R);
4786 return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
4787 }
4788
4789 int
xcb_render_create_radial_gradient_colors_length(const xcb_render_create_radial_gradient_request_t * R)4790 xcb_render_create_radial_gradient_colors_length (const xcb_render_create_radial_gradient_request_t *R)
4791 {
4792 return R->num_stops;
4793 }
4794
4795 xcb_render_color_iterator_t
xcb_render_create_radial_gradient_colors_iterator(const xcb_render_create_radial_gradient_request_t * R)4796 xcb_render_create_radial_gradient_colors_iterator (const xcb_render_create_radial_gradient_request_t *R)
4797 {
4798 xcb_render_color_iterator_t i;
4799 xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R);
4800 i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
4801 i.rem = R->num_stops;
4802 i.index = (char *) i.data - (char *) R;
4803 return i;
4804 }
4805
4806 int
xcb_render_create_conical_gradient_sizeof(const void * _buffer)4807 xcb_render_create_conical_gradient_sizeof (const void *_buffer)
4808 {
4809 char *xcb_tmp = (char *)_buffer;
4810 const xcb_render_create_conical_gradient_request_t *_aux = (xcb_render_create_conical_gradient_request_t *)_buffer;
4811 unsigned int xcb_buffer_len = 0;
4812 unsigned int xcb_block_len = 0;
4813 unsigned int xcb_pad = 0;
4814 unsigned int xcb_align_to = 0;
4815
4816
4817 xcb_block_len += sizeof(xcb_render_create_conical_gradient_request_t);
4818 xcb_tmp += xcb_block_len;
4819 xcb_buffer_len += xcb_block_len;
4820 xcb_block_len = 0;
4821 /* stops */
4822 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
4823 xcb_tmp += xcb_block_len;
4824 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
4825 /* insert padding */
4826 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4827 xcb_buffer_len += xcb_block_len + xcb_pad;
4828 if (0 != xcb_pad) {
4829 xcb_tmp += xcb_pad;
4830 xcb_pad = 0;
4831 }
4832 xcb_block_len = 0;
4833 /* colors */
4834 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
4835 xcb_tmp += xcb_block_len;
4836 xcb_align_to = ALIGNOF(xcb_render_color_t);
4837 /* insert padding */
4838 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4839 xcb_buffer_len += xcb_block_len + xcb_pad;
4840 if (0 != xcb_pad) {
4841 xcb_tmp += xcb_pad;
4842 xcb_pad = 0;
4843 }
4844 xcb_block_len = 0;
4845
4846 return xcb_buffer_len;
4847 }
4848
4849 xcb_void_cookie_t
xcb_render_create_conical_gradient_checked(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t center,xcb_render_fixed_t angle,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4850 xcb_render_create_conical_gradient_checked (xcb_connection_t *c,
4851 xcb_render_picture_t picture,
4852 xcb_render_pointfix_t center,
4853 xcb_render_fixed_t angle,
4854 uint32_t num_stops,
4855 const xcb_render_fixed_t *stops,
4856 const xcb_render_color_t *colors)
4857 {
4858 static const xcb_protocol_request_t xcb_req = {
4859 .count = 6,
4860 .ext = &xcb_render_id,
4861 .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT,
4862 .isvoid = 1
4863 };
4864
4865 struct iovec xcb_parts[8];
4866 xcb_void_cookie_t xcb_ret;
4867 xcb_render_create_conical_gradient_request_t xcb_out;
4868
4869 xcb_out.picture = picture;
4870 xcb_out.center = center;
4871 xcb_out.angle = angle;
4872 xcb_out.num_stops = num_stops;
4873
4874 xcb_parts[2].iov_base = (char *) &xcb_out;
4875 xcb_parts[2].iov_len = sizeof(xcb_out);
4876 xcb_parts[3].iov_base = 0;
4877 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4878 /* xcb_render_fixed_t stops */
4879 xcb_parts[4].iov_base = (char *) stops;
4880 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4881 xcb_parts[5].iov_base = 0;
4882 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4883 /* xcb_render_color_t colors */
4884 xcb_parts[6].iov_base = (char *) colors;
4885 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4886 xcb_parts[7].iov_base = 0;
4887 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4888
4889 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4890 return xcb_ret;
4891 }
4892
4893 xcb_void_cookie_t
xcb_render_create_conical_gradient(xcb_connection_t * c,xcb_render_picture_t picture,xcb_render_pointfix_t center,xcb_render_fixed_t angle,uint32_t num_stops,const xcb_render_fixed_t * stops,const xcb_render_color_t * colors)4894 xcb_render_create_conical_gradient (xcb_connection_t *c,
4895 xcb_render_picture_t picture,
4896 xcb_render_pointfix_t center,
4897 xcb_render_fixed_t angle,
4898 uint32_t num_stops,
4899 const xcb_render_fixed_t *stops,
4900 const xcb_render_color_t *colors)
4901 {
4902 static const xcb_protocol_request_t xcb_req = {
4903 .count = 6,
4904 .ext = &xcb_render_id,
4905 .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT,
4906 .isvoid = 1
4907 };
4908
4909 struct iovec xcb_parts[8];
4910 xcb_void_cookie_t xcb_ret;
4911 xcb_render_create_conical_gradient_request_t xcb_out;
4912
4913 xcb_out.picture = picture;
4914 xcb_out.center = center;
4915 xcb_out.angle = angle;
4916 xcb_out.num_stops = num_stops;
4917
4918 xcb_parts[2].iov_base = (char *) &xcb_out;
4919 xcb_parts[2].iov_len = sizeof(xcb_out);
4920 xcb_parts[3].iov_base = 0;
4921 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4922 /* xcb_render_fixed_t stops */
4923 xcb_parts[4].iov_base = (char *) stops;
4924 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
4925 xcb_parts[5].iov_base = 0;
4926 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4927 /* xcb_render_color_t colors */
4928 xcb_parts[6].iov_base = (char *) colors;
4929 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
4930 xcb_parts[7].iov_base = 0;
4931 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
4932
4933 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4934 return xcb_ret;
4935 }
4936
4937 xcb_render_fixed_t *
xcb_render_create_conical_gradient_stops(const xcb_render_create_conical_gradient_request_t * R)4938 xcb_render_create_conical_gradient_stops (const xcb_render_create_conical_gradient_request_t *R)
4939 {
4940 return (xcb_render_fixed_t *) (R + 1);
4941 }
4942
4943 int
xcb_render_create_conical_gradient_stops_length(const xcb_render_create_conical_gradient_request_t * R)4944 xcb_render_create_conical_gradient_stops_length (const xcb_render_create_conical_gradient_request_t *R)
4945 {
4946 return R->num_stops;
4947 }
4948
4949 xcb_generic_iterator_t
xcb_render_create_conical_gradient_stops_end(const xcb_render_create_conical_gradient_request_t * R)4950 xcb_render_create_conical_gradient_stops_end (const xcb_render_create_conical_gradient_request_t *R)
4951 {
4952 xcb_generic_iterator_t i;
4953 i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
4954 i.rem = 0;
4955 i.index = (char *) i.data - (char *) R;
4956 return i;
4957 }
4958
4959 xcb_render_color_t *
xcb_render_create_conical_gradient_colors(const xcb_render_create_conical_gradient_request_t * R)4960 xcb_render_create_conical_gradient_colors (const xcb_render_create_conical_gradient_request_t *R)
4961 {
4962 xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R);
4963 return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
4964 }
4965
4966 int
xcb_render_create_conical_gradient_colors_length(const xcb_render_create_conical_gradient_request_t * R)4967 xcb_render_create_conical_gradient_colors_length (const xcb_render_create_conical_gradient_request_t *R)
4968 {
4969 return R->num_stops;
4970 }
4971
4972 xcb_render_color_iterator_t
xcb_render_create_conical_gradient_colors_iterator(const xcb_render_create_conical_gradient_request_t * R)4973 xcb_render_create_conical_gradient_colors_iterator (const xcb_render_create_conical_gradient_request_t *R)
4974 {
4975 xcb_render_color_iterator_t i;
4976 xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R);
4977 i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
4978 i.rem = R->num_stops;
4979 i.index = (char *) i.data - (char *) R;
4980 return i;
4981 }
4982
4983