?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
etc/protocols - sync with NetBSD-8
[minix.git] / external / mit / xorg / lib / libxcb / files / render.c
blob5ac468ce281d8e8916bc7de7906428422d781790
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
197 xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R /**< */)
198 {
199 return (xcb_render_pictvisual_t *) (R + 1);
200 }
201
202 int
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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 *
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
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
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
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
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 *
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
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
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 child = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R));
671 i.data = ((uint32_t *) child.data) + (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 *
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
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
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
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 *
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
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
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 *
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
799 xcb_render_create_picture_sizeof (const void *_buffer /**< */)
800 {
801 char *xcb_tmp = (char *)_buffer;
802 const xcb_render_create_picture_request_t *_aux = (xcb_render_create_picture_request_t *)_buffer;
803 unsigned int xcb_buffer_len = 0;
804 unsigned int xcb_block_len = 0;
805 unsigned int xcb_pad = 0;
806 unsigned int xcb_align_to = 0;
807
808
809 xcb_block_len += sizeof(xcb_render_create_picture_request_t);
810 xcb_tmp += xcb_block_len;
811 xcb_buffer_len += xcb_block_len;
812 xcb_block_len = 0;
813 /* value_list */
814 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t);
815 xcb_tmp += xcb_block_len;
816 xcb_align_to = ALIGNOF(uint32_t);
817 /* insert padding */
818 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
819 xcb_buffer_len += xcb_block_len + xcb_pad;
820 if (0 != xcb_pad) {
821 xcb_tmp += xcb_pad;
822 xcb_pad = 0;
823 }
824 xcb_block_len = 0;
825
826 return xcb_buffer_len;
827 }
828
829 xcb_void_cookie_t
830 xcb_render_create_picture_checked (xcb_connection_t *c /**< */,
831 xcb_render_picture_t pid /**< */,
832 xcb_drawable_t drawable /**< */,
833 xcb_render_pictformat_t format /**< */,
834 uint32_t value_mask /**< */,
835 const uint32_t *value_list /**< */)
836 {
837 static const xcb_protocol_request_t xcb_req = {
838 /* count */ 4,
839 /* ext */ &xcb_render_id,
840 /* opcode */ XCB_RENDER_CREATE_PICTURE,
841 /* isvoid */ 1
842 };
843
844 struct iovec xcb_parts[6];
845 xcb_void_cookie_t xcb_ret;
846 xcb_render_create_picture_request_t xcb_out;
847
848 xcb_out.pid = pid;
849 xcb_out.drawable = drawable;
850 xcb_out.format = format;
851 xcb_out.value_mask = value_mask;
852
853 xcb_parts[2].iov_base = (char *) &xcb_out;
854 xcb_parts[2].iov_len = sizeof(xcb_out);
855 xcb_parts[3].iov_base = 0;
856 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
857 /* uint32_t value_list */
858 xcb_parts[4].iov_base = (char *) value_list;
859 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t);
860 xcb_parts[5].iov_base = 0;
861 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
862
863 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
864 return xcb_ret;
865 }
866
867 xcb_void_cookie_t
868 xcb_render_create_picture (xcb_connection_t *c /**< */,
869 xcb_render_picture_t pid /**< */,
870 xcb_drawable_t drawable /**< */,
871 xcb_render_pictformat_t format /**< */,
872 uint32_t value_mask /**< */,
873 const uint32_t *value_list /**< */)
874 {
875 static const xcb_protocol_request_t xcb_req = {
876 /* count */ 4,
877 /* ext */ &xcb_render_id,
878 /* opcode */ XCB_RENDER_CREATE_PICTURE,
879 /* isvoid */ 1
880 };
881
882 struct iovec xcb_parts[6];
883 xcb_void_cookie_t xcb_ret;
884 xcb_render_create_picture_request_t xcb_out;
885
886 xcb_out.pid = pid;
887 xcb_out.drawable = drawable;
888 xcb_out.format = format;
889 xcb_out.value_mask = value_mask;
890
891 xcb_parts[2].iov_base = (char *) &xcb_out;
892 xcb_parts[2].iov_len = sizeof(xcb_out);
893 xcb_parts[3].iov_base = 0;
894 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
895 /* uint32_t value_list */
896 xcb_parts[4].iov_base = (char *) value_list;
897 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t);
898 xcb_parts[5].iov_base = 0;
899 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
900
901 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
902 return xcb_ret;
903 }
904
905 int
906 xcb_render_change_picture_sizeof (const void *_buffer /**< */)
907 {
908 char *xcb_tmp = (char *)_buffer;
909 const xcb_render_change_picture_request_t *_aux = (xcb_render_change_picture_request_t *)_buffer;
910 unsigned int xcb_buffer_len = 0;
911 unsigned int xcb_block_len = 0;
912 unsigned int xcb_pad = 0;
913 unsigned int xcb_align_to = 0;
914
915
916 xcb_block_len += sizeof(xcb_render_change_picture_request_t);
917 xcb_tmp += xcb_block_len;
918 xcb_buffer_len += xcb_block_len;
919 xcb_block_len = 0;
920 /* value_list */
921 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t);
922 xcb_tmp += xcb_block_len;
923 xcb_align_to = ALIGNOF(uint32_t);
924 /* insert padding */
925 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
926 xcb_buffer_len += xcb_block_len + xcb_pad;
927 if (0 != xcb_pad) {
928 xcb_tmp += xcb_pad;
929 xcb_pad = 0;
930 }
931 xcb_block_len = 0;
932
933 return xcb_buffer_len;
934 }
935
936 xcb_void_cookie_t
937 xcb_render_change_picture_checked (xcb_connection_t *c /**< */,
938 xcb_render_picture_t picture /**< */,
939 uint32_t value_mask /**< */,
940 const uint32_t *value_list /**< */)
941 {
942 static const xcb_protocol_request_t xcb_req = {
943 /* count */ 4,
944 /* ext */ &xcb_render_id,
945 /* opcode */ XCB_RENDER_CHANGE_PICTURE,
946 /* isvoid */ 1
947 };
948
949 struct iovec xcb_parts[6];
950 xcb_void_cookie_t xcb_ret;
951 xcb_render_change_picture_request_t xcb_out;
952
953 xcb_out.picture = picture;
954 xcb_out.value_mask = value_mask;
955
956 xcb_parts[2].iov_base = (char *) &xcb_out;
957 xcb_parts[2].iov_len = sizeof(xcb_out);
958 xcb_parts[3].iov_base = 0;
959 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
960 /* uint32_t value_list */
961 xcb_parts[4].iov_base = (char *) value_list;
962 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t);
963 xcb_parts[5].iov_base = 0;
964 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
965
966 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
967 return xcb_ret;
968 }
969
970 xcb_void_cookie_t
971 xcb_render_change_picture (xcb_connection_t *c /**< */,
972 xcb_render_picture_t picture /**< */,
973 uint32_t value_mask /**< */,
974 const uint32_t *value_list /**< */)
975 {
976 static const xcb_protocol_request_t xcb_req = {
977 /* count */ 4,
978 /* ext */ &xcb_render_id,
979 /* opcode */ XCB_RENDER_CHANGE_PICTURE,
980 /* isvoid */ 1
981 };
982
983 struct iovec xcb_parts[6];
984 xcb_void_cookie_t xcb_ret;
985 xcb_render_change_picture_request_t xcb_out;
986
987 xcb_out.picture = picture;
988 xcb_out.value_mask = value_mask;
989
990 xcb_parts[2].iov_base = (char *) &xcb_out;
991 xcb_parts[2].iov_len = sizeof(xcb_out);
992 xcb_parts[3].iov_base = 0;
993 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
994 /* uint32_t value_list */
995 xcb_parts[4].iov_base = (char *) value_list;
996 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t);
997 xcb_parts[5].iov_base = 0;
998 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
999
1000 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1001 return xcb_ret;
1002 }
1003
1004 int
1005 xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */,
1006 uint32_t rectangles_len /**< */)
1007 {
1008 char *xcb_tmp = (char *)_buffer;
1009 unsigned int xcb_buffer_len = 0;
1010 unsigned int xcb_block_len = 0;
1011 unsigned int xcb_pad = 0;
1012 unsigned int xcb_align_to = 0;
1013
1014
1015 xcb_block_len += sizeof(xcb_render_set_picture_clip_rectangles_request_t);
1016 xcb_tmp += xcb_block_len;
1017 xcb_buffer_len += xcb_block_len;
1018 xcb_block_len = 0;
1019 /* rectangles */
1020 xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
1021 xcb_tmp += xcb_block_len;
1022 xcb_align_to = ALIGNOF(xcb_rectangle_t);
1023 /* insert padding */
1024 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1025 xcb_buffer_len += xcb_block_len + xcb_pad;
1026 if (0 != xcb_pad) {
1027 xcb_tmp += xcb_pad;
1028 xcb_pad = 0;
1029 }
1030 xcb_block_len = 0;
1031
1032 return xcb_buffer_len;
1033 }
1034
1035 xcb_void_cookie_t
1036 xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< */,
1037 xcb_render_picture_t picture /**< */,
1038 int16_t clip_x_origin /**< */,
1039 int16_t clip_y_origin /**< */,
1040 uint32_t rectangles_len /**< */,
1041 const xcb_rectangle_t *rectangles /**< */)
1042 {
1043 static const xcb_protocol_request_t xcb_req = {
1044 /* count */ 4,
1045 /* ext */ &xcb_render_id,
1046 /* opcode */ XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
1047 /* isvoid */ 1
1048 };
1049
1050 struct iovec xcb_parts[6];
1051 xcb_void_cookie_t xcb_ret;
1052 xcb_render_set_picture_clip_rectangles_request_t xcb_out;
1053
1054 xcb_out.picture = picture;
1055 xcb_out.clip_x_origin = clip_x_origin;
1056 xcb_out.clip_y_origin = clip_y_origin;
1057
1058 xcb_parts[2].iov_base = (char *) &xcb_out;
1059 xcb_parts[2].iov_len = sizeof(xcb_out);
1060 xcb_parts[3].iov_base = 0;
1061 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1062 /* xcb_rectangle_t rectangles */
1063 xcb_parts[4].iov_base = (char *) rectangles;
1064 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
1065 xcb_parts[5].iov_base = 0;
1066 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1067
1068 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1069 return xcb_ret;
1070 }
1071
1072 xcb_void_cookie_t
1073 xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */,
1074 xcb_render_picture_t picture /**< */,
1075 int16_t clip_x_origin /**< */,
1076 int16_t clip_y_origin /**< */,
1077 uint32_t rectangles_len /**< */,
1078 const xcb_rectangle_t *rectangles /**< */)
1079 {
1080 static const xcb_protocol_request_t xcb_req = {
1081 /* count */ 4,
1082 /* ext */ &xcb_render_id,
1083 /* opcode */ XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
1084 /* isvoid */ 1
1085 };
1086
1087 struct iovec xcb_parts[6];
1088 xcb_void_cookie_t xcb_ret;
1089 xcb_render_set_picture_clip_rectangles_request_t xcb_out;
1090
1091 xcb_out.picture = picture;
1092 xcb_out.clip_x_origin = clip_x_origin;
1093 xcb_out.clip_y_origin = clip_y_origin;
1094
1095 xcb_parts[2].iov_base = (char *) &xcb_out;
1096 xcb_parts[2].iov_len = sizeof(xcb_out);
1097 xcb_parts[3].iov_base = 0;
1098 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1099 /* xcb_rectangle_t rectangles */
1100 xcb_parts[4].iov_base = (char *) rectangles;
1101 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
1102 xcb_parts[5].iov_base = 0;
1103 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1104
1105 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1106 return xcb_ret;
1107 }
1108
1109 xcb_void_cookie_t
1110 xcb_render_free_picture_checked (xcb_connection_t *c /**< */,
1111 xcb_render_picture_t picture /**< */)
1112 {
1113 static const xcb_protocol_request_t xcb_req = {
1114 /* count */ 2,
1115 /* ext */ &xcb_render_id,
1116 /* opcode */ XCB_RENDER_FREE_PICTURE,
1117 /* isvoid */ 1
1118 };
1119
1120 struct iovec xcb_parts[4];
1121 xcb_void_cookie_t xcb_ret;
1122 xcb_render_free_picture_request_t xcb_out;
1123
1124 xcb_out.picture = picture;
1125
1126 xcb_parts[2].iov_base = (char *) &xcb_out;
1127 xcb_parts[2].iov_len = sizeof(xcb_out);
1128 xcb_parts[3].iov_base = 0;
1129 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1130
1131 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1132 return xcb_ret;
1133 }
1134
1135 xcb_void_cookie_t
1136 xcb_render_free_picture (xcb_connection_t *c /**< */,
1137 xcb_render_picture_t picture /**< */)
1138 {
1139 static const xcb_protocol_request_t xcb_req = {
1140 /* count */ 2,
1141 /* ext */ &xcb_render_id,
1142 /* opcode */ XCB_RENDER_FREE_PICTURE,
1143 /* isvoid */ 1
1144 };
1145
1146 struct iovec xcb_parts[4];
1147 xcb_void_cookie_t xcb_ret;
1148 xcb_render_free_picture_request_t xcb_out;
1149
1150 xcb_out.picture = picture;
1151
1152 xcb_parts[2].iov_base = (char *) &xcb_out;
1153 xcb_parts[2].iov_len = sizeof(xcb_out);
1154 xcb_parts[3].iov_base = 0;
1155 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1156
1157 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1158 return xcb_ret;
1159 }
1160
1161 xcb_void_cookie_t
1162 xcb_render_composite_checked (xcb_connection_t *c /**< */,
1163 uint8_t op /**< */,
1164 xcb_render_picture_t src /**< */,
1165 xcb_render_picture_t mask /**< */,
1166 xcb_render_picture_t dst /**< */,
1167 int16_t src_x /**< */,
1168 int16_t src_y /**< */,
1169 int16_t mask_x /**< */,
1170 int16_t mask_y /**< */,
1171 int16_t dst_x /**< */,
1172 int16_t dst_y /**< */,
1173 uint16_t width /**< */,
1174 uint16_t height /**< */)
1175 {
1176 static const xcb_protocol_request_t xcb_req = {
1177 /* count */ 2,
1178 /* ext */ &xcb_render_id,
1179 /* opcode */ XCB_RENDER_COMPOSITE,
1180 /* isvoid */ 1
1181 };
1182
1183 struct iovec xcb_parts[4];
1184 xcb_void_cookie_t xcb_ret;
1185 xcb_render_composite_request_t xcb_out;
1186
1187 xcb_out.op = op;
1188 memset(xcb_out.pad0, 0, 3);
1189 xcb_out.src = src;
1190 xcb_out.mask = mask;
1191 xcb_out.dst = dst;
1192 xcb_out.src_x = src_x;
1193 xcb_out.src_y = src_y;
1194 xcb_out.mask_x = mask_x;
1195 xcb_out.mask_y = mask_y;
1196 xcb_out.dst_x = dst_x;
1197 xcb_out.dst_y = dst_y;
1198 xcb_out.width = width;
1199 xcb_out.height = height;
1200
1201 xcb_parts[2].iov_base = (char *) &xcb_out;
1202 xcb_parts[2].iov_len = sizeof(xcb_out);
1203 xcb_parts[3].iov_base = 0;
1204 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1205
1206 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1207 return xcb_ret;
1208 }
1209
1210 xcb_void_cookie_t
1211 xcb_render_composite (xcb_connection_t *c /**< */,
1212 uint8_t op /**< */,
1213 xcb_render_picture_t src /**< */,
1214 xcb_render_picture_t mask /**< */,
1215 xcb_render_picture_t dst /**< */,
1216 int16_t src_x /**< */,
1217 int16_t src_y /**< */,
1218 int16_t mask_x /**< */,
1219 int16_t mask_y /**< */,
1220 int16_t dst_x /**< */,
1221 int16_t dst_y /**< */,
1222 uint16_t width /**< */,
1223 uint16_t height /**< */)
1224 {
1225 static const xcb_protocol_request_t xcb_req = {
1226 /* count */ 2,
1227 /* ext */ &xcb_render_id,
1228 /* opcode */ XCB_RENDER_COMPOSITE,
1229 /* isvoid */ 1
1230 };
1231
1232 struct iovec xcb_parts[4];
1233 xcb_void_cookie_t xcb_ret;
1234 xcb_render_composite_request_t xcb_out;
1235
1236 xcb_out.op = op;
1237 memset(xcb_out.pad0, 0, 3);
1238 xcb_out.src = src;
1239 xcb_out.mask = mask;
1240 xcb_out.dst = dst;
1241 xcb_out.src_x = src_x;
1242 xcb_out.src_y = src_y;
1243 xcb_out.mask_x = mask_x;
1244 xcb_out.mask_y = mask_y;
1245 xcb_out.dst_x = dst_x;
1246 xcb_out.dst_y = dst_y;
1247 xcb_out.width = width;
1248 xcb_out.height = height;
1249
1250 xcb_parts[2].iov_base = (char *) &xcb_out;
1251 xcb_parts[2].iov_len = sizeof(xcb_out);
1252 xcb_parts[3].iov_base = 0;
1253 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1254
1255 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1256 return xcb_ret;
1257 }
1258
1259 int
1260 xcb_render_trapezoids_sizeof (const void *_buffer /**< */,
1261 uint32_t traps_len /**< */)
1262 {
1263 char *xcb_tmp = (char *)_buffer;
1264 unsigned int xcb_buffer_len = 0;
1265 unsigned int xcb_block_len = 0;
1266 unsigned int xcb_pad = 0;
1267 unsigned int xcb_align_to = 0;
1268
1269
1270 xcb_block_len += sizeof(xcb_render_trapezoids_request_t);
1271 xcb_tmp += xcb_block_len;
1272 xcb_buffer_len += xcb_block_len;
1273 xcb_block_len = 0;
1274 /* traps */
1275 xcb_block_len += traps_len * sizeof(xcb_render_trapezoid_t);
1276 xcb_tmp += xcb_block_len;
1277 xcb_align_to = ALIGNOF(xcb_render_trapezoid_t);
1278 /* insert padding */
1279 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1280 xcb_buffer_len += xcb_block_len + xcb_pad;
1281 if (0 != xcb_pad) {
1282 xcb_tmp += xcb_pad;
1283 xcb_pad = 0;
1284 }
1285 xcb_block_len = 0;
1286
1287 return xcb_buffer_len;
1288 }
1289
1290 xcb_void_cookie_t
1291 xcb_render_trapezoids_checked (xcb_connection_t *c /**< */,
1292 uint8_t op /**< */,
1293 xcb_render_picture_t src /**< */,
1294 xcb_render_picture_t dst /**< */,
1295 xcb_render_pictformat_t mask_format /**< */,
1296 int16_t src_x /**< */,
1297 int16_t src_y /**< */,
1298 uint32_t traps_len /**< */,
1299 const xcb_render_trapezoid_t *traps /**< */)
1300 {
1301 static const xcb_protocol_request_t xcb_req = {
1302 /* count */ 4,
1303 /* ext */ &xcb_render_id,
1304 /* opcode */ XCB_RENDER_TRAPEZOIDS,
1305 /* isvoid */ 1
1306 };
1307
1308 struct iovec xcb_parts[6];
1309 xcb_void_cookie_t xcb_ret;
1310 xcb_render_trapezoids_request_t xcb_out;
1311
1312 xcb_out.op = op;
1313 memset(xcb_out.pad0, 0, 3);
1314 xcb_out.src = src;
1315 xcb_out.dst = dst;
1316 xcb_out.mask_format = mask_format;
1317 xcb_out.src_x = src_x;
1318 xcb_out.src_y = src_y;
1319
1320 xcb_parts[2].iov_base = (char *) &xcb_out;
1321 xcb_parts[2].iov_len = sizeof(xcb_out);
1322 xcb_parts[3].iov_base = 0;
1323 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1324 /* xcb_render_trapezoid_t traps */
1325 xcb_parts[4].iov_base = (char *) traps;
1326 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t);
1327 xcb_parts[5].iov_base = 0;
1328 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1329
1330 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1331 return xcb_ret;
1332 }
1333
1334 xcb_void_cookie_t
1335 xcb_render_trapezoids (xcb_connection_t *c /**< */,
1336 uint8_t op /**< */,
1337 xcb_render_picture_t src /**< */,
1338 xcb_render_picture_t dst /**< */,
1339 xcb_render_pictformat_t mask_format /**< */,
1340 int16_t src_x /**< */,
1341 int16_t src_y /**< */,
1342 uint32_t traps_len /**< */,
1343 const xcb_render_trapezoid_t *traps /**< */)
1344 {
1345 static const xcb_protocol_request_t xcb_req = {
1346 /* count */ 4,
1347 /* ext */ &xcb_render_id,
1348 /* opcode */ XCB_RENDER_TRAPEZOIDS,
1349 /* isvoid */ 1
1350 };
1351
1352 struct iovec xcb_parts[6];
1353 xcb_void_cookie_t xcb_ret;
1354 xcb_render_trapezoids_request_t xcb_out;
1355
1356 xcb_out.op = op;
1357 memset(xcb_out.pad0, 0, 3);
1358 xcb_out.src = src;
1359 xcb_out.dst = dst;
1360 xcb_out.mask_format = mask_format;
1361 xcb_out.src_x = src_x;
1362 xcb_out.src_y = src_y;
1363
1364 xcb_parts[2].iov_base = (char *) &xcb_out;
1365 xcb_parts[2].iov_len = sizeof(xcb_out);
1366 xcb_parts[3].iov_base = 0;
1367 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1368 /* xcb_render_trapezoid_t traps */
1369 xcb_parts[4].iov_base = (char *) traps;
1370 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t);
1371 xcb_parts[5].iov_base = 0;
1372 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1373
1374 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1375 return xcb_ret;
1376 }
1377
1378 int
1379 xcb_render_triangles_sizeof (const void *_buffer /**< */,
1380 uint32_t triangles_len /**< */)
1381 {
1382 char *xcb_tmp = (char *)_buffer;
1383 unsigned int xcb_buffer_len = 0;
1384 unsigned int xcb_block_len = 0;
1385 unsigned int xcb_pad = 0;
1386 unsigned int xcb_align_to = 0;
1387
1388
1389 xcb_block_len += sizeof(xcb_render_triangles_request_t);
1390 xcb_tmp += xcb_block_len;
1391 xcb_buffer_len += xcb_block_len;
1392 xcb_block_len = 0;
1393 /* triangles */
1394 xcb_block_len += triangles_len * sizeof(xcb_render_triangle_t);
1395 xcb_tmp += xcb_block_len;
1396 xcb_align_to = ALIGNOF(xcb_render_triangle_t);
1397 /* insert padding */
1398 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1399 xcb_buffer_len += xcb_block_len + xcb_pad;
1400 if (0 != xcb_pad) {
1401 xcb_tmp += xcb_pad;
1402 xcb_pad = 0;
1403 }
1404 xcb_block_len = 0;
1405
1406 return xcb_buffer_len;
1407 }
1408
1409 xcb_void_cookie_t
1410 xcb_render_triangles_checked (xcb_connection_t *c /**< */,
1411 uint8_t op /**< */,
1412 xcb_render_picture_t src /**< */,
1413 xcb_render_picture_t dst /**< */,
1414 xcb_render_pictformat_t mask_format /**< */,
1415 int16_t src_x /**< */,
1416 int16_t src_y /**< */,
1417 uint32_t triangles_len /**< */,
1418 const xcb_render_triangle_t *triangles /**< */)
1419 {
1420 static const xcb_protocol_request_t xcb_req = {
1421 /* count */ 4,
1422 /* ext */ &xcb_render_id,
1423 /* opcode */ XCB_RENDER_TRIANGLES,
1424 /* isvoid */ 1
1425 };
1426
1427 struct iovec xcb_parts[6];
1428 xcb_void_cookie_t xcb_ret;
1429 xcb_render_triangles_request_t xcb_out;
1430
1431 xcb_out.op = op;
1432 memset(xcb_out.pad0, 0, 3);
1433 xcb_out.src = src;
1434 xcb_out.dst = dst;
1435 xcb_out.mask_format = mask_format;
1436 xcb_out.src_x = src_x;
1437 xcb_out.src_y = src_y;
1438
1439 xcb_parts[2].iov_base = (char *) &xcb_out;
1440 xcb_parts[2].iov_len = sizeof(xcb_out);
1441 xcb_parts[3].iov_base = 0;
1442 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1443 /* xcb_render_triangle_t triangles */
1444 xcb_parts[4].iov_base = (char *) triangles;
1445 xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
1446 xcb_parts[5].iov_base = 0;
1447 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1448
1449 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1450 return xcb_ret;
1451 }
1452
1453 xcb_void_cookie_t
1454 xcb_render_triangles (xcb_connection_t *c /**< */,
1455 uint8_t op /**< */,
1456 xcb_render_picture_t src /**< */,
1457 xcb_render_picture_t dst /**< */,
1458 xcb_render_pictformat_t mask_format /**< */,
1459 int16_t src_x /**< */,
1460 int16_t src_y /**< */,
1461 uint32_t triangles_len /**< */,
1462 const xcb_render_triangle_t *triangles /**< */)
1463 {
1464 static const xcb_protocol_request_t xcb_req = {
1465 /* count */ 4,
1466 /* ext */ &xcb_render_id,
1467 /* opcode */ XCB_RENDER_TRIANGLES,
1468 /* isvoid */ 1
1469 };
1470
1471 struct iovec xcb_parts[6];
1472 xcb_void_cookie_t xcb_ret;
1473 xcb_render_triangles_request_t xcb_out;
1474
1475 xcb_out.op = op;
1476 memset(xcb_out.pad0, 0, 3);
1477 xcb_out.src = src;
1478 xcb_out.dst = dst;
1479 xcb_out.mask_format = mask_format;
1480 xcb_out.src_x = src_x;
1481 xcb_out.src_y = src_y;
1482
1483 xcb_parts[2].iov_base = (char *) &xcb_out;
1484 xcb_parts[2].iov_len = sizeof(xcb_out);
1485 xcb_parts[3].iov_base = 0;
1486 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1487 /* xcb_render_triangle_t triangles */
1488 xcb_parts[4].iov_base = (char *) triangles;
1489 xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
1490 xcb_parts[5].iov_base = 0;
1491 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1492
1493 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1494 return xcb_ret;
1495 }
1496
1497 int
1498 xcb_render_tri_strip_sizeof (const void *_buffer /**< */,
1499 uint32_t points_len /**< */)
1500 {
1501 char *xcb_tmp = (char *)_buffer;
1502 unsigned int xcb_buffer_len = 0;
1503 unsigned int xcb_block_len = 0;
1504 unsigned int xcb_pad = 0;
1505 unsigned int xcb_align_to = 0;
1506
1507
1508 xcb_block_len += sizeof(xcb_render_tri_strip_request_t);
1509 xcb_tmp += xcb_block_len;
1510 xcb_buffer_len += xcb_block_len;
1511 xcb_block_len = 0;
1512 /* points */
1513 xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
1514 xcb_tmp += xcb_block_len;
1515 xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
1516 /* insert padding */
1517 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1518 xcb_buffer_len += xcb_block_len + xcb_pad;
1519 if (0 != xcb_pad) {
1520 xcb_tmp += xcb_pad;
1521 xcb_pad = 0;
1522 }
1523 xcb_block_len = 0;
1524
1525 return xcb_buffer_len;
1526 }
1527
1528 xcb_void_cookie_t
1529 xcb_render_tri_strip_checked (xcb_connection_t *c /**< */,
1530 uint8_t op /**< */,
1531 xcb_render_picture_t src /**< */,
1532 xcb_render_picture_t dst /**< */,
1533 xcb_render_pictformat_t mask_format /**< */,
1534 int16_t src_x /**< */,
1535 int16_t src_y /**< */,
1536 uint32_t points_len /**< */,
1537 const xcb_render_pointfix_t *points /**< */)
1538 {
1539 static const xcb_protocol_request_t xcb_req = {
1540 /* count */ 4,
1541 /* ext */ &xcb_render_id,
1542 /* opcode */ XCB_RENDER_TRI_STRIP,
1543 /* isvoid */ 1
1544 };
1545
1546 struct iovec xcb_parts[6];
1547 xcb_void_cookie_t xcb_ret;
1548 xcb_render_tri_strip_request_t xcb_out;
1549
1550 xcb_out.op = op;
1551 memset(xcb_out.pad0, 0, 3);
1552 xcb_out.src = src;
1553 xcb_out.dst = dst;
1554 xcb_out.mask_format = mask_format;
1555 xcb_out.src_x = src_x;
1556 xcb_out.src_y = src_y;
1557
1558 xcb_parts[2].iov_base = (char *) &xcb_out;
1559 xcb_parts[2].iov_len = sizeof(xcb_out);
1560 xcb_parts[3].iov_base = 0;
1561 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1562 /* xcb_render_pointfix_t points */
1563 xcb_parts[4].iov_base = (char *) points;
1564 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
1565 xcb_parts[5].iov_base = 0;
1566 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1567
1568 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1569 return xcb_ret;
1570 }
1571
1572 xcb_void_cookie_t
1573 xcb_render_tri_strip (xcb_connection_t *c /**< */,
1574 uint8_t op /**< */,
1575 xcb_render_picture_t src /**< */,
1576 xcb_render_picture_t dst /**< */,
1577 xcb_render_pictformat_t mask_format /**< */,
1578 int16_t src_x /**< */,
1579 int16_t src_y /**< */,
1580 uint32_t points_len /**< */,
1581 const xcb_render_pointfix_t *points /**< */)
1582 {
1583 static const xcb_protocol_request_t xcb_req = {
1584 /* count */ 4,
1585 /* ext */ &xcb_render_id,
1586 /* opcode */ XCB_RENDER_TRI_STRIP,
1587 /* isvoid */ 1
1588 };
1589
1590 struct iovec xcb_parts[6];
1591 xcb_void_cookie_t xcb_ret;
1592 xcb_render_tri_strip_request_t xcb_out;
1593
1594 xcb_out.op = op;
1595 memset(xcb_out.pad0, 0, 3);
1596 xcb_out.src = src;
1597 xcb_out.dst = dst;
1598 xcb_out.mask_format = mask_format;
1599 xcb_out.src_x = src_x;
1600 xcb_out.src_y = src_y;
1601
1602 xcb_parts[2].iov_base = (char *) &xcb_out;
1603 xcb_parts[2].iov_len = sizeof(xcb_out);
1604 xcb_parts[3].iov_base = 0;
1605 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1606 /* xcb_render_pointfix_t points */
1607 xcb_parts[4].iov_base = (char *) points;
1608 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
1609 xcb_parts[5].iov_base = 0;
1610 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1611
1612 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1613 return xcb_ret;
1614 }
1615
1616 int
1617 xcb_render_tri_fan_sizeof (const void *_buffer /**< */,
1618 uint32_t points_len /**< */)
1619 {
1620 char *xcb_tmp = (char *)_buffer;
1621 unsigned int xcb_buffer_len = 0;
1622 unsigned int xcb_block_len = 0;
1623 unsigned int xcb_pad = 0;
1624 unsigned int xcb_align_to = 0;
1625
1626
1627 xcb_block_len += sizeof(xcb_render_tri_fan_request_t);
1628 xcb_tmp += xcb_block_len;
1629 xcb_buffer_len += xcb_block_len;
1630 xcb_block_len = 0;
1631 /* points */
1632 xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
1633 xcb_tmp += xcb_block_len;
1634 xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
1635 /* insert padding */
1636 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1637 xcb_buffer_len += xcb_block_len + xcb_pad;
1638 if (0 != xcb_pad) {
1639 xcb_tmp += xcb_pad;
1640 xcb_pad = 0;
1641 }
1642 xcb_block_len = 0;
1643
1644 return xcb_buffer_len;
1645 }
1646
1647 xcb_void_cookie_t
1648 xcb_render_tri_fan_checked (xcb_connection_t *c /**< */,
1649 uint8_t op /**< */,
1650 xcb_render_picture_t src /**< */,
1651 xcb_render_picture_t dst /**< */,
1652 xcb_render_pictformat_t mask_format /**< */,
1653 int16_t src_x /**< */,
1654 int16_t src_y /**< */,
1655 uint32_t points_len /**< */,
1656 const xcb_render_pointfix_t *points /**< */)
1657 {
1658 static const xcb_protocol_request_t xcb_req = {
1659 /* count */ 4,
1660 /* ext */ &xcb_render_id,
1661 /* opcode */ XCB_RENDER_TRI_FAN,
1662 /* isvoid */ 1
1663 };
1664
1665 struct iovec xcb_parts[6];
1666 xcb_void_cookie_t xcb_ret;
1667 xcb_render_tri_fan_request_t xcb_out;
1668
1669 xcb_out.op = op;
1670 memset(xcb_out.pad0, 0, 3);
1671 xcb_out.src = src;
1672 xcb_out.dst = dst;
1673 xcb_out.mask_format = mask_format;
1674 xcb_out.src_x = src_x;
1675 xcb_out.src_y = src_y;
1676
1677 xcb_parts[2].iov_base = (char *) &xcb_out;
1678 xcb_parts[2].iov_len = sizeof(xcb_out);
1679 xcb_parts[3].iov_base = 0;
1680 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1681 /* xcb_render_pointfix_t points */
1682 xcb_parts[4].iov_base = (char *) points;
1683 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
1684 xcb_parts[5].iov_base = 0;
1685 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1686
1687 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1688 return xcb_ret;
1689 }
1690
1691 xcb_void_cookie_t
1692 xcb_render_tri_fan (xcb_connection_t *c /**< */,
1693 uint8_t op /**< */,
1694 xcb_render_picture_t src /**< */,
1695 xcb_render_picture_t dst /**< */,
1696 xcb_render_pictformat_t mask_format /**< */,
1697 int16_t src_x /**< */,
1698 int16_t src_y /**< */,
1699 uint32_t points_len /**< */,
1700 const xcb_render_pointfix_t *points /**< */)
1701 {
1702 static const xcb_protocol_request_t xcb_req = {
1703 /* count */ 4,
1704 /* ext */ &xcb_render_id,
1705 /* opcode */ XCB_RENDER_TRI_FAN,
1706 /* isvoid */ 1
1707 };
1708
1709 struct iovec xcb_parts[6];
1710 xcb_void_cookie_t xcb_ret;
1711 xcb_render_tri_fan_request_t xcb_out;
1712
1713 xcb_out.op = op;
1714 memset(xcb_out.pad0, 0, 3);
1715 xcb_out.src = src;
1716 xcb_out.dst = dst;
1717 xcb_out.mask_format = mask_format;
1718 xcb_out.src_x = src_x;
1719 xcb_out.src_y = src_y;
1720
1721 xcb_parts[2].iov_base = (char *) &xcb_out;
1722 xcb_parts[2].iov_len = sizeof(xcb_out);
1723 xcb_parts[3].iov_base = 0;
1724 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1725 /* xcb_render_pointfix_t points */
1726 xcb_parts[4].iov_base = (char *) points;
1727 xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
1728 xcb_parts[5].iov_base = 0;
1729 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1730
1731 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1732 return xcb_ret;
1733 }
1734
1735 xcb_void_cookie_t
1736 xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */,
1737 xcb_render_glyphset_t gsid /**< */,
1738 xcb_render_pictformat_t format /**< */)
1739 {
1740 static const xcb_protocol_request_t xcb_req = {
1741 /* count */ 2,
1742 /* ext */ &xcb_render_id,
1743 /* opcode */ XCB_RENDER_CREATE_GLYPH_SET,
1744 /* isvoid */ 1
1745 };
1746
1747 struct iovec xcb_parts[4];
1748 xcb_void_cookie_t xcb_ret;
1749 xcb_render_create_glyph_set_request_t xcb_out;
1750
1751 xcb_out.gsid = gsid;
1752 xcb_out.format = format;
1753
1754 xcb_parts[2].iov_base = (char *) &xcb_out;
1755 xcb_parts[2].iov_len = sizeof(xcb_out);
1756 xcb_parts[3].iov_base = 0;
1757 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1758
1759 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1760 return xcb_ret;
1761 }
1762
1763 xcb_void_cookie_t
1764 xcb_render_create_glyph_set (xcb_connection_t *c /**< */,
1765 xcb_render_glyphset_t gsid /**< */,
1766 xcb_render_pictformat_t format /**< */)
1767 {
1768 static const xcb_protocol_request_t xcb_req = {
1769 /* count */ 2,
1770 /* ext */ &xcb_render_id,
1771 /* opcode */ XCB_RENDER_CREATE_GLYPH_SET,
1772 /* isvoid */ 1
1773 };
1774
1775 struct iovec xcb_parts[4];
1776 xcb_void_cookie_t xcb_ret;
1777 xcb_render_create_glyph_set_request_t xcb_out;
1778
1779 xcb_out.gsid = gsid;
1780 xcb_out.format = format;
1781
1782 xcb_parts[2].iov_base = (char *) &xcb_out;
1783 xcb_parts[2].iov_len = sizeof(xcb_out);
1784 xcb_parts[3].iov_base = 0;
1785 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1786
1787 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1788 return xcb_ret;
1789 }
1790
1791 xcb_void_cookie_t
1792 xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */,
1793 xcb_render_glyphset_t gsid /**< */,
1794 xcb_render_glyphset_t existing /**< */)
1795 {
1796 static const xcb_protocol_request_t xcb_req = {
1797 /* count */ 2,
1798 /* ext */ &xcb_render_id,
1799 /* opcode */ XCB_RENDER_REFERENCE_GLYPH_SET,
1800 /* isvoid */ 1
1801 };
1802
1803 struct iovec xcb_parts[4];
1804 xcb_void_cookie_t xcb_ret;
1805 xcb_render_reference_glyph_set_request_t xcb_out;
1806
1807 xcb_out.gsid = gsid;
1808 xcb_out.existing = existing;
1809
1810 xcb_parts[2].iov_base = (char *) &xcb_out;
1811 xcb_parts[2].iov_len = sizeof(xcb_out);
1812 xcb_parts[3].iov_base = 0;
1813 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1814
1815 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1816 return xcb_ret;
1817 }
1818
1819 xcb_void_cookie_t
1820 xcb_render_reference_glyph_set (xcb_connection_t *c /**< */,
1821 xcb_render_glyphset_t gsid /**< */,
1822 xcb_render_glyphset_t existing /**< */)
1823 {
1824 static const xcb_protocol_request_t xcb_req = {
1825 /* count */ 2,
1826 /* ext */ &xcb_render_id,
1827 /* opcode */ XCB_RENDER_REFERENCE_GLYPH_SET,
1828 /* isvoid */ 1
1829 };
1830
1831 struct iovec xcb_parts[4];
1832 xcb_void_cookie_t xcb_ret;
1833 xcb_render_reference_glyph_set_request_t xcb_out;
1834
1835 xcb_out.gsid = gsid;
1836 xcb_out.existing = existing;
1837
1838 xcb_parts[2].iov_base = (char *) &xcb_out;
1839 xcb_parts[2].iov_len = sizeof(xcb_out);
1840 xcb_parts[3].iov_base = 0;
1841 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1842
1843 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1844 return xcb_ret;
1845 }
1846
1847 xcb_void_cookie_t
1848 xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */,
1849 xcb_render_glyphset_t glyphset /**< */)
1850 {
1851 static const xcb_protocol_request_t xcb_req = {
1852 /* count */ 2,
1853 /* ext */ &xcb_render_id,
1854 /* opcode */ XCB_RENDER_FREE_GLYPH_SET,
1855 /* isvoid */ 1
1856 };
1857
1858 struct iovec xcb_parts[4];
1859 xcb_void_cookie_t xcb_ret;
1860 xcb_render_free_glyph_set_request_t xcb_out;
1861
1862 xcb_out.glyphset = glyphset;
1863
1864 xcb_parts[2].iov_base = (char *) &xcb_out;
1865 xcb_parts[2].iov_len = sizeof(xcb_out);
1866 xcb_parts[3].iov_base = 0;
1867 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1868
1869 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1870 return xcb_ret;
1871 }
1872
1873 xcb_void_cookie_t
1874 xcb_render_free_glyph_set (xcb_connection_t *c /**< */,
1875 xcb_render_glyphset_t glyphset /**< */)
1876 {
1877 static const xcb_protocol_request_t xcb_req = {
1878 /* count */ 2,
1879 /* ext */ &xcb_render_id,
1880 /* opcode */ XCB_RENDER_FREE_GLYPH_SET,
1881 /* isvoid */ 1
1882 };
1883
1884 struct iovec xcb_parts[4];
1885 xcb_void_cookie_t xcb_ret;
1886 xcb_render_free_glyph_set_request_t xcb_out;
1887
1888 xcb_out.glyphset = glyphset;
1889
1890 xcb_parts[2].iov_base = (char *) &xcb_out;
1891 xcb_parts[2].iov_len = sizeof(xcb_out);
1892 xcb_parts[3].iov_base = 0;
1893 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1894
1895 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1896 return xcb_ret;
1897 }
1898
1899 int
1900 xcb_render_add_glyphs_sizeof (const void *_buffer /**< */,
1901 uint32_t data_len /**< */)
1902 {
1903 char *xcb_tmp = (char *)_buffer;
1904 const xcb_render_add_glyphs_request_t *_aux = (xcb_render_add_glyphs_request_t *)_buffer;
1905 unsigned int xcb_buffer_len = 0;
1906 unsigned int xcb_block_len = 0;
1907 unsigned int xcb_pad = 0;
1908 unsigned int xcb_align_to = 0;
1909
1910
1911 xcb_block_len += sizeof(xcb_render_add_glyphs_request_t);
1912 xcb_tmp += xcb_block_len;
1913 xcb_buffer_len += xcb_block_len;
1914 xcb_block_len = 0;
1915 /* glyphids */
1916 xcb_block_len += _aux->glyphs_len * sizeof(uint32_t);
1917 xcb_tmp += xcb_block_len;
1918 xcb_align_to = ALIGNOF(uint32_t);
1919 /* insert padding */
1920 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1921 xcb_buffer_len += xcb_block_len + xcb_pad;
1922 if (0 != xcb_pad) {
1923 xcb_tmp += xcb_pad;
1924 xcb_pad = 0;
1925 }
1926 xcb_block_len = 0;
1927 /* glyphs */
1928 xcb_block_len += _aux->glyphs_len * sizeof(xcb_render_glyphinfo_t);
1929 xcb_tmp += xcb_block_len;
1930 xcb_align_to = ALIGNOF(xcb_render_glyphinfo_t);
1931 /* insert padding */
1932 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1933 xcb_buffer_len += xcb_block_len + xcb_pad;
1934 if (0 != xcb_pad) {
1935 xcb_tmp += xcb_pad;
1936 xcb_pad = 0;
1937 }
1938 xcb_block_len = 0;
1939 /* data */
1940 xcb_block_len += data_len * sizeof(uint8_t);
1941 xcb_tmp += xcb_block_len;
1942 xcb_align_to = ALIGNOF(uint8_t);
1943 /* insert padding */
1944 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1945 xcb_buffer_len += xcb_block_len + xcb_pad;
1946 if (0 != xcb_pad) {
1947 xcb_tmp += xcb_pad;
1948 xcb_pad = 0;
1949 }
1950 xcb_block_len = 0;
1951
1952 return xcb_buffer_len;
1953 }
1954
1955 xcb_void_cookie_t
1956 xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */,
1957 xcb_render_glyphset_t glyphset /**< */,
1958 uint32_t glyphs_len /**< */,
1959 const uint32_t *glyphids /**< */,
1960 const xcb_render_glyphinfo_t *glyphs /**< */,
1961 uint32_t data_len /**< */,
1962 const uint8_t *data /**< */)
1963 {
1964 static const xcb_protocol_request_t xcb_req = {
1965 /* count */ 8,
1966 /* ext */ &xcb_render_id,
1967 /* opcode */ XCB_RENDER_ADD_GLYPHS,
1968 /* isvoid */ 1
1969 };
1970
1971 struct iovec xcb_parts[10];
1972 xcb_void_cookie_t xcb_ret;
1973 xcb_render_add_glyphs_request_t xcb_out;
1974
1975 xcb_out.glyphset = glyphset;
1976 xcb_out.glyphs_len = glyphs_len;
1977
1978 xcb_parts[2].iov_base = (char *) &xcb_out;
1979 xcb_parts[2].iov_len = sizeof(xcb_out);
1980 xcb_parts[3].iov_base = 0;
1981 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1982 /* uint32_t glyphids */
1983 xcb_parts[4].iov_base = (char *) glyphids;
1984 xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
1985 xcb_parts[5].iov_base = 0;
1986 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1987 /* xcb_render_glyphinfo_t glyphs */
1988 xcb_parts[6].iov_base = (char *) glyphs;
1989 xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
1990 xcb_parts[7].iov_base = 0;
1991 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
1992 /* uint8_t data */
1993 xcb_parts[8].iov_base = (char *) data;
1994 xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
1995 xcb_parts[9].iov_base = 0;
1996 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
1997
1998 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1999 return xcb_ret;
2000 }
2001
2002 xcb_void_cookie_t
2003 xcb_render_add_glyphs (xcb_connection_t *c /**< */,
2004 xcb_render_glyphset_t glyphset /**< */,
2005 uint32_t glyphs_len /**< */,
2006 const uint32_t *glyphids /**< */,
2007 const xcb_render_glyphinfo_t *glyphs /**< */,
2008 uint32_t data_len /**< */,
2009 const uint8_t *data /**< */)
2010 {
2011 static const xcb_protocol_request_t xcb_req = {
2012 /* count */ 8,
2013 /* ext */ &xcb_render_id,
2014 /* opcode */ XCB_RENDER_ADD_GLYPHS,
2015 /* isvoid */ 1
2016 };
2017
2018 struct iovec xcb_parts[10];
2019 xcb_void_cookie_t xcb_ret;
2020 xcb_render_add_glyphs_request_t xcb_out;
2021
2022 xcb_out.glyphset = glyphset;
2023 xcb_out.glyphs_len = glyphs_len;
2024
2025 xcb_parts[2].iov_base = (char *) &xcb_out;
2026 xcb_parts[2].iov_len = sizeof(xcb_out);
2027 xcb_parts[3].iov_base = 0;
2028 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2029 /* uint32_t glyphids */
2030 xcb_parts[4].iov_base = (char *) glyphids;
2031 xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
2032 xcb_parts[5].iov_base = 0;
2033 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2034 /* xcb_render_glyphinfo_t glyphs */
2035 xcb_parts[6].iov_base = (char *) glyphs;
2036 xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
2037 xcb_parts[7].iov_base = 0;
2038 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
2039 /* uint8_t data */
2040 xcb_parts[8].iov_base = (char *) data;
2041 xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
2042 xcb_parts[9].iov_base = 0;
2043 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
2044
2045 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2046 return xcb_ret;
2047 }
2048
2049 int
2050 xcb_render_free_glyphs_sizeof (const void *_buffer /**< */,
2051 uint32_t glyphs_len /**< */)
2052 {
2053 char *xcb_tmp = (char *)_buffer;
2054 unsigned int xcb_buffer_len = 0;
2055 unsigned int xcb_block_len = 0;
2056 unsigned int xcb_pad = 0;
2057 unsigned int xcb_align_to = 0;
2058
2059
2060 xcb_block_len += sizeof(xcb_render_free_glyphs_request_t);
2061 xcb_tmp += xcb_block_len;
2062 xcb_buffer_len += xcb_block_len;
2063 xcb_block_len = 0;
2064 /* glyphs */
2065 xcb_block_len += glyphs_len * sizeof(xcb_render_glyph_t);
2066 xcb_tmp += xcb_block_len;
2067 xcb_align_to = ALIGNOF(xcb_render_glyph_t);
2068 /* insert padding */
2069 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2070 xcb_buffer_len += xcb_block_len + xcb_pad;
2071 if (0 != xcb_pad) {
2072 xcb_tmp += xcb_pad;
2073 xcb_pad = 0;
2074 }
2075 xcb_block_len = 0;
2076
2077 return xcb_buffer_len;
2078 }
2079
2080 xcb_void_cookie_t
2081 xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */,
2082 xcb_render_glyphset_t glyphset /**< */,
2083 uint32_t glyphs_len /**< */,
2084 const xcb_render_glyph_t *glyphs /**< */)
2085 {
2086 static const xcb_protocol_request_t xcb_req = {
2087 /* count */ 4,
2088 /* ext */ &xcb_render_id,
2089 /* opcode */ XCB_RENDER_FREE_GLYPHS,
2090 /* isvoid */ 1
2091 };
2092
2093 struct iovec xcb_parts[6];
2094 xcb_void_cookie_t xcb_ret;
2095 xcb_render_free_glyphs_request_t xcb_out;
2096
2097 xcb_out.glyphset = glyphset;
2098
2099 xcb_parts[2].iov_base = (char *) &xcb_out;
2100 xcb_parts[2].iov_len = sizeof(xcb_out);
2101 xcb_parts[3].iov_base = 0;
2102 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2103 /* xcb_render_glyph_t glyphs */
2104 xcb_parts[4].iov_base = (char *) glyphs;
2105 xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
2106 xcb_parts[5].iov_base = 0;
2107 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2108
2109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2110 return xcb_ret;
2111 }
2112
2113 xcb_void_cookie_t
2114 xcb_render_free_glyphs (xcb_connection_t *c /**< */,
2115 xcb_render_glyphset_t glyphset /**< */,
2116 uint32_t glyphs_len /**< */,
2117 const xcb_render_glyph_t *glyphs /**< */)
2118 {
2119 static const xcb_protocol_request_t xcb_req = {
2120 /* count */ 4,
2121 /* ext */ &xcb_render_id,
2122 /* opcode */ XCB_RENDER_FREE_GLYPHS,
2123 /* isvoid */ 1
2124 };
2125
2126 struct iovec xcb_parts[6];
2127 xcb_void_cookie_t xcb_ret;
2128 xcb_render_free_glyphs_request_t xcb_out;
2129
2130 xcb_out.glyphset = glyphset;
2131
2132 xcb_parts[2].iov_base = (char *) &xcb_out;
2133 xcb_parts[2].iov_len = sizeof(xcb_out);
2134 xcb_parts[3].iov_base = 0;
2135 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2136 /* xcb_render_glyph_t glyphs */
2137 xcb_parts[4].iov_base = (char *) glyphs;
2138 xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
2139 xcb_parts[5].iov_base = 0;
2140 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2141
2142 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2143 return xcb_ret;
2144 }
2145
2146 int
2147 xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */,
2148 uint32_t glyphcmds_len /**< */)
2149 {
2150 char *xcb_tmp = (char *)_buffer;
2151 unsigned int xcb_buffer_len = 0;
2152 unsigned int xcb_block_len = 0;
2153 unsigned int xcb_pad = 0;
2154 unsigned int xcb_align_to = 0;
2155
2156
2157 xcb_block_len += sizeof(xcb_render_composite_glyphs_8_request_t);
2158 xcb_tmp += xcb_block_len;
2159 xcb_buffer_len += xcb_block_len;
2160 xcb_block_len = 0;
2161 /* glyphcmds */
2162 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
2163 xcb_tmp += xcb_block_len;
2164 xcb_align_to = ALIGNOF(uint8_t);
2165 /* insert padding */
2166 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2167 xcb_buffer_len += xcb_block_len + xcb_pad;
2168 if (0 != xcb_pad) {
2169 xcb_tmp += xcb_pad;
2170 xcb_pad = 0;
2171 }
2172 xcb_block_len = 0;
2173
2174 return xcb_buffer_len;
2175 }
2176
2177 xcb_void_cookie_t
2178 xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */,
2179 uint8_t op /**< */,
2180 xcb_render_picture_t src /**< */,
2181 xcb_render_picture_t dst /**< */,
2182 xcb_render_pictformat_t mask_format /**< */,
2183 xcb_render_glyphset_t glyphset /**< */,
2184 int16_t src_x /**< */,
2185 int16_t src_y /**< */,
2186 uint32_t glyphcmds_len /**< */,
2187 const uint8_t *glyphcmds /**< */)
2188 {
2189 static const xcb_protocol_request_t xcb_req = {
2190 /* count */ 4,
2191 /* ext */ &xcb_render_id,
2192 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_8,
2193 /* isvoid */ 1
2194 };
2195
2196 struct iovec xcb_parts[6];
2197 xcb_void_cookie_t xcb_ret;
2198 xcb_render_composite_glyphs_8_request_t xcb_out;
2199
2200 xcb_out.op = op;
2201 memset(xcb_out.pad0, 0, 3);
2202 xcb_out.src = src;
2203 xcb_out.dst = dst;
2204 xcb_out.mask_format = mask_format;
2205 xcb_out.glyphset = glyphset;
2206 xcb_out.src_x = src_x;
2207 xcb_out.src_y = src_y;
2208
2209 xcb_parts[2].iov_base = (char *) &xcb_out;
2210 xcb_parts[2].iov_len = sizeof(xcb_out);
2211 xcb_parts[3].iov_base = 0;
2212 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2213 /* uint8_t glyphcmds */
2214 xcb_parts[4].iov_base = (char *) glyphcmds;
2215 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
2216 xcb_parts[5].iov_base = 0;
2217 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2218
2219 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2220 return xcb_ret;
2221 }
2222
2223 xcb_void_cookie_t
2224 xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */,
2225 uint8_t op /**< */,
2226 xcb_render_picture_t src /**< */,
2227 xcb_render_picture_t dst /**< */,
2228 xcb_render_pictformat_t mask_format /**< */,
2229 xcb_render_glyphset_t glyphset /**< */,
2230 int16_t src_x /**< */,
2231 int16_t src_y /**< */,
2232 uint32_t glyphcmds_len /**< */,
2233 const uint8_t *glyphcmds /**< */)
2234 {
2235 static const xcb_protocol_request_t xcb_req = {
2236 /* count */ 4,
2237 /* ext */ &xcb_render_id,
2238 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_8,
2239 /* isvoid */ 1
2240 };
2241
2242 struct iovec xcb_parts[6];
2243 xcb_void_cookie_t xcb_ret;
2244 xcb_render_composite_glyphs_8_request_t xcb_out;
2245
2246 xcb_out.op = op;
2247 memset(xcb_out.pad0, 0, 3);
2248 xcb_out.src = src;
2249 xcb_out.dst = dst;
2250 xcb_out.mask_format = mask_format;
2251 xcb_out.glyphset = glyphset;
2252 xcb_out.src_x = src_x;
2253 xcb_out.src_y = src_y;
2254
2255 xcb_parts[2].iov_base = (char *) &xcb_out;
2256 xcb_parts[2].iov_len = sizeof(xcb_out);
2257 xcb_parts[3].iov_base = 0;
2258 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2259 /* uint8_t glyphcmds */
2260 xcb_parts[4].iov_base = (char *) glyphcmds;
2261 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
2262 xcb_parts[5].iov_base = 0;
2263 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2264
2265 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2266 return xcb_ret;
2267 }
2268
2269 int
2270 xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */,
2271 uint32_t glyphcmds_len /**< */)
2272 {
2273 char *xcb_tmp = (char *)_buffer;
2274 unsigned int xcb_buffer_len = 0;
2275 unsigned int xcb_block_len = 0;
2276 unsigned int xcb_pad = 0;
2277 unsigned int xcb_align_to = 0;
2278
2279
2280 xcb_block_len += sizeof(xcb_render_composite_glyphs_16_request_t);
2281 xcb_tmp += xcb_block_len;
2282 xcb_buffer_len += xcb_block_len;
2283 xcb_block_len = 0;
2284 /* glyphcmds */
2285 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
2286 xcb_tmp += xcb_block_len;
2287 xcb_align_to = ALIGNOF(uint8_t);
2288 /* insert padding */
2289 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2290 xcb_buffer_len += xcb_block_len + xcb_pad;
2291 if (0 != xcb_pad) {
2292 xcb_tmp += xcb_pad;
2293 xcb_pad = 0;
2294 }
2295 xcb_block_len = 0;
2296
2297 return xcb_buffer_len;
2298 }
2299
2300 xcb_void_cookie_t
2301 xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */,
2302 uint8_t op /**< */,
2303 xcb_render_picture_t src /**< */,
2304 xcb_render_picture_t dst /**< */,
2305 xcb_render_pictformat_t mask_format /**< */,
2306 xcb_render_glyphset_t glyphset /**< */,
2307 int16_t src_x /**< */,
2308 int16_t src_y /**< */,
2309 uint32_t glyphcmds_len /**< */,
2310 const uint8_t *glyphcmds /**< */)
2311 {
2312 static const xcb_protocol_request_t xcb_req = {
2313 /* count */ 4,
2314 /* ext */ &xcb_render_id,
2315 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_16,
2316 /* isvoid */ 1
2317 };
2318
2319 struct iovec xcb_parts[6];
2320 xcb_void_cookie_t xcb_ret;
2321 xcb_render_composite_glyphs_16_request_t xcb_out;
2322
2323 xcb_out.op = op;
2324 memset(xcb_out.pad0, 0, 3);
2325 xcb_out.src = src;
2326 xcb_out.dst = dst;
2327 xcb_out.mask_format = mask_format;
2328 xcb_out.glyphset = glyphset;
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 /* uint8_t glyphcmds */
2337 xcb_parts[4].iov_base = (char *) glyphcmds;
2338 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_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
2347 xcb_render_composite_glyphs_16 (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 xcb_render_glyphset_t glyphset /**< */,
2353 int16_t src_x /**< */,
2354 int16_t src_y /**< */,
2355 uint32_t glyphcmds_len /**< */,
2356 const uint8_t *glyphcmds /**< */)
2357 {
2358 static const xcb_protocol_request_t xcb_req = {
2359 /* count */ 4,
2360 /* ext */ &xcb_render_id,
2361 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_16,
2362 /* isvoid */ 1
2363 };
2364
2365 struct iovec xcb_parts[6];
2366 xcb_void_cookie_t xcb_ret;
2367 xcb_render_composite_glyphs_16_request_t xcb_out;
2368
2369 xcb_out.op = op;
2370 memset(xcb_out.pad0, 0, 3);
2371 xcb_out.src = src;
2372 xcb_out.dst = dst;
2373 xcb_out.mask_format = mask_format;
2374 xcb_out.glyphset = glyphset;
2375 xcb_out.src_x = src_x;
2376 xcb_out.src_y = src_y;
2377
2378 xcb_parts[2].iov_base = (char *) &xcb_out;
2379 xcb_parts[2].iov_len = sizeof(xcb_out);
2380 xcb_parts[3].iov_base = 0;
2381 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2382 /* uint8_t glyphcmds */
2383 xcb_parts[4].iov_base = (char *) glyphcmds;
2384 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
2385 xcb_parts[5].iov_base = 0;
2386 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2387
2388 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2389 return xcb_ret;
2390 }
2391
2392 int
2393 xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */,
2394 uint32_t glyphcmds_len /**< */)
2395 {
2396 char *xcb_tmp = (char *)_buffer;
2397 unsigned int xcb_buffer_len = 0;
2398 unsigned int xcb_block_len = 0;
2399 unsigned int xcb_pad = 0;
2400 unsigned int xcb_align_to = 0;
2401
2402
2403 xcb_block_len += sizeof(xcb_render_composite_glyphs_32_request_t);
2404 xcb_tmp += xcb_block_len;
2405 xcb_buffer_len += xcb_block_len;
2406 xcb_block_len = 0;
2407 /* glyphcmds */
2408 xcb_block_len += glyphcmds_len * sizeof(uint8_t);
2409 xcb_tmp += xcb_block_len;
2410 xcb_align_to = ALIGNOF(uint8_t);
2411 /* insert padding */
2412 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2413 xcb_buffer_len += xcb_block_len + xcb_pad;
2414 if (0 != xcb_pad) {
2415 xcb_tmp += xcb_pad;
2416 xcb_pad = 0;
2417 }
2418 xcb_block_len = 0;
2419
2420 return xcb_buffer_len;
2421 }
2422
2423 xcb_void_cookie_t
2424 xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */,
2425 uint8_t op /**< */,
2426 xcb_render_picture_t src /**< */,
2427 xcb_render_picture_t dst /**< */,
2428 xcb_render_pictformat_t mask_format /**< */,
2429 xcb_render_glyphset_t glyphset /**< */,
2430 int16_t src_x /**< */,
2431 int16_t src_y /**< */,
2432 uint32_t glyphcmds_len /**< */,
2433 const uint8_t *glyphcmds /**< */)
2434 {
2435 static const xcb_protocol_request_t xcb_req = {
2436 /* count */ 4,
2437 /* ext */ &xcb_render_id,
2438 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_32,
2439 /* isvoid */ 1
2440 };
2441
2442 struct iovec xcb_parts[6];
2443 xcb_void_cookie_t xcb_ret;
2444 xcb_render_composite_glyphs_32_request_t xcb_out;
2445
2446 xcb_out.op = op;
2447 memset(xcb_out.pad0, 0, 3);
2448 xcb_out.src = src;
2449 xcb_out.dst = dst;
2450 xcb_out.mask_format = mask_format;
2451 xcb_out.glyphset = glyphset;
2452 xcb_out.src_x = src_x;
2453 xcb_out.src_y = src_y;
2454
2455 xcb_parts[2].iov_base = (char *) &xcb_out;
2456 xcb_parts[2].iov_len = sizeof(xcb_out);
2457 xcb_parts[3].iov_base = 0;
2458 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2459 /* uint8_t glyphcmds */
2460 xcb_parts[4].iov_base = (char *) glyphcmds;
2461 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
2462 xcb_parts[5].iov_base = 0;
2463 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2464
2465 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2466 return xcb_ret;
2467 }
2468
2469 xcb_void_cookie_t
2470 xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */,
2471 uint8_t op /**< */,
2472 xcb_render_picture_t src /**< */,
2473 xcb_render_picture_t dst /**< */,
2474 xcb_render_pictformat_t mask_format /**< */,
2475 xcb_render_glyphset_t glyphset /**< */,
2476 int16_t src_x /**< */,
2477 int16_t src_y /**< */,
2478 uint32_t glyphcmds_len /**< */,
2479 const uint8_t *glyphcmds /**< */)
2480 {
2481 static const xcb_protocol_request_t xcb_req = {
2482 /* count */ 4,
2483 /* ext */ &xcb_render_id,
2484 /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_32,
2485 /* isvoid */ 1
2486 };
2487
2488 struct iovec xcb_parts[6];
2489 xcb_void_cookie_t xcb_ret;
2490 xcb_render_composite_glyphs_32_request_t xcb_out;
2491
2492 xcb_out.op = op;
2493 memset(xcb_out.pad0, 0, 3);
2494 xcb_out.src = src;
2495 xcb_out.dst = dst;
2496 xcb_out.mask_format = mask_format;
2497 xcb_out.glyphset = glyphset;
2498 xcb_out.src_x = src_x;
2499 xcb_out.src_y = src_y;
2500
2501 xcb_parts[2].iov_base = (char *) &xcb_out;
2502 xcb_parts[2].iov_len = sizeof(xcb_out);
2503 xcb_parts[3].iov_base = 0;
2504 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2505 /* uint8_t glyphcmds */
2506 xcb_parts[4].iov_base = (char *) glyphcmds;
2507 xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
2508 xcb_parts[5].iov_base = 0;
2509 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2510
2511 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2512 return xcb_ret;
2513 }
2514
2515 int
2516 xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */,
2517 uint32_t rects_len /**< */)
2518 {
2519 char *xcb_tmp = (char *)_buffer;
2520 unsigned int xcb_buffer_len = 0;
2521 unsigned int xcb_block_len = 0;
2522 unsigned int xcb_pad = 0;
2523 unsigned int xcb_align_to = 0;
2524
2525
2526 xcb_block_len += sizeof(xcb_render_fill_rectangles_request_t);
2527 xcb_tmp += xcb_block_len;
2528 xcb_buffer_len += xcb_block_len;
2529 xcb_block_len = 0;
2530 /* rects */
2531 xcb_block_len += rects_len * sizeof(xcb_rectangle_t);
2532 xcb_tmp += xcb_block_len;
2533 xcb_align_to = ALIGNOF(xcb_rectangle_t);
2534 /* insert padding */
2535 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2536 xcb_buffer_len += xcb_block_len + xcb_pad;
2537 if (0 != xcb_pad) {
2538 xcb_tmp += xcb_pad;
2539 xcb_pad = 0;
2540 }
2541 xcb_block_len = 0;
2542
2543 return xcb_buffer_len;
2544 }
2545
2546 xcb_void_cookie_t
2547 xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */,
2548 uint8_t op /**< */,
2549 xcb_render_picture_t dst /**< */,
2550 xcb_render_color_t color /**< */,
2551 uint32_t rects_len /**< */,
2552 const xcb_rectangle_t *rects /**< */)
2553 {
2554 static const xcb_protocol_request_t xcb_req = {
2555 /* count */ 4,
2556 /* ext */ &xcb_render_id,
2557 /* opcode */ XCB_RENDER_FILL_RECTANGLES,
2558 /* isvoid */ 1
2559 };
2560
2561 struct iovec xcb_parts[6];
2562 xcb_void_cookie_t xcb_ret;
2563 xcb_render_fill_rectangles_request_t xcb_out;
2564
2565 xcb_out.op = op;
2566 memset(xcb_out.pad0, 0, 3);
2567 xcb_out.dst = dst;
2568 xcb_out.color = color;
2569
2570 xcb_parts[2].iov_base = (char *) &xcb_out;
2571 xcb_parts[2].iov_len = sizeof(xcb_out);
2572 xcb_parts[3].iov_base = 0;
2573 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2574 /* xcb_rectangle_t rects */
2575 xcb_parts[4].iov_base = (char *) rects;
2576 xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
2577 xcb_parts[5].iov_base = 0;
2578 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2579
2580 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2581 return xcb_ret;
2582 }
2583
2584 xcb_void_cookie_t
2585 xcb_render_fill_rectangles (xcb_connection_t *c /**< */,
2586 uint8_t op /**< */,
2587 xcb_render_picture_t dst /**< */,
2588 xcb_render_color_t color /**< */,
2589 uint32_t rects_len /**< */,
2590 const xcb_rectangle_t *rects /**< */)
2591 {
2592 static const xcb_protocol_request_t xcb_req = {
2593 /* count */ 4,
2594 /* ext */ &xcb_render_id,
2595 /* opcode */ XCB_RENDER_FILL_RECTANGLES,
2596 /* isvoid */ 1
2597 };
2598
2599 struct iovec xcb_parts[6];
2600 xcb_void_cookie_t xcb_ret;
2601 xcb_render_fill_rectangles_request_t xcb_out;
2602
2603 xcb_out.op = op;
2604 memset(xcb_out.pad0, 0, 3);
2605 xcb_out.dst = dst;
2606 xcb_out.color = color;
2607
2608 xcb_parts[2].iov_base = (char *) &xcb_out;
2609 xcb_parts[2].iov_len = sizeof(xcb_out);
2610 xcb_parts[3].iov_base = 0;
2611 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2612 /* xcb_rectangle_t rects */
2613 xcb_parts[4].iov_base = (char *) rects;
2614 xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
2615 xcb_parts[5].iov_base = 0;
2616 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2617
2618 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2619 return xcb_ret;
2620 }
2621
2622 xcb_void_cookie_t
2623 xcb_render_create_cursor_checked (xcb_connection_t *c /**< */,
2624 xcb_cursor_t cid /**< */,
2625 xcb_render_picture_t source /**< */,
2626 uint16_t x /**< */,
2627 uint16_t y /**< */)
2628 {
2629 static const xcb_protocol_request_t xcb_req = {
2630 /* count */ 2,
2631 /* ext */ &xcb_render_id,
2632 /* opcode */ XCB_RENDER_CREATE_CURSOR,
2633 /* isvoid */ 1
2634 };
2635
2636 struct iovec xcb_parts[4];
2637 xcb_void_cookie_t xcb_ret;
2638 xcb_render_create_cursor_request_t xcb_out;
2639
2640 xcb_out.cid = cid;
2641 xcb_out.source = source;
2642 xcb_out.x = x;
2643 xcb_out.y = y;
2644
2645 xcb_parts[2].iov_base = (char *) &xcb_out;
2646 xcb_parts[2].iov_len = sizeof(xcb_out);
2647 xcb_parts[3].iov_base = 0;
2648 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2649
2650 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2651 return xcb_ret;
2652 }
2653
2654 xcb_void_cookie_t
2655 xcb_render_create_cursor (xcb_connection_t *c /**< */,
2656 xcb_cursor_t cid /**< */,
2657 xcb_render_picture_t source /**< */,
2658 uint16_t x /**< */,
2659 uint16_t y /**< */)
2660 {
2661 static const xcb_protocol_request_t xcb_req = {
2662 /* count */ 2,
2663 /* ext */ &xcb_render_id,
2664 /* opcode */ XCB_RENDER_CREATE_CURSOR,
2665 /* isvoid */ 1
2666 };
2667
2668 struct iovec xcb_parts[4];
2669 xcb_void_cookie_t xcb_ret;
2670 xcb_render_create_cursor_request_t xcb_out;
2671
2672 xcb_out.cid = cid;
2673 xcb_out.source = source;
2674 xcb_out.x = x;
2675 xcb_out.y = y;
2676
2677 xcb_parts[2].iov_base = (char *) &xcb_out;
2678 xcb_parts[2].iov_len = sizeof(xcb_out);
2679 xcb_parts[3].iov_base = 0;
2680 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2681
2682 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2683 return xcb_ret;
2684 }
2685
2686 void
2687 xcb_render_transform_next (xcb_render_transform_iterator_t *i /**< */)
2688 {
2689 --i->rem;
2690 ++i->data;
2691 i->index += sizeof(xcb_render_transform_t);
2692 }
2693
2694 xcb_generic_iterator_t
2695 xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */)
2696 {
2697 xcb_generic_iterator_t ret;
2698 ret.data = i.data + i.rem;
2699 ret.index = i.index + ((char *) ret.data - (char *) i.data);
2700 ret.rem = 0;
2701 return ret;
2702 }
2703
2704 xcb_void_cookie_t
2705 xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */,
2706 xcb_render_picture_t picture /**< */,
2707 xcb_render_transform_t transform /**< */)
2708 {
2709 static const xcb_protocol_request_t xcb_req = {
2710 /* count */ 2,
2711 /* ext */ &xcb_render_id,
2712 /* opcode */ XCB_RENDER_SET_PICTURE_TRANSFORM,
2713 /* isvoid */ 1
2714 };
2715
2716 struct iovec xcb_parts[4];
2717 xcb_void_cookie_t xcb_ret;
2718 xcb_render_set_picture_transform_request_t xcb_out;
2719
2720 xcb_out.picture = picture;
2721 xcb_out.transform = transform;
2722
2723 xcb_parts[2].iov_base = (char *) &xcb_out;
2724 xcb_parts[2].iov_len = sizeof(xcb_out);
2725 xcb_parts[3].iov_base = 0;
2726 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2727
2728 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2729 return xcb_ret;
2730 }
2731
2732 xcb_void_cookie_t
2733 xcb_render_set_picture_transform (xcb_connection_t *c /**< */,
2734 xcb_render_picture_t picture /**< */,
2735 xcb_render_transform_t transform /**< */)
2736 {
2737 static const xcb_protocol_request_t xcb_req = {
2738 /* count */ 2,
2739 /* ext */ &xcb_render_id,
2740 /* opcode */ XCB_RENDER_SET_PICTURE_TRANSFORM,
2741 /* isvoid */ 1
2742 };
2743
2744 struct iovec xcb_parts[4];
2745 xcb_void_cookie_t xcb_ret;
2746 xcb_render_set_picture_transform_request_t xcb_out;
2747
2748 xcb_out.picture = picture;
2749 xcb_out.transform = transform;
2750
2751 xcb_parts[2].iov_base = (char *) &xcb_out;
2752 xcb_parts[2].iov_len = sizeof(xcb_out);
2753 xcb_parts[3].iov_base = 0;
2754 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2755
2756 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2757 return xcb_ret;
2758 }
2759
2760 int
2761 xcb_render_query_filters_sizeof (const void *_buffer /**< */)
2762 {
2763 char *xcb_tmp = (char *)_buffer;
2764 const xcb_render_query_filters_reply_t *_aux = (xcb_render_query_filters_reply_t *)_buffer;
2765 unsigned int xcb_buffer_len = 0;
2766 unsigned int xcb_block_len = 0;
2767 unsigned int xcb_pad = 0;
2768 unsigned int xcb_align_to = 0;
2769
2770 unsigned int i;
2771 unsigned int xcb_tmp_len;
2772
2773 xcb_block_len += sizeof(xcb_render_query_filters_reply_t);
2774 xcb_tmp += xcb_block_len;
2775 xcb_buffer_len += xcb_block_len;
2776 xcb_block_len = 0;
2777 /* aliases */
2778 xcb_block_len += _aux->num_aliases * sizeof(uint16_t);
2779 xcb_tmp += xcb_block_len;
2780 xcb_align_to = ALIGNOF(uint16_t);
2781 /* insert padding */
2782 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2783 xcb_buffer_len += xcb_block_len + xcb_pad;
2784 if (0 != xcb_pad) {
2785 xcb_tmp += xcb_pad;
2786 xcb_pad = 0;
2787 }
2788 xcb_block_len = 0;
2789 /* filters */
2790 for(i=0; i<_aux->num_filters; i++) {
2791 xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
2792 xcb_block_len += xcb_tmp_len;
2793 xcb_tmp += xcb_tmp_len;
2794 }
2795 xcb_align_to = ALIGNOF(xcb_str_t);
2796 /* insert padding */
2797 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2798 xcb_buffer_len += xcb_block_len + xcb_pad;
2799 if (0 != xcb_pad) {
2800 xcb_tmp += xcb_pad;
2801 xcb_pad = 0;
2802 }
2803 xcb_block_len = 0;
2804
2805 return xcb_buffer_len;
2806 }
2807
2808 xcb_render_query_filters_cookie_t
2809 xcb_render_query_filters (xcb_connection_t *c /**< */,
2810 xcb_drawable_t drawable /**< */)
2811 {
2812 static const xcb_protocol_request_t xcb_req = {
2813 /* count */ 2,
2814 /* ext */ &xcb_render_id,
2815 /* opcode */ XCB_RENDER_QUERY_FILTERS,
2816 /* isvoid */ 0
2817 };
2818
2819 struct iovec xcb_parts[4];
2820 xcb_render_query_filters_cookie_t xcb_ret;
2821 xcb_render_query_filters_request_t xcb_out;
2822
2823 xcb_out.drawable = drawable;
2824
2825 xcb_parts[2].iov_base = (char *) &xcb_out;
2826 xcb_parts[2].iov_len = sizeof(xcb_out);
2827 xcb_parts[3].iov_base = 0;
2828 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2829
2830 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2831 return xcb_ret;
2832 }
2833
2834 xcb_render_query_filters_cookie_t
2835 xcb_render_query_filters_unchecked (xcb_connection_t *c /**< */,
2836 xcb_drawable_t drawable /**< */)
2837 {
2838 static const xcb_protocol_request_t xcb_req = {
2839 /* count */ 2,
2840 /* ext */ &xcb_render_id,
2841 /* opcode */ XCB_RENDER_QUERY_FILTERS,
2842 /* isvoid */ 0
2843 };
2844
2845 struct iovec xcb_parts[4];
2846 xcb_render_query_filters_cookie_t xcb_ret;
2847 xcb_render_query_filters_request_t xcb_out;
2848
2849 xcb_out.drawable = drawable;
2850
2851 xcb_parts[2].iov_base = (char *) &xcb_out;
2852 xcb_parts[2].iov_len = sizeof(xcb_out);
2853 xcb_parts[3].iov_base = 0;
2854 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2855
2856 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2857 return xcb_ret;
2858 }
2859
2860 uint16_t *
2861 xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R /**< */)
2862 {
2863 return (uint16_t *) (R + 1);
2864 }
2865
2866 int
2867 xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R /**< */)
2868 {
2869 return R->num_aliases;
2870 }
2871
2872 xcb_generic_iterator_t
2873 xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R /**< */)
2874 {
2875 xcb_generic_iterator_t i;
2876 i.data = ((uint16_t *) (R + 1)) + (R->num_aliases);
2877 i.rem = 0;
2878 i.index = (char *) i.data - (char *) R;
2879 return i;
2880 }
2881
2882 int
2883 xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R /**< */)
2884 {
2885 return R->num_filters;
2886 }
2887
2888 xcb_str_iterator_t
2889 xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R /**< */)
2890 {
2891 xcb_str_iterator_t i;
2892 xcb_generic_iterator_t prev = xcb_render_query_filters_aliases_end(R);
2893 i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index));
2894 i.rem = R->num_filters;
2895 i.index = (char *) i.data - (char *) R;
2896 return i;
2897 }
2898
2899 xcb_render_query_filters_reply_t *
2900 xcb_render_query_filters_reply (xcb_connection_t *c /**< */,
2901 xcb_render_query_filters_cookie_t cookie /**< */,
2902 xcb_generic_error_t **e /**< */)
2903 {
2904 return (xcb_render_query_filters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2905 }
2906
2907 int
2908 xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */,
2909 uint32_t values_len /**< */)
2910 {
2911 char *xcb_tmp = (char *)_buffer;
2912 const xcb_render_set_picture_filter_request_t *_aux = (xcb_render_set_picture_filter_request_t *)_buffer;
2913 unsigned int xcb_buffer_len = 0;
2914 unsigned int xcb_block_len = 0;
2915 unsigned int xcb_pad = 0;
2916 unsigned int xcb_align_to = 0;
2917
2918
2919 xcb_block_len += sizeof(xcb_render_set_picture_filter_request_t);
2920 xcb_tmp += xcb_block_len;
2921 xcb_buffer_len += xcb_block_len;
2922 xcb_block_len = 0;
2923 /* filter */
2924 xcb_block_len += _aux->filter_len * sizeof(char);
2925 xcb_tmp += xcb_block_len;
2926 xcb_align_to = ALIGNOF(char);
2927 /* insert padding */
2928 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2929 xcb_buffer_len += xcb_block_len + xcb_pad;
2930 if (0 != xcb_pad) {
2931 xcb_tmp += xcb_pad;
2932 xcb_pad = 0;
2933 }
2934 xcb_block_len = 0;
2935 /* values */
2936 xcb_block_len += values_len * sizeof(xcb_render_fixed_t);
2937 xcb_tmp += xcb_block_len;
2938 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
2939 /* insert padding */
2940 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2941 xcb_buffer_len += xcb_block_len + xcb_pad;
2942 if (0 != xcb_pad) {
2943 xcb_tmp += xcb_pad;
2944 xcb_pad = 0;
2945 }
2946 xcb_block_len = 0;
2947
2948 return xcb_buffer_len;
2949 }
2950
2951 xcb_void_cookie_t
2952 xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */,
2953 xcb_render_picture_t picture /**< */,
2954 uint16_t filter_len /**< */,
2955 const char *filter /**< */,
2956 uint32_t values_len /**< */,
2957 const xcb_render_fixed_t *values /**< */)
2958 {
2959 static const xcb_protocol_request_t xcb_req = {
2960 /* count */ 6,
2961 /* ext */ &xcb_render_id,
2962 /* opcode */ XCB_RENDER_SET_PICTURE_FILTER,
2963 /* isvoid */ 1
2964 };
2965
2966 struct iovec xcb_parts[8];
2967 xcb_void_cookie_t xcb_ret;
2968 xcb_render_set_picture_filter_request_t xcb_out;
2969
2970 xcb_out.picture = picture;
2971 xcb_out.filter_len = filter_len;
2972 memset(xcb_out.pad0, 0, 2);
2973
2974 xcb_parts[2].iov_base = (char *) &xcb_out;
2975 xcb_parts[2].iov_len = sizeof(xcb_out);
2976 xcb_parts[3].iov_base = 0;
2977 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2978 /* char filter */
2979 xcb_parts[4].iov_base = (char *) filter;
2980 xcb_parts[4].iov_len = filter_len * sizeof(char);
2981 xcb_parts[5].iov_base = 0;
2982 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2983 /* xcb_render_fixed_t values */
2984 xcb_parts[6].iov_base = (char *) values;
2985 xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
2986 xcb_parts[7].iov_base = 0;
2987 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
2988
2989 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2990 return xcb_ret;
2991 }
2992
2993 xcb_void_cookie_t
2994 xcb_render_set_picture_filter (xcb_connection_t *c /**< */,
2995 xcb_render_picture_t picture /**< */,
2996 uint16_t filter_len /**< */,
2997 const char *filter /**< */,
2998 uint32_t values_len /**< */,
2999 const xcb_render_fixed_t *values /**< */)
3000 {
3001 static const xcb_protocol_request_t xcb_req = {
3002 /* count */ 6,
3003 /* ext */ &xcb_render_id,
3004 /* opcode */ XCB_RENDER_SET_PICTURE_FILTER,
3005 /* isvoid */ 1
3006 };
3007
3008 struct iovec xcb_parts[8];
3009 xcb_void_cookie_t xcb_ret;
3010 xcb_render_set_picture_filter_request_t xcb_out;
3011
3012 xcb_out.picture = picture;
3013 xcb_out.filter_len = filter_len;
3014 memset(xcb_out.pad0, 0, 2);
3015
3016 xcb_parts[2].iov_base = (char *) &xcb_out;
3017 xcb_parts[2].iov_len = sizeof(xcb_out);
3018 xcb_parts[3].iov_base = 0;
3019 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3020 /* char filter */
3021 xcb_parts[4].iov_base = (char *) filter;
3022 xcb_parts[4].iov_len = filter_len * sizeof(char);
3023 xcb_parts[5].iov_base = 0;
3024 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3025 /* xcb_render_fixed_t values */
3026 xcb_parts[6].iov_base = (char *) values;
3027 xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
3028 xcb_parts[7].iov_base = 0;
3029 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3030
3031 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3032 return xcb_ret;
3033 }
3034
3035 void
3036 xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */)
3037 {
3038 --i->rem;
3039 ++i->data;
3040 i->index += sizeof(xcb_render_animcursorelt_t);
3041 }
3042
3043 xcb_generic_iterator_t
3044 xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */)
3045 {
3046 xcb_generic_iterator_t ret;
3047 ret.data = i.data + i.rem;
3048 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3049 ret.rem = 0;
3050 return ret;
3051 }
3052
3053 int
3054 xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */,
3055 uint32_t cursors_len /**< */)
3056 {
3057 char *xcb_tmp = (char *)_buffer;
3058 unsigned int xcb_buffer_len = 0;
3059 unsigned int xcb_block_len = 0;
3060 unsigned int xcb_pad = 0;
3061 unsigned int xcb_align_to = 0;
3062
3063
3064 xcb_block_len += sizeof(xcb_render_create_anim_cursor_request_t);
3065 xcb_tmp += xcb_block_len;
3066 xcb_buffer_len += xcb_block_len;
3067 xcb_block_len = 0;
3068 /* cursors */
3069 xcb_block_len += cursors_len * sizeof(xcb_render_animcursorelt_t);
3070 xcb_tmp += xcb_block_len;
3071 xcb_align_to = ALIGNOF(xcb_render_animcursorelt_t);
3072 /* insert padding */
3073 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3074 xcb_buffer_len += xcb_block_len + xcb_pad;
3075 if (0 != xcb_pad) {
3076 xcb_tmp += xcb_pad;
3077 xcb_pad = 0;
3078 }
3079 xcb_block_len = 0;
3080
3081 return xcb_buffer_len;
3082 }
3083
3084 xcb_void_cookie_t
3085 xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< */,
3086 xcb_cursor_t cid /**< */,
3087 uint32_t cursors_len /**< */,
3088 const xcb_render_animcursorelt_t *cursors /**< */)
3089 {
3090 static const xcb_protocol_request_t xcb_req = {
3091 /* count */ 4,
3092 /* ext */ &xcb_render_id,
3093 /* opcode */ XCB_RENDER_CREATE_ANIM_CURSOR,
3094 /* isvoid */ 1
3095 };
3096
3097 struct iovec xcb_parts[6];
3098 xcb_void_cookie_t xcb_ret;
3099 xcb_render_create_anim_cursor_request_t xcb_out;
3100
3101 xcb_out.cid = cid;
3102
3103 xcb_parts[2].iov_base = (char *) &xcb_out;
3104 xcb_parts[2].iov_len = sizeof(xcb_out);
3105 xcb_parts[3].iov_base = 0;
3106 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3107 /* xcb_render_animcursorelt_t cursors */
3108 xcb_parts[4].iov_base = (char *) cursors;
3109 xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
3110 xcb_parts[5].iov_base = 0;
3111 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3112
3113 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3114 return xcb_ret;
3115 }
3116
3117 xcb_void_cookie_t
3118 xcb_render_create_anim_cursor (xcb_connection_t *c /**< */,
3119 xcb_cursor_t cid /**< */,
3120 uint32_t cursors_len /**< */,
3121 const xcb_render_animcursorelt_t *cursors /**< */)
3122 {
3123 static const xcb_protocol_request_t xcb_req = {
3124 /* count */ 4,
3125 /* ext */ &xcb_render_id,
3126 /* opcode */ XCB_RENDER_CREATE_ANIM_CURSOR,
3127 /* isvoid */ 1
3128 };
3129
3130 struct iovec xcb_parts[6];
3131 xcb_void_cookie_t xcb_ret;
3132 xcb_render_create_anim_cursor_request_t xcb_out;
3133
3134 xcb_out.cid = cid;
3135
3136 xcb_parts[2].iov_base = (char *) &xcb_out;
3137 xcb_parts[2].iov_len = sizeof(xcb_out);
3138 xcb_parts[3].iov_base = 0;
3139 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3140 /* xcb_render_animcursorelt_t cursors */
3141 xcb_parts[4].iov_base = (char *) cursors;
3142 xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
3143 xcb_parts[5].iov_base = 0;
3144 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3145
3146 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3147 return xcb_ret;
3148 }
3149
3150 void
3151 xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i /**< */)
3152 {
3153 --i->rem;
3154 ++i->data;
3155 i->index += sizeof(xcb_render_spanfix_t);
3156 }
3157
3158 xcb_generic_iterator_t
3159 xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i /**< */)
3160 {
3161 xcb_generic_iterator_t ret;
3162 ret.data = i.data + i.rem;
3163 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3164 ret.rem = 0;
3165 return ret;
3166 }
3167
3168 void
3169 xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */)
3170 {
3171 --i->rem;
3172 ++i->data;
3173 i->index += sizeof(xcb_render_trap_t);
3174 }
3175
3176 xcb_generic_iterator_t
3177 xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */)
3178 {
3179 xcb_generic_iterator_t ret;
3180 ret.data = i.data + i.rem;
3181 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3182 ret.rem = 0;
3183 return ret;
3184 }
3185
3186 int
3187 xcb_render_add_traps_sizeof (const void *_buffer /**< */,
3188 uint32_t traps_len /**< */)
3189 {
3190 char *xcb_tmp = (char *)_buffer;
3191 unsigned int xcb_buffer_len = 0;
3192 unsigned int xcb_block_len = 0;
3193 unsigned int xcb_pad = 0;
3194 unsigned int xcb_align_to = 0;
3195
3196
3197 xcb_block_len += sizeof(xcb_render_add_traps_request_t);
3198 xcb_tmp += xcb_block_len;
3199 xcb_buffer_len += xcb_block_len;
3200 xcb_block_len = 0;
3201 /* traps */
3202 xcb_block_len += traps_len * sizeof(xcb_render_trap_t);
3203 xcb_tmp += xcb_block_len;
3204 xcb_align_to = ALIGNOF(xcb_render_trap_t);
3205 /* insert padding */
3206 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3207 xcb_buffer_len += xcb_block_len + xcb_pad;
3208 if (0 != xcb_pad) {
3209 xcb_tmp += xcb_pad;
3210 xcb_pad = 0;
3211 }
3212 xcb_block_len = 0;
3213
3214 return xcb_buffer_len;
3215 }
3216
3217 xcb_void_cookie_t
3218 xcb_render_add_traps_checked (xcb_connection_t *c /**< */,
3219 xcb_render_picture_t picture /**< */,
3220 int16_t x_off /**< */,
3221 int16_t y_off /**< */,
3222 uint32_t traps_len /**< */,
3223 const xcb_render_trap_t *traps /**< */)
3224 {
3225 static const xcb_protocol_request_t xcb_req = {
3226 /* count */ 4,
3227 /* ext */ &xcb_render_id,
3228 /* opcode */ XCB_RENDER_ADD_TRAPS,
3229 /* isvoid */ 1
3230 };
3231
3232 struct iovec xcb_parts[6];
3233 xcb_void_cookie_t xcb_ret;
3234 xcb_render_add_traps_request_t xcb_out;
3235
3236 xcb_out.picture = picture;
3237 xcb_out.x_off = x_off;
3238 xcb_out.y_off = y_off;
3239
3240 xcb_parts[2].iov_base = (char *) &xcb_out;
3241 xcb_parts[2].iov_len = sizeof(xcb_out);
3242 xcb_parts[3].iov_base = 0;
3243 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3244 /* xcb_render_trap_t traps */
3245 xcb_parts[4].iov_base = (char *) traps;
3246 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
3247 xcb_parts[5].iov_base = 0;
3248 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3249
3250 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3251 return xcb_ret;
3252 }
3253
3254 xcb_void_cookie_t
3255 xcb_render_add_traps (xcb_connection_t *c /**< */,
3256 xcb_render_picture_t picture /**< */,
3257 int16_t x_off /**< */,
3258 int16_t y_off /**< */,
3259 uint32_t traps_len /**< */,
3260 const xcb_render_trap_t *traps /**< */)
3261 {
3262 static const xcb_protocol_request_t xcb_req = {
3263 /* count */ 4,
3264 /* ext */ &xcb_render_id,
3265 /* opcode */ XCB_RENDER_ADD_TRAPS,
3266 /* isvoid */ 1
3267 };
3268
3269 struct iovec xcb_parts[6];
3270 xcb_void_cookie_t xcb_ret;
3271 xcb_render_add_traps_request_t xcb_out;
3272
3273 xcb_out.picture = picture;
3274 xcb_out.x_off = x_off;
3275 xcb_out.y_off = y_off;
3276
3277 xcb_parts[2].iov_base = (char *) &xcb_out;
3278 xcb_parts[2].iov_len = sizeof(xcb_out);
3279 xcb_parts[3].iov_base = 0;
3280 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3281 /* xcb_render_trap_t traps */
3282 xcb_parts[4].iov_base = (char *) traps;
3283 xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
3284 xcb_parts[5].iov_base = 0;
3285 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3286
3287 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3288 return xcb_ret;
3289 }
3290
3291 xcb_void_cookie_t
3292 xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */,
3293 xcb_render_picture_t picture /**< */,
3294 xcb_render_color_t color /**< */)
3295 {
3296 static const xcb_protocol_request_t xcb_req = {
3297 /* count */ 2,
3298 /* ext */ &xcb_render_id,
3299 /* opcode */ XCB_RENDER_CREATE_SOLID_FILL,
3300 /* isvoid */ 1
3301 };
3302
3303 struct iovec xcb_parts[4];
3304 xcb_void_cookie_t xcb_ret;
3305 xcb_render_create_solid_fill_request_t xcb_out;
3306
3307 xcb_out.picture = picture;
3308 xcb_out.color = color;
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
3315 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3316 return xcb_ret;
3317 }
3318
3319 xcb_void_cookie_t
3320 xcb_render_create_solid_fill (xcb_connection_t *c /**< */,
3321 xcb_render_picture_t picture /**< */,
3322 xcb_render_color_t color /**< */)
3323 {
3324 static const xcb_protocol_request_t xcb_req = {
3325 /* count */ 2,
3326 /* ext */ &xcb_render_id,
3327 /* opcode */ XCB_RENDER_CREATE_SOLID_FILL,
3328 /* isvoid */ 1
3329 };
3330
3331 struct iovec xcb_parts[4];
3332 xcb_void_cookie_t xcb_ret;
3333 xcb_render_create_solid_fill_request_t xcb_out;
3334
3335 xcb_out.picture = picture;
3336 xcb_out.color = color;
3337
3338 xcb_parts[2].iov_base = (char *) &xcb_out;
3339 xcb_parts[2].iov_len = sizeof(xcb_out);
3340 xcb_parts[3].iov_base = 0;
3341 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3342
3343 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3344 return xcb_ret;
3345 }
3346
3347 int
3348 xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */)
3349 {
3350 char *xcb_tmp = (char *)_buffer;
3351 const xcb_render_create_linear_gradient_request_t *_aux = (xcb_render_create_linear_gradient_request_t *)_buffer;
3352 unsigned int xcb_buffer_len = 0;
3353 unsigned int xcb_block_len = 0;
3354 unsigned int xcb_pad = 0;
3355 unsigned int xcb_align_to = 0;
3356
3357
3358 xcb_block_len += sizeof(xcb_render_create_linear_gradient_request_t);
3359 xcb_tmp += xcb_block_len;
3360 xcb_buffer_len += xcb_block_len;
3361 xcb_block_len = 0;
3362 /* stops */
3363 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
3364 xcb_tmp += xcb_block_len;
3365 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
3366 /* insert padding */
3367 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3368 xcb_buffer_len += xcb_block_len + xcb_pad;
3369 if (0 != xcb_pad) {
3370 xcb_tmp += xcb_pad;
3371 xcb_pad = 0;
3372 }
3373 xcb_block_len = 0;
3374 /* colors */
3375 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
3376 xcb_tmp += xcb_block_len;
3377 xcb_align_to = ALIGNOF(xcb_render_color_t);
3378 /* insert padding */
3379 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3380 xcb_buffer_len += xcb_block_len + xcb_pad;
3381 if (0 != xcb_pad) {
3382 xcb_tmp += xcb_pad;
3383 xcb_pad = 0;
3384 }
3385 xcb_block_len = 0;
3386
3387 return xcb_buffer_len;
3388 }
3389
3390 xcb_void_cookie_t
3391 xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */,
3392 xcb_render_picture_t picture /**< */,
3393 xcb_render_pointfix_t p1 /**< */,
3394 xcb_render_pointfix_t p2 /**< */,
3395 uint32_t num_stops /**< */,
3396 const xcb_render_fixed_t *stops /**< */,
3397 const xcb_render_color_t *colors /**< */)
3398 {
3399 static const xcb_protocol_request_t xcb_req = {
3400 /* count */ 6,
3401 /* ext */ &xcb_render_id,
3402 /* opcode */ XCB_RENDER_CREATE_LINEAR_GRADIENT,
3403 /* isvoid */ 1
3404 };
3405
3406 struct iovec xcb_parts[8];
3407 xcb_void_cookie_t xcb_ret;
3408 xcb_render_create_linear_gradient_request_t xcb_out;
3409
3410 xcb_out.picture = picture;
3411 xcb_out.p1 = p1;
3412 xcb_out.p2 = p2;
3413 xcb_out.num_stops = num_stops;
3414
3415 xcb_parts[2].iov_base = (char *) &xcb_out;
3416 xcb_parts[2].iov_len = sizeof(xcb_out);
3417 xcb_parts[3].iov_base = 0;
3418 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3419 /* xcb_render_fixed_t stops */
3420 xcb_parts[4].iov_base = (char *) stops;
3421 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3422 xcb_parts[5].iov_base = 0;
3423 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3424 /* xcb_render_color_t colors */
3425 xcb_parts[6].iov_base = (char *) colors;
3426 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3427 xcb_parts[7].iov_base = 0;
3428 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3429
3430 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3431 return xcb_ret;
3432 }
3433
3434 xcb_void_cookie_t
3435 xcb_render_create_linear_gradient (xcb_connection_t *c /**< */,
3436 xcb_render_picture_t picture /**< */,
3437 xcb_render_pointfix_t p1 /**< */,
3438 xcb_render_pointfix_t p2 /**< */,
3439 uint32_t num_stops /**< */,
3440 const xcb_render_fixed_t *stops /**< */,
3441 const xcb_render_color_t *colors /**< */)
3442 {
3443 static const xcb_protocol_request_t xcb_req = {
3444 /* count */ 6,
3445 /* ext */ &xcb_render_id,
3446 /* opcode */ XCB_RENDER_CREATE_LINEAR_GRADIENT,
3447 /* isvoid */ 1
3448 };
3449
3450 struct iovec xcb_parts[8];
3451 xcb_void_cookie_t xcb_ret;
3452 xcb_render_create_linear_gradient_request_t xcb_out;
3453
3454 xcb_out.picture = picture;
3455 xcb_out.p1 = p1;
3456 xcb_out.p2 = p2;
3457 xcb_out.num_stops = num_stops;
3458
3459 xcb_parts[2].iov_base = (char *) &xcb_out;
3460 xcb_parts[2].iov_len = sizeof(xcb_out);
3461 xcb_parts[3].iov_base = 0;
3462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3463 /* xcb_render_fixed_t stops */
3464 xcb_parts[4].iov_base = (char *) stops;
3465 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3466 xcb_parts[5].iov_base = 0;
3467 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3468 /* xcb_render_color_t colors */
3469 xcb_parts[6].iov_base = (char *) colors;
3470 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3471 xcb_parts[7].iov_base = 0;
3472 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3473
3474 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3475 return xcb_ret;
3476 }
3477
3478 int
3479 xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */)
3480 {
3481 char *xcb_tmp = (char *)_buffer;
3482 const xcb_render_create_radial_gradient_request_t *_aux = (xcb_render_create_radial_gradient_request_t *)_buffer;
3483 unsigned int xcb_buffer_len = 0;
3484 unsigned int xcb_block_len = 0;
3485 unsigned int xcb_pad = 0;
3486 unsigned int xcb_align_to = 0;
3487
3488
3489 xcb_block_len += sizeof(xcb_render_create_radial_gradient_request_t);
3490 xcb_tmp += xcb_block_len;
3491 xcb_buffer_len += xcb_block_len;
3492 xcb_block_len = 0;
3493 /* stops */
3494 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
3495 xcb_tmp += xcb_block_len;
3496 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
3497 /* insert padding */
3498 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3499 xcb_buffer_len += xcb_block_len + xcb_pad;
3500 if (0 != xcb_pad) {
3501 xcb_tmp += xcb_pad;
3502 xcb_pad = 0;
3503 }
3504 xcb_block_len = 0;
3505 /* colors */
3506 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
3507 xcb_tmp += xcb_block_len;
3508 xcb_align_to = ALIGNOF(xcb_render_color_t);
3509 /* insert padding */
3510 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3511 xcb_buffer_len += xcb_block_len + xcb_pad;
3512 if (0 != xcb_pad) {
3513 xcb_tmp += xcb_pad;
3514 xcb_pad = 0;
3515 }
3516 xcb_block_len = 0;
3517
3518 return xcb_buffer_len;
3519 }
3520
3521 xcb_void_cookie_t
3522 xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */,
3523 xcb_render_picture_t picture /**< */,
3524 xcb_render_pointfix_t inner /**< */,
3525 xcb_render_pointfix_t outer /**< */,
3526 xcb_render_fixed_t inner_radius /**< */,
3527 xcb_render_fixed_t outer_radius /**< */,
3528 uint32_t num_stops /**< */,
3529 const xcb_render_fixed_t *stops /**< */,
3530 const xcb_render_color_t *colors /**< */)
3531 {
3532 static const xcb_protocol_request_t xcb_req = {
3533 /* count */ 6,
3534 /* ext */ &xcb_render_id,
3535 /* opcode */ XCB_RENDER_CREATE_RADIAL_GRADIENT,
3536 /* isvoid */ 1
3537 };
3538
3539 struct iovec xcb_parts[8];
3540 xcb_void_cookie_t xcb_ret;
3541 xcb_render_create_radial_gradient_request_t xcb_out;
3542
3543 xcb_out.picture = picture;
3544 xcb_out.inner = inner;
3545 xcb_out.outer = outer;
3546 xcb_out.inner_radius = inner_radius;
3547 xcb_out.outer_radius = outer_radius;
3548 xcb_out.num_stops = num_stops;
3549
3550 xcb_parts[2].iov_base = (char *) &xcb_out;
3551 xcb_parts[2].iov_len = sizeof(xcb_out);
3552 xcb_parts[3].iov_base = 0;
3553 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3554 /* xcb_render_fixed_t stops */
3555 xcb_parts[4].iov_base = (char *) stops;
3556 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3557 xcb_parts[5].iov_base = 0;
3558 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3559 /* xcb_render_color_t colors */
3560 xcb_parts[6].iov_base = (char *) colors;
3561 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3562 xcb_parts[7].iov_base = 0;
3563 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3564
3565 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3566 return xcb_ret;
3567 }
3568
3569 xcb_void_cookie_t
3570 xcb_render_create_radial_gradient (xcb_connection_t *c /**< */,
3571 xcb_render_picture_t picture /**< */,
3572 xcb_render_pointfix_t inner /**< */,
3573 xcb_render_pointfix_t outer /**< */,
3574 xcb_render_fixed_t inner_radius /**< */,
3575 xcb_render_fixed_t outer_radius /**< */,
3576 uint32_t num_stops /**< */,
3577 const xcb_render_fixed_t *stops /**< */,
3578 const xcb_render_color_t *colors /**< */)
3579 {
3580 static const xcb_protocol_request_t xcb_req = {
3581 /* count */ 6,
3582 /* ext */ &xcb_render_id,
3583 /* opcode */ XCB_RENDER_CREATE_RADIAL_GRADIENT,
3584 /* isvoid */ 1
3585 };
3586
3587 struct iovec xcb_parts[8];
3588 xcb_void_cookie_t xcb_ret;
3589 xcb_render_create_radial_gradient_request_t xcb_out;
3590
3591 xcb_out.picture = picture;
3592 xcb_out.inner = inner;
3593 xcb_out.outer = outer;
3594 xcb_out.inner_radius = inner_radius;
3595 xcb_out.outer_radius = outer_radius;
3596 xcb_out.num_stops = num_stops;
3597
3598 xcb_parts[2].iov_base = (char *) &xcb_out;
3599 xcb_parts[2].iov_len = sizeof(xcb_out);
3600 xcb_parts[3].iov_base = 0;
3601 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3602 /* xcb_render_fixed_t stops */
3603 xcb_parts[4].iov_base = (char *) stops;
3604 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3605 xcb_parts[5].iov_base = 0;
3606 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3607 /* xcb_render_color_t colors */
3608 xcb_parts[6].iov_base = (char *) colors;
3609 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3610 xcb_parts[7].iov_base = 0;
3611 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3612
3613 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3614 return xcb_ret;
3615 }
3616
3617 int
3618 xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */)
3619 {
3620 char *xcb_tmp = (char *)_buffer;
3621 const xcb_render_create_conical_gradient_request_t *_aux = (xcb_render_create_conical_gradient_request_t *)_buffer;
3622 unsigned int xcb_buffer_len = 0;
3623 unsigned int xcb_block_len = 0;
3624 unsigned int xcb_pad = 0;
3625 unsigned int xcb_align_to = 0;
3626
3627
3628 xcb_block_len += sizeof(xcb_render_create_conical_gradient_request_t);
3629 xcb_tmp += xcb_block_len;
3630 xcb_buffer_len += xcb_block_len;
3631 xcb_block_len = 0;
3632 /* stops */
3633 xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
3634 xcb_tmp += xcb_block_len;
3635 xcb_align_to = ALIGNOF(xcb_render_fixed_t);
3636 /* insert padding */
3637 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3638 xcb_buffer_len += xcb_block_len + xcb_pad;
3639 if (0 != xcb_pad) {
3640 xcb_tmp += xcb_pad;
3641 xcb_pad = 0;
3642 }
3643 xcb_block_len = 0;
3644 /* colors */
3645 xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
3646 xcb_tmp += xcb_block_len;
3647 xcb_align_to = ALIGNOF(xcb_render_color_t);
3648 /* insert padding */
3649 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3650 xcb_buffer_len += xcb_block_len + xcb_pad;
3651 if (0 != xcb_pad) {
3652 xcb_tmp += xcb_pad;
3653 xcb_pad = 0;
3654 }
3655 xcb_block_len = 0;
3656
3657 return xcb_buffer_len;
3658 }
3659
3660 xcb_void_cookie_t
3661 xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */,
3662 xcb_render_picture_t picture /**< */,
3663 xcb_render_pointfix_t center /**< */,
3664 xcb_render_fixed_t angle /**< */,
3665 uint32_t num_stops /**< */,
3666 const xcb_render_fixed_t *stops /**< */,
3667 const xcb_render_color_t *colors /**< */)
3668 {
3669 static const xcb_protocol_request_t xcb_req = {
3670 /* count */ 6,
3671 /* ext */ &xcb_render_id,
3672 /* opcode */ XCB_RENDER_CREATE_CONICAL_GRADIENT,
3673 /* isvoid */ 1
3674 };
3675
3676 struct iovec xcb_parts[8];
3677 xcb_void_cookie_t xcb_ret;
3678 xcb_render_create_conical_gradient_request_t xcb_out;
3679
3680 xcb_out.picture = picture;
3681 xcb_out.center = center;
3682 xcb_out.angle = angle;
3683 xcb_out.num_stops = num_stops;
3684
3685 xcb_parts[2].iov_base = (char *) &xcb_out;
3686 xcb_parts[2].iov_len = sizeof(xcb_out);
3687 xcb_parts[3].iov_base = 0;
3688 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3689 /* xcb_render_fixed_t stops */
3690 xcb_parts[4].iov_base = (char *) stops;
3691 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3692 xcb_parts[5].iov_base = 0;
3693 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3694 /* xcb_render_color_t colors */
3695 xcb_parts[6].iov_base = (char *) colors;
3696 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3697 xcb_parts[7].iov_base = 0;
3698 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3699
3700 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3701 return xcb_ret;
3702 }
3703
3704 xcb_void_cookie_t
3705 xcb_render_create_conical_gradient (xcb_connection_t *c /**< */,
3706 xcb_render_picture_t picture /**< */,
3707 xcb_render_pointfix_t center /**< */,
3708 xcb_render_fixed_t angle /**< */,
3709 uint32_t num_stops /**< */,
3710 const xcb_render_fixed_t *stops /**< */,
3711 const xcb_render_color_t *colors /**< */)
3712 {
3713 static const xcb_protocol_request_t xcb_req = {
3714 /* count */ 6,
3715 /* ext */ &xcb_render_id,
3716 /* opcode */ XCB_RENDER_CREATE_CONICAL_GRADIENT,
3717 /* isvoid */ 1
3718 };
3719
3720 struct iovec xcb_parts[8];
3721 xcb_void_cookie_t xcb_ret;
3722 xcb_render_create_conical_gradient_request_t xcb_out;
3723
3724 xcb_out.picture = picture;
3725 xcb_out.center = center;
3726 xcb_out.angle = angle;
3727 xcb_out.num_stops = num_stops;
3728
3729 xcb_parts[2].iov_base = (char *) &xcb_out;
3730 xcb_parts[2].iov_len = sizeof(xcb_out);
3731 xcb_parts[3].iov_base = 0;
3732 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3733 /* xcb_render_fixed_t stops */
3734 xcb_parts[4].iov_base = (char *) stops;
3735 xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
3736 xcb_parts[5].iov_base = 0;
3737 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3738 /* xcb_render_color_t colors */
3739 xcb_parts[6].iov_base = (char *) colors;
3740 xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
3741 xcb_parts[7].iov_base = 0;
3742 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
3743
3744 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3745 return xcb_ret;
3746 }
3747
MINIX 3 (repo.or.cz mirror)