xref: /netbsd-src/external/mit/xorg/lib/libxcb/files/render.c (revision ba6321fe7f085fc81d62ca44a3abf72ff7ab2641)
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