xref: /netbsd-src/external/mit/xorg/lib/libxcb/files/xproto.c (revision c201ebe368fc4b13732e29cfc99699e9060bdbf2)
1 /*
2  * This file generated automatically from xproto.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 "xproto.h"
15 
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 
18 void
xcb_char2b_next(xcb_char2b_iterator_t * i)19 xcb_char2b_next (xcb_char2b_iterator_t *i)
20 {
21     --i->rem;
22     ++i->data;
23     i->index += sizeof(xcb_char2b_t);
24 }
25 
26 xcb_generic_iterator_t
xcb_char2b_end(xcb_char2b_iterator_t i)27 xcb_char2b_end (xcb_char2b_iterator_t i)
28 {
29     xcb_generic_iterator_t ret;
30     ret.data = i.data + i.rem;
31     ret.index = i.index + ((char *) ret.data - (char *) i.data);
32     ret.rem = 0;
33     return ret;
34 }
35 
36 void
xcb_window_next(xcb_window_iterator_t * i)37 xcb_window_next (xcb_window_iterator_t *i)
38 {
39     --i->rem;
40     ++i->data;
41     i->index += sizeof(xcb_window_t);
42 }
43 
44 xcb_generic_iterator_t
xcb_window_end(xcb_window_iterator_t i)45 xcb_window_end (xcb_window_iterator_t i)
46 {
47     xcb_generic_iterator_t ret;
48     ret.data = i.data + i.rem;
49     ret.index = i.index + ((char *) ret.data - (char *) i.data);
50     ret.rem = 0;
51     return ret;
52 }
53 
54 void
xcb_pixmap_next(xcb_pixmap_iterator_t * i)55 xcb_pixmap_next (xcb_pixmap_iterator_t *i)
56 {
57     --i->rem;
58     ++i->data;
59     i->index += sizeof(xcb_pixmap_t);
60 }
61 
62 xcb_generic_iterator_t
xcb_pixmap_end(xcb_pixmap_iterator_t i)63 xcb_pixmap_end (xcb_pixmap_iterator_t i)
64 {
65     xcb_generic_iterator_t ret;
66     ret.data = i.data + i.rem;
67     ret.index = i.index + ((char *) ret.data - (char *) i.data);
68     ret.rem = 0;
69     return ret;
70 }
71 
72 void
xcb_cursor_next(xcb_cursor_iterator_t * i)73 xcb_cursor_next (xcb_cursor_iterator_t *i)
74 {
75     --i->rem;
76     ++i->data;
77     i->index += sizeof(xcb_cursor_t);
78 }
79 
80 xcb_generic_iterator_t
xcb_cursor_end(xcb_cursor_iterator_t i)81 xcb_cursor_end (xcb_cursor_iterator_t i)
82 {
83     xcb_generic_iterator_t ret;
84     ret.data = i.data + i.rem;
85     ret.index = i.index + ((char *) ret.data - (char *) i.data);
86     ret.rem = 0;
87     return ret;
88 }
89 
90 void
xcb_font_next(xcb_font_iterator_t * i)91 xcb_font_next (xcb_font_iterator_t *i)
92 {
93     --i->rem;
94     ++i->data;
95     i->index += sizeof(xcb_font_t);
96 }
97 
98 xcb_generic_iterator_t
xcb_font_end(xcb_font_iterator_t i)99 xcb_font_end (xcb_font_iterator_t i)
100 {
101     xcb_generic_iterator_t ret;
102     ret.data = i.data + i.rem;
103     ret.index = i.index + ((char *) ret.data - (char *) i.data);
104     ret.rem = 0;
105     return ret;
106 }
107 
108 void
xcb_gcontext_next(xcb_gcontext_iterator_t * i)109 xcb_gcontext_next (xcb_gcontext_iterator_t *i)
110 {
111     --i->rem;
112     ++i->data;
113     i->index += sizeof(xcb_gcontext_t);
114 }
115 
116 xcb_generic_iterator_t
xcb_gcontext_end(xcb_gcontext_iterator_t i)117 xcb_gcontext_end (xcb_gcontext_iterator_t i)
118 {
119     xcb_generic_iterator_t ret;
120     ret.data = i.data + i.rem;
121     ret.index = i.index + ((char *) ret.data - (char *) i.data);
122     ret.rem = 0;
123     return ret;
124 }
125 
126 void
xcb_colormap_next(xcb_colormap_iterator_t * i)127 xcb_colormap_next (xcb_colormap_iterator_t *i)
128 {
129     --i->rem;
130     ++i->data;
131     i->index += sizeof(xcb_colormap_t);
132 }
133 
134 xcb_generic_iterator_t
xcb_colormap_end(xcb_colormap_iterator_t i)135 xcb_colormap_end (xcb_colormap_iterator_t i)
136 {
137     xcb_generic_iterator_t ret;
138     ret.data = i.data + i.rem;
139     ret.index = i.index + ((char *) ret.data - (char *) i.data);
140     ret.rem = 0;
141     return ret;
142 }
143 
144 void
xcb_atom_next(xcb_atom_iterator_t * i)145 xcb_atom_next (xcb_atom_iterator_t *i)
146 {
147     --i->rem;
148     ++i->data;
149     i->index += sizeof(xcb_atom_t);
150 }
151 
152 xcb_generic_iterator_t
xcb_atom_end(xcb_atom_iterator_t i)153 xcb_atom_end (xcb_atom_iterator_t i)
154 {
155     xcb_generic_iterator_t ret;
156     ret.data = i.data + i.rem;
157     ret.index = i.index + ((char *) ret.data - (char *) i.data);
158     ret.rem = 0;
159     return ret;
160 }
161 
162 void
xcb_drawable_next(xcb_drawable_iterator_t * i)163 xcb_drawable_next (xcb_drawable_iterator_t *i)
164 {
165     --i->rem;
166     ++i->data;
167     i->index += sizeof(xcb_drawable_t);
168 }
169 
170 xcb_generic_iterator_t
xcb_drawable_end(xcb_drawable_iterator_t i)171 xcb_drawable_end (xcb_drawable_iterator_t i)
172 {
173     xcb_generic_iterator_t ret;
174     ret.data = i.data + i.rem;
175     ret.index = i.index + ((char *) ret.data - (char *) i.data);
176     ret.rem = 0;
177     return ret;
178 }
179 
180 void
xcb_fontable_next(xcb_fontable_iterator_t * i)181 xcb_fontable_next (xcb_fontable_iterator_t *i)
182 {
183     --i->rem;
184     ++i->data;
185     i->index += sizeof(xcb_fontable_t);
186 }
187 
188 xcb_generic_iterator_t
xcb_fontable_end(xcb_fontable_iterator_t i)189 xcb_fontable_end (xcb_fontable_iterator_t i)
190 {
191     xcb_generic_iterator_t ret;
192     ret.data = i.data + i.rem;
193     ret.index = i.index + ((char *) ret.data - (char *) i.data);
194     ret.rem = 0;
195     return ret;
196 }
197 
198 void
xcb_bool32_next(xcb_bool32_iterator_t * i)199 xcb_bool32_next (xcb_bool32_iterator_t *i)
200 {
201     --i->rem;
202     ++i->data;
203     i->index += sizeof(xcb_bool32_t);
204 }
205 
206 xcb_generic_iterator_t
xcb_bool32_end(xcb_bool32_iterator_t i)207 xcb_bool32_end (xcb_bool32_iterator_t i)
208 {
209     xcb_generic_iterator_t ret;
210     ret.data = i.data + i.rem;
211     ret.index = i.index + ((char *) ret.data - (char *) i.data);
212     ret.rem = 0;
213     return ret;
214 }
215 
216 void
xcb_visualid_next(xcb_visualid_iterator_t * i)217 xcb_visualid_next (xcb_visualid_iterator_t *i)
218 {
219     --i->rem;
220     ++i->data;
221     i->index += sizeof(xcb_visualid_t);
222 }
223 
224 xcb_generic_iterator_t
xcb_visualid_end(xcb_visualid_iterator_t i)225 xcb_visualid_end (xcb_visualid_iterator_t i)
226 {
227     xcb_generic_iterator_t ret;
228     ret.data = i.data + i.rem;
229     ret.index = i.index + ((char *) ret.data - (char *) i.data);
230     ret.rem = 0;
231     return ret;
232 }
233 
234 void
xcb_timestamp_next(xcb_timestamp_iterator_t * i)235 xcb_timestamp_next (xcb_timestamp_iterator_t *i)
236 {
237     --i->rem;
238     ++i->data;
239     i->index += sizeof(xcb_timestamp_t);
240 }
241 
242 xcb_generic_iterator_t
xcb_timestamp_end(xcb_timestamp_iterator_t i)243 xcb_timestamp_end (xcb_timestamp_iterator_t i)
244 {
245     xcb_generic_iterator_t ret;
246     ret.data = i.data + i.rem;
247     ret.index = i.index + ((char *) ret.data - (char *) i.data);
248     ret.rem = 0;
249     return ret;
250 }
251 
252 void
xcb_keysym_next(xcb_keysym_iterator_t * i)253 xcb_keysym_next (xcb_keysym_iterator_t *i)
254 {
255     --i->rem;
256     ++i->data;
257     i->index += sizeof(xcb_keysym_t);
258 }
259 
260 xcb_generic_iterator_t
xcb_keysym_end(xcb_keysym_iterator_t i)261 xcb_keysym_end (xcb_keysym_iterator_t i)
262 {
263     xcb_generic_iterator_t ret;
264     ret.data = i.data + i.rem;
265     ret.index = i.index + ((char *) ret.data - (char *) i.data);
266     ret.rem = 0;
267     return ret;
268 }
269 
270 void
xcb_keycode_next(xcb_keycode_iterator_t * i)271 xcb_keycode_next (xcb_keycode_iterator_t *i)
272 {
273     --i->rem;
274     ++i->data;
275     i->index += sizeof(xcb_keycode_t);
276 }
277 
278 xcb_generic_iterator_t
xcb_keycode_end(xcb_keycode_iterator_t i)279 xcb_keycode_end (xcb_keycode_iterator_t i)
280 {
281     xcb_generic_iterator_t ret;
282     ret.data = i.data + i.rem;
283     ret.index = i.index + ((char *) ret.data - (char *) i.data);
284     ret.rem = 0;
285     return ret;
286 }
287 
288 void
xcb_keycode32_next(xcb_keycode32_iterator_t * i)289 xcb_keycode32_next (xcb_keycode32_iterator_t *i)
290 {
291     --i->rem;
292     ++i->data;
293     i->index += sizeof(xcb_keycode32_t);
294 }
295 
296 xcb_generic_iterator_t
xcb_keycode32_end(xcb_keycode32_iterator_t i)297 xcb_keycode32_end (xcb_keycode32_iterator_t i)
298 {
299     xcb_generic_iterator_t ret;
300     ret.data = i.data + i.rem;
301     ret.index = i.index + ((char *) ret.data - (char *) i.data);
302     ret.rem = 0;
303     return ret;
304 }
305 
306 void
xcb_button_next(xcb_button_iterator_t * i)307 xcb_button_next (xcb_button_iterator_t *i)
308 {
309     --i->rem;
310     ++i->data;
311     i->index += sizeof(xcb_button_t);
312 }
313 
314 xcb_generic_iterator_t
xcb_button_end(xcb_button_iterator_t i)315 xcb_button_end (xcb_button_iterator_t i)
316 {
317     xcb_generic_iterator_t ret;
318     ret.data = i.data + i.rem;
319     ret.index = i.index + ((char *) ret.data - (char *) i.data);
320     ret.rem = 0;
321     return ret;
322 }
323 
324 void
xcb_point_next(xcb_point_iterator_t * i)325 xcb_point_next (xcb_point_iterator_t *i)
326 {
327     --i->rem;
328     ++i->data;
329     i->index += sizeof(xcb_point_t);
330 }
331 
332 xcb_generic_iterator_t
xcb_point_end(xcb_point_iterator_t i)333 xcb_point_end (xcb_point_iterator_t i)
334 {
335     xcb_generic_iterator_t ret;
336     ret.data = i.data + i.rem;
337     ret.index = i.index + ((char *) ret.data - (char *) i.data);
338     ret.rem = 0;
339     return ret;
340 }
341 
342 void
xcb_rectangle_next(xcb_rectangle_iterator_t * i)343 xcb_rectangle_next (xcb_rectangle_iterator_t *i)
344 {
345     --i->rem;
346     ++i->data;
347     i->index += sizeof(xcb_rectangle_t);
348 }
349 
350 xcb_generic_iterator_t
xcb_rectangle_end(xcb_rectangle_iterator_t i)351 xcb_rectangle_end (xcb_rectangle_iterator_t i)
352 {
353     xcb_generic_iterator_t ret;
354     ret.data = i.data + i.rem;
355     ret.index = i.index + ((char *) ret.data - (char *) i.data);
356     ret.rem = 0;
357     return ret;
358 }
359 
360 void
xcb_arc_next(xcb_arc_iterator_t * i)361 xcb_arc_next (xcb_arc_iterator_t *i)
362 {
363     --i->rem;
364     ++i->data;
365     i->index += sizeof(xcb_arc_t);
366 }
367 
368 xcb_generic_iterator_t
xcb_arc_end(xcb_arc_iterator_t i)369 xcb_arc_end (xcb_arc_iterator_t i)
370 {
371     xcb_generic_iterator_t ret;
372     ret.data = i.data + i.rem;
373     ret.index = i.index + ((char *) ret.data - (char *) i.data);
374     ret.rem = 0;
375     return ret;
376 }
377 
378 void
xcb_format_next(xcb_format_iterator_t * i)379 xcb_format_next (xcb_format_iterator_t *i)
380 {
381     --i->rem;
382     ++i->data;
383     i->index += sizeof(xcb_format_t);
384 }
385 
386 xcb_generic_iterator_t
xcb_format_end(xcb_format_iterator_t i)387 xcb_format_end (xcb_format_iterator_t i)
388 {
389     xcb_generic_iterator_t ret;
390     ret.data = i.data + i.rem;
391     ret.index = i.index + ((char *) ret.data - (char *) i.data);
392     ret.rem = 0;
393     return ret;
394 }
395 
396 void
xcb_visualtype_next(xcb_visualtype_iterator_t * i)397 xcb_visualtype_next (xcb_visualtype_iterator_t *i)
398 {
399     --i->rem;
400     ++i->data;
401     i->index += sizeof(xcb_visualtype_t);
402 }
403 
404 xcb_generic_iterator_t
xcb_visualtype_end(xcb_visualtype_iterator_t i)405 xcb_visualtype_end (xcb_visualtype_iterator_t i)
406 {
407     xcb_generic_iterator_t ret;
408     ret.data = i.data + i.rem;
409     ret.index = i.index + ((char *) ret.data - (char *) i.data);
410     ret.rem = 0;
411     return ret;
412 }
413 
414 int
xcb_depth_sizeof(const void * _buffer)415 xcb_depth_sizeof (const void  *_buffer)
416 {
417     char *xcb_tmp = (char *)_buffer;
418     const xcb_depth_t *_aux = (xcb_depth_t *)_buffer;
419     unsigned int xcb_buffer_len = 0;
420     unsigned int xcb_block_len = 0;
421     unsigned int xcb_pad = 0;
422     unsigned int xcb_align_to = 0;
423 
424 
425     xcb_block_len += sizeof(xcb_depth_t);
426     xcb_tmp += xcb_block_len;
427     xcb_buffer_len += xcb_block_len;
428     xcb_block_len = 0;
429     /* visuals */
430     xcb_block_len += _aux->visuals_len * sizeof(xcb_visualtype_t);
431     xcb_tmp += xcb_block_len;
432     xcb_align_to = ALIGNOF(xcb_visualtype_t);
433     /* insert padding */
434     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
435     xcb_buffer_len += xcb_block_len + xcb_pad;
436     if (0 != xcb_pad) {
437         xcb_tmp += xcb_pad;
438         xcb_pad = 0;
439     }
440     xcb_block_len = 0;
441 
442     return xcb_buffer_len;
443 }
444 
445 xcb_visualtype_t *
xcb_depth_visuals(const xcb_depth_t * R)446 xcb_depth_visuals (const xcb_depth_t *R)
447 {
448     return (xcb_visualtype_t *) (R + 1);
449 }
450 
451 int
xcb_depth_visuals_length(const xcb_depth_t * R)452 xcb_depth_visuals_length (const xcb_depth_t *R)
453 {
454     return R->visuals_len;
455 }
456 
457 xcb_visualtype_iterator_t
xcb_depth_visuals_iterator(const xcb_depth_t * R)458 xcb_depth_visuals_iterator (const xcb_depth_t *R)
459 {
460     xcb_visualtype_iterator_t i;
461     i.data = (xcb_visualtype_t *) (R + 1);
462     i.rem = R->visuals_len;
463     i.index = (char *) i.data - (char *) R;
464     return i;
465 }
466 
467 void
xcb_depth_next(xcb_depth_iterator_t * i)468 xcb_depth_next (xcb_depth_iterator_t *i)
469 {
470     xcb_depth_t *R = i->data;
471     xcb_generic_iterator_t child;
472     child.data = (xcb_depth_t *)(((char *)R) + xcb_depth_sizeof(R));
473     i->index = (char *) child.data - (char *) i->data;
474     --i->rem;
475     i->data = (xcb_depth_t *) child.data;
476 }
477 
478 xcb_generic_iterator_t
xcb_depth_end(xcb_depth_iterator_t i)479 xcb_depth_end (xcb_depth_iterator_t i)
480 {
481     xcb_generic_iterator_t ret;
482     while(i.rem > 0)
483         xcb_depth_next(&i);
484     ret.data = i.data;
485     ret.rem = i.rem;
486     ret.index = i.index;
487     return ret;
488 }
489 
490 int
xcb_screen_sizeof(const void * _buffer)491 xcb_screen_sizeof (const void  *_buffer)
492 {
493     char *xcb_tmp = (char *)_buffer;
494     const xcb_screen_t *_aux = (xcb_screen_t *)_buffer;
495     unsigned int xcb_buffer_len = 0;
496     unsigned int xcb_block_len = 0;
497     unsigned int xcb_pad = 0;
498     unsigned int xcb_align_to = 0;
499 
500     unsigned int i;
501     unsigned int xcb_tmp_len;
502 
503     xcb_block_len += sizeof(xcb_screen_t);
504     xcb_tmp += xcb_block_len;
505     xcb_buffer_len += xcb_block_len;
506     xcb_block_len = 0;
507     /* allowed_depths */
508     for(i=0; i<_aux->allowed_depths_len; i++) {
509         xcb_tmp_len = xcb_depth_sizeof(xcb_tmp);
510         xcb_block_len += xcb_tmp_len;
511         xcb_tmp += xcb_tmp_len;
512     }
513     xcb_align_to = ALIGNOF(xcb_depth_t);
514     /* insert padding */
515     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
516     xcb_buffer_len += xcb_block_len + xcb_pad;
517     if (0 != xcb_pad) {
518         xcb_tmp += xcb_pad;
519         xcb_pad = 0;
520     }
521     xcb_block_len = 0;
522 
523     return xcb_buffer_len;
524 }
525 
526 int
xcb_screen_allowed_depths_length(const xcb_screen_t * R)527 xcb_screen_allowed_depths_length (const xcb_screen_t *R)
528 {
529     return R->allowed_depths_len;
530 }
531 
532 xcb_depth_iterator_t
xcb_screen_allowed_depths_iterator(const xcb_screen_t * R)533 xcb_screen_allowed_depths_iterator (const xcb_screen_t *R)
534 {
535     xcb_depth_iterator_t i;
536     i.data = (xcb_depth_t *) (R + 1);
537     i.rem = R->allowed_depths_len;
538     i.index = (char *) i.data - (char *) R;
539     return i;
540 }
541 
542 void
xcb_screen_next(xcb_screen_iterator_t * i)543 xcb_screen_next (xcb_screen_iterator_t *i)
544 {
545     xcb_screen_t *R = i->data;
546     xcb_generic_iterator_t child;
547     child.data = (xcb_screen_t *)(((char *)R) + xcb_screen_sizeof(R));
548     i->index = (char *) child.data - (char *) i->data;
549     --i->rem;
550     i->data = (xcb_screen_t *) child.data;
551 }
552 
553 xcb_generic_iterator_t
xcb_screen_end(xcb_screen_iterator_t i)554 xcb_screen_end (xcb_screen_iterator_t i)
555 {
556     xcb_generic_iterator_t ret;
557     while(i.rem > 0)
558         xcb_screen_next(&i);
559     ret.data = i.data;
560     ret.rem = i.rem;
561     ret.index = i.index;
562     return ret;
563 }
564 
565 int
xcb_setup_request_sizeof(const void * _buffer)566 xcb_setup_request_sizeof (const void  *_buffer)
567 {
568     char *xcb_tmp = (char *)_buffer;
569     const xcb_setup_request_t *_aux = (xcb_setup_request_t *)_buffer;
570     unsigned int xcb_buffer_len = 0;
571     unsigned int xcb_block_len = 0;
572     unsigned int xcb_pad = 0;
573     unsigned int xcb_align_to = 0;
574 
575 
576     xcb_block_len += sizeof(xcb_setup_request_t);
577     xcb_tmp += xcb_block_len;
578     xcb_buffer_len += xcb_block_len;
579     xcb_block_len = 0;
580     /* authorization_protocol_name */
581     xcb_block_len += _aux->authorization_protocol_name_len * sizeof(char);
582     xcb_tmp += xcb_block_len;
583     xcb_align_to = ALIGNOF(char);
584     xcb_align_to = 4;
585     /* insert padding */
586     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
587     xcb_buffer_len += xcb_block_len + xcb_pad;
588     if (0 != xcb_pad) {
589         xcb_tmp += xcb_pad;
590         xcb_pad = 0;
591     }
592     xcb_block_len = 0;
593     /* insert padding */
594     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
595     xcb_buffer_len += xcb_block_len + xcb_pad;
596     if (0 != xcb_pad) {
597         xcb_tmp += xcb_pad;
598         xcb_pad = 0;
599     }
600     xcb_block_len = 0;
601     /* authorization_protocol_data */
602     xcb_block_len += _aux->authorization_protocol_data_len * sizeof(char);
603     xcb_tmp += xcb_block_len;
604     xcb_align_to = ALIGNOF(char);
605     xcb_align_to = 4;
606     /* insert padding */
607     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
608     xcb_buffer_len += xcb_block_len + xcb_pad;
609     if (0 != xcb_pad) {
610         xcb_tmp += xcb_pad;
611         xcb_pad = 0;
612     }
613     xcb_block_len = 0;
614     /* insert padding */
615     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
616     xcb_buffer_len += xcb_block_len + xcb_pad;
617     if (0 != xcb_pad) {
618         xcb_tmp += xcb_pad;
619         xcb_pad = 0;
620     }
621     xcb_block_len = 0;
622 
623     return xcb_buffer_len;
624 }
625 
626 char *
xcb_setup_request_authorization_protocol_name(const xcb_setup_request_t * R)627 xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R)
628 {
629     return (char *) (R + 1);
630 }
631 
632 int
xcb_setup_request_authorization_protocol_name_length(const xcb_setup_request_t * R)633 xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R)
634 {
635     return R->authorization_protocol_name_len;
636 }
637 
638 xcb_generic_iterator_t
xcb_setup_request_authorization_protocol_name_end(const xcb_setup_request_t * R)639 xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R)
640 {
641     xcb_generic_iterator_t i;
642     i.data = ((char *) (R + 1)) + (R->authorization_protocol_name_len);
643     i.rem = 0;
644     i.index = (char *) i.data - (char *) R;
645     return i;
646 }
647 
648 char *
xcb_setup_request_authorization_protocol_data(const xcb_setup_request_t * R)649 xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R)
650 {
651     xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R);
652     return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
653 }
654 
655 int
xcb_setup_request_authorization_protocol_data_length(const xcb_setup_request_t * R)656 xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R)
657 {
658     return R->authorization_protocol_data_len;
659 }
660 
661 xcb_generic_iterator_t
xcb_setup_request_authorization_protocol_data_end(const xcb_setup_request_t * R)662 xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R)
663 {
664     xcb_generic_iterator_t i;
665     xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R);
666     i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->authorization_protocol_data_len);
667     i.rem = 0;
668     i.index = (char *) i.data - (char *) R;
669     return i;
670 }
671 
672 void
xcb_setup_request_next(xcb_setup_request_iterator_t * i)673 xcb_setup_request_next (xcb_setup_request_iterator_t *i)
674 {
675     xcb_setup_request_t *R = i->data;
676     xcb_generic_iterator_t child;
677     child.data = (xcb_setup_request_t *)(((char *)R) + xcb_setup_request_sizeof(R));
678     i->index = (char *) child.data - (char *) i->data;
679     --i->rem;
680     i->data = (xcb_setup_request_t *) child.data;
681 }
682 
683 xcb_generic_iterator_t
xcb_setup_request_end(xcb_setup_request_iterator_t i)684 xcb_setup_request_end (xcb_setup_request_iterator_t i)
685 {
686     xcb_generic_iterator_t ret;
687     while(i.rem > 0)
688         xcb_setup_request_next(&i);
689     ret.data = i.data;
690     ret.rem = i.rem;
691     ret.index = i.index;
692     return ret;
693 }
694 
695 int
xcb_setup_failed_sizeof(const void * _buffer)696 xcb_setup_failed_sizeof (const void  *_buffer)
697 {
698     char *xcb_tmp = (char *)_buffer;
699     const xcb_setup_failed_t *_aux = (xcb_setup_failed_t *)_buffer;
700     unsigned int xcb_buffer_len = 0;
701     unsigned int xcb_block_len = 0;
702     unsigned int xcb_pad = 0;
703     unsigned int xcb_align_to = 0;
704 
705 
706     xcb_block_len += sizeof(xcb_setup_failed_t);
707     xcb_tmp += xcb_block_len;
708     xcb_buffer_len += xcb_block_len;
709     xcb_block_len = 0;
710     /* reason */
711     xcb_block_len += _aux->reason_len * sizeof(char);
712     xcb_tmp += xcb_block_len;
713     xcb_align_to = ALIGNOF(char);
714     /* insert padding */
715     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
716     xcb_buffer_len += xcb_block_len + xcb_pad;
717     if (0 != xcb_pad) {
718         xcb_tmp += xcb_pad;
719         xcb_pad = 0;
720     }
721     xcb_block_len = 0;
722 
723     return xcb_buffer_len;
724 }
725 
726 char *
xcb_setup_failed_reason(const xcb_setup_failed_t * R)727 xcb_setup_failed_reason (const xcb_setup_failed_t *R)
728 {
729     return (char *) (R + 1);
730 }
731 
732 int
xcb_setup_failed_reason_length(const xcb_setup_failed_t * R)733 xcb_setup_failed_reason_length (const xcb_setup_failed_t *R)
734 {
735     return R->reason_len;
736 }
737 
738 xcb_generic_iterator_t
xcb_setup_failed_reason_end(const xcb_setup_failed_t * R)739 xcb_setup_failed_reason_end (const xcb_setup_failed_t *R)
740 {
741     xcb_generic_iterator_t i;
742     i.data = ((char *) (R + 1)) + (R->reason_len);
743     i.rem = 0;
744     i.index = (char *) i.data - (char *) R;
745     return i;
746 }
747 
748 void
xcb_setup_failed_next(xcb_setup_failed_iterator_t * i)749 xcb_setup_failed_next (xcb_setup_failed_iterator_t *i)
750 {
751     xcb_setup_failed_t *R = i->data;
752     xcb_generic_iterator_t child;
753     child.data = (xcb_setup_failed_t *)(((char *)R) + xcb_setup_failed_sizeof(R));
754     i->index = (char *) child.data - (char *) i->data;
755     --i->rem;
756     i->data = (xcb_setup_failed_t *) child.data;
757 }
758 
759 xcb_generic_iterator_t
xcb_setup_failed_end(xcb_setup_failed_iterator_t i)760 xcb_setup_failed_end (xcb_setup_failed_iterator_t i)
761 {
762     xcb_generic_iterator_t ret;
763     while(i.rem > 0)
764         xcb_setup_failed_next(&i);
765     ret.data = i.data;
766     ret.rem = i.rem;
767     ret.index = i.index;
768     return ret;
769 }
770 
771 int
xcb_setup_authenticate_sizeof(const void * _buffer)772 xcb_setup_authenticate_sizeof (const void  *_buffer)
773 {
774     char *xcb_tmp = (char *)_buffer;
775     const xcb_setup_authenticate_t *_aux = (xcb_setup_authenticate_t *)_buffer;
776     unsigned int xcb_buffer_len = 0;
777     unsigned int xcb_block_len = 0;
778     unsigned int xcb_pad = 0;
779     unsigned int xcb_align_to = 0;
780 
781 
782     xcb_block_len += sizeof(xcb_setup_authenticate_t);
783     xcb_tmp += xcb_block_len;
784     xcb_buffer_len += xcb_block_len;
785     xcb_block_len = 0;
786     /* reason */
787     xcb_block_len += (_aux->length * 4) * sizeof(char);
788     xcb_tmp += xcb_block_len;
789     xcb_align_to = ALIGNOF(char);
790     /* insert padding */
791     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
792     xcb_buffer_len += xcb_block_len + xcb_pad;
793     if (0 != xcb_pad) {
794         xcb_tmp += xcb_pad;
795         xcb_pad = 0;
796     }
797     xcb_block_len = 0;
798 
799     return xcb_buffer_len;
800 }
801 
802 char *
xcb_setup_authenticate_reason(const xcb_setup_authenticate_t * R)803 xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R)
804 {
805     return (char *) (R + 1);
806 }
807 
808 int
xcb_setup_authenticate_reason_length(const xcb_setup_authenticate_t * R)809 xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R)
810 {
811     return (R->length * 4);
812 }
813 
814 xcb_generic_iterator_t
xcb_setup_authenticate_reason_end(const xcb_setup_authenticate_t * R)815 xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R)
816 {
817     xcb_generic_iterator_t i;
818     i.data = ((char *) (R + 1)) + ((R->length * 4));
819     i.rem = 0;
820     i.index = (char *) i.data - (char *) R;
821     return i;
822 }
823 
824 void
xcb_setup_authenticate_next(xcb_setup_authenticate_iterator_t * i)825 xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i)
826 {
827     xcb_setup_authenticate_t *R = i->data;
828     xcb_generic_iterator_t child;
829     child.data = (xcb_setup_authenticate_t *)(((char *)R) + xcb_setup_authenticate_sizeof(R));
830     i->index = (char *) child.data - (char *) i->data;
831     --i->rem;
832     i->data = (xcb_setup_authenticate_t *) child.data;
833 }
834 
835 xcb_generic_iterator_t
xcb_setup_authenticate_end(xcb_setup_authenticate_iterator_t i)836 xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i)
837 {
838     xcb_generic_iterator_t ret;
839     while(i.rem > 0)
840         xcb_setup_authenticate_next(&i);
841     ret.data = i.data;
842     ret.rem = i.rem;
843     ret.index = i.index;
844     return ret;
845 }
846 
847 int
xcb_setup_sizeof(const void * _buffer)848 xcb_setup_sizeof (const void  *_buffer)
849 {
850     char *xcb_tmp = (char *)_buffer;
851     const xcb_setup_t *_aux = (xcb_setup_t *)_buffer;
852     unsigned int xcb_buffer_len = 0;
853     unsigned int xcb_block_len = 0;
854     unsigned int xcb_pad = 0;
855     unsigned int xcb_align_to = 0;
856 
857     unsigned int i;
858     unsigned int xcb_tmp_len;
859 
860     xcb_block_len += sizeof(xcb_setup_t);
861     xcb_tmp += xcb_block_len;
862     xcb_buffer_len += xcb_block_len;
863     xcb_block_len = 0;
864     /* vendor */
865     xcb_block_len += _aux->vendor_len * sizeof(char);
866     xcb_tmp += xcb_block_len;
867     xcb_align_to = ALIGNOF(char);
868     xcb_align_to = 4;
869     /* insert padding */
870     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
871     xcb_buffer_len += xcb_block_len + xcb_pad;
872     if (0 != xcb_pad) {
873         xcb_tmp += xcb_pad;
874         xcb_pad = 0;
875     }
876     xcb_block_len = 0;
877     /* insert padding */
878     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
879     xcb_buffer_len += xcb_block_len + xcb_pad;
880     if (0 != xcb_pad) {
881         xcb_tmp += xcb_pad;
882         xcb_pad = 0;
883     }
884     xcb_block_len = 0;
885     /* pixmap_formats */
886     xcb_block_len += _aux->pixmap_formats_len * sizeof(xcb_format_t);
887     xcb_tmp += xcb_block_len;
888     xcb_align_to = ALIGNOF(xcb_format_t);
889     /* insert padding */
890     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
891     xcb_buffer_len += xcb_block_len + xcb_pad;
892     if (0 != xcb_pad) {
893         xcb_tmp += xcb_pad;
894         xcb_pad = 0;
895     }
896     xcb_block_len = 0;
897     /* roots */
898     for(i=0; i<_aux->roots_len; i++) {
899         xcb_tmp_len = xcb_screen_sizeof(xcb_tmp);
900         xcb_block_len += xcb_tmp_len;
901         xcb_tmp += xcb_tmp_len;
902     }
903     xcb_align_to = ALIGNOF(xcb_screen_t);
904     /* insert padding */
905     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
906     xcb_buffer_len += xcb_block_len + xcb_pad;
907     if (0 != xcb_pad) {
908         xcb_tmp += xcb_pad;
909         xcb_pad = 0;
910     }
911     xcb_block_len = 0;
912 
913     return xcb_buffer_len;
914 }
915 
916 char *
xcb_setup_vendor(const xcb_setup_t * R)917 xcb_setup_vendor (const xcb_setup_t *R)
918 {
919     return (char *) (R + 1);
920 }
921 
922 int
xcb_setup_vendor_length(const xcb_setup_t * R)923 xcb_setup_vendor_length (const xcb_setup_t *R)
924 {
925     return R->vendor_len;
926 }
927 
928 xcb_generic_iterator_t
xcb_setup_vendor_end(const xcb_setup_t * R)929 xcb_setup_vendor_end (const xcb_setup_t *R)
930 {
931     xcb_generic_iterator_t i;
932     i.data = ((char *) (R + 1)) + (R->vendor_len);
933     i.rem = 0;
934     i.index = (char *) i.data - (char *) R;
935     return i;
936 }
937 
938 xcb_format_t *
xcb_setup_pixmap_formats(const xcb_setup_t * R)939 xcb_setup_pixmap_formats (const xcb_setup_t *R)
940 {
941     xcb_generic_iterator_t prev = xcb_setup_vendor_end(R);
942     return (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
943 }
944 
945 int
xcb_setup_pixmap_formats_length(const xcb_setup_t * R)946 xcb_setup_pixmap_formats_length (const xcb_setup_t *R)
947 {
948     return R->pixmap_formats_len;
949 }
950 
951 xcb_format_iterator_t
xcb_setup_pixmap_formats_iterator(const xcb_setup_t * R)952 xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R)
953 {
954     xcb_format_iterator_t i;
955     xcb_generic_iterator_t prev = xcb_setup_vendor_end(R);
956     i.data = (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
957     i.rem = R->pixmap_formats_len;
958     i.index = (char *) i.data - (char *) R;
959     return i;
960 }
961 
962 int
xcb_setup_roots_length(const xcb_setup_t * R)963 xcb_setup_roots_length (const xcb_setup_t *R)
964 {
965     return R->roots_len;
966 }
967 
968 xcb_screen_iterator_t
xcb_setup_roots_iterator(const xcb_setup_t * R)969 xcb_setup_roots_iterator (const xcb_setup_t *R)
970 {
971     xcb_screen_iterator_t i;
972     xcb_generic_iterator_t prev = xcb_format_end(xcb_setup_pixmap_formats_iterator(R));
973     i.data = (xcb_screen_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_screen_t, prev.index));
974     i.rem = R->roots_len;
975     i.index = (char *) i.data - (char *) R;
976     return i;
977 }
978 
979 void
xcb_setup_next(xcb_setup_iterator_t * i)980 xcb_setup_next (xcb_setup_iterator_t *i)
981 {
982     xcb_setup_t *R = i->data;
983     xcb_generic_iterator_t child;
984     child.data = (xcb_setup_t *)(((char *)R) + xcb_setup_sizeof(R));
985     i->index = (char *) child.data - (char *) i->data;
986     --i->rem;
987     i->data = (xcb_setup_t *) child.data;
988 }
989 
990 xcb_generic_iterator_t
xcb_setup_end(xcb_setup_iterator_t i)991 xcb_setup_end (xcb_setup_iterator_t i)
992 {
993     xcb_generic_iterator_t ret;
994     while(i.rem > 0)
995         xcb_setup_next(&i);
996     ret.data = i.data;
997     ret.rem = i.rem;
998     ret.index = i.index;
999     return ret;
1000 }
1001 
1002 void
xcb_client_message_data_next(xcb_client_message_data_iterator_t * i)1003 xcb_client_message_data_next (xcb_client_message_data_iterator_t *i)
1004 {
1005     --i->rem;
1006     ++i->data;
1007     i->index += sizeof(xcb_client_message_data_t);
1008 }
1009 
1010 xcb_generic_iterator_t
xcb_client_message_data_end(xcb_client_message_data_iterator_t i)1011 xcb_client_message_data_end (xcb_client_message_data_iterator_t i)
1012 {
1013     xcb_generic_iterator_t ret;
1014     ret.data = i.data + i.rem;
1015     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1016     ret.rem = 0;
1017     return ret;
1018 }
1019 
1020 int
xcb_create_window_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_create_window_value_list_t * _aux)1021 xcb_create_window_value_list_serialize (void                                 **_buffer,
1022                                         uint32_t                               value_mask,
1023                                         const xcb_create_window_value_list_t  *_aux)
1024 {
1025     char *xcb_out = *_buffer;
1026     unsigned int xcb_buffer_len = 0;
1027     unsigned int xcb_align_to = 0;
1028     unsigned int xcb_padding_offset = 0;
1029 
1030     unsigned int xcb_pad = 0;
1031     char xcb_pad0[3] = {0, 0, 0};
1032     struct iovec xcb_parts[16];
1033     unsigned int xcb_parts_idx = 0;
1034     unsigned int xcb_block_len = 0;
1035     unsigned int i;
1036     char *xcb_tmp;
1037 
1038     if(value_mask & XCB_CW_BACK_PIXMAP) {
1039         /* xcb_create_window_value_list_t.background_pixmap */
1040         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap;
1041         xcb_block_len += sizeof(xcb_pixmap_t);
1042         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
1043         xcb_parts_idx++;
1044         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1045     }
1046     if(value_mask & XCB_CW_BACK_PIXEL) {
1047         /* xcb_create_window_value_list_t.background_pixel */
1048         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel;
1049         xcb_block_len += sizeof(uint32_t);
1050         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1051         xcb_parts_idx++;
1052         xcb_align_to = ALIGNOF(uint32_t);
1053     }
1054     if(value_mask & XCB_CW_BORDER_PIXMAP) {
1055         /* xcb_create_window_value_list_t.border_pixmap */
1056         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap;
1057         xcb_block_len += sizeof(xcb_pixmap_t);
1058         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
1059         xcb_parts_idx++;
1060         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1061     }
1062     if(value_mask & XCB_CW_BORDER_PIXEL) {
1063         /* xcb_create_window_value_list_t.border_pixel */
1064         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel;
1065         xcb_block_len += sizeof(uint32_t);
1066         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1067         xcb_parts_idx++;
1068         xcb_align_to = ALIGNOF(uint32_t);
1069     }
1070     if(value_mask & XCB_CW_BIT_GRAVITY) {
1071         /* xcb_create_window_value_list_t.bit_gravity */
1072         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity;
1073         xcb_block_len += sizeof(uint32_t);
1074         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1075         xcb_parts_idx++;
1076         xcb_align_to = ALIGNOF(uint32_t);
1077     }
1078     if(value_mask & XCB_CW_WIN_GRAVITY) {
1079         /* xcb_create_window_value_list_t.win_gravity */
1080         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity;
1081         xcb_block_len += sizeof(uint32_t);
1082         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1083         xcb_parts_idx++;
1084         xcb_align_to = ALIGNOF(uint32_t);
1085     }
1086     if(value_mask & XCB_CW_BACKING_STORE) {
1087         /* xcb_create_window_value_list_t.backing_store */
1088         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store;
1089         xcb_block_len += sizeof(uint32_t);
1090         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1091         xcb_parts_idx++;
1092         xcb_align_to = ALIGNOF(uint32_t);
1093     }
1094     if(value_mask & XCB_CW_BACKING_PLANES) {
1095         /* xcb_create_window_value_list_t.backing_planes */
1096         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes;
1097         xcb_block_len += sizeof(uint32_t);
1098         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1099         xcb_parts_idx++;
1100         xcb_align_to = ALIGNOF(uint32_t);
1101     }
1102     if(value_mask & XCB_CW_BACKING_PIXEL) {
1103         /* xcb_create_window_value_list_t.backing_pixel */
1104         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel;
1105         xcb_block_len += sizeof(uint32_t);
1106         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1107         xcb_parts_idx++;
1108         xcb_align_to = ALIGNOF(uint32_t);
1109     }
1110     if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
1111         /* xcb_create_window_value_list_t.override_redirect */
1112         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect;
1113         xcb_block_len += sizeof(xcb_bool32_t);
1114         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
1115         xcb_parts_idx++;
1116         xcb_align_to = ALIGNOF(xcb_bool32_t);
1117     }
1118     if(value_mask & XCB_CW_SAVE_UNDER) {
1119         /* xcb_create_window_value_list_t.save_under */
1120         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under;
1121         xcb_block_len += sizeof(xcb_bool32_t);
1122         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
1123         xcb_parts_idx++;
1124         xcb_align_to = ALIGNOF(xcb_bool32_t);
1125     }
1126     if(value_mask & XCB_CW_EVENT_MASK) {
1127         /* xcb_create_window_value_list_t.event_mask */
1128         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask;
1129         xcb_block_len += sizeof(uint32_t);
1130         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1131         xcb_parts_idx++;
1132         xcb_align_to = ALIGNOF(uint32_t);
1133     }
1134     if(value_mask & XCB_CW_DONT_PROPAGATE) {
1135         /* xcb_create_window_value_list_t.do_not_propogate_mask */
1136         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask;
1137         xcb_block_len += sizeof(uint32_t);
1138         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1139         xcb_parts_idx++;
1140         xcb_align_to = ALIGNOF(uint32_t);
1141     }
1142     if(value_mask & XCB_CW_COLORMAP) {
1143         /* xcb_create_window_value_list_t.colormap */
1144         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap;
1145         xcb_block_len += sizeof(xcb_colormap_t);
1146         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t);
1147         xcb_parts_idx++;
1148         xcb_align_to = ALIGNOF(xcb_colormap_t);
1149     }
1150     if(value_mask & XCB_CW_CURSOR) {
1151         /* xcb_create_window_value_list_t.cursor */
1152         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor;
1153         xcb_block_len += sizeof(xcb_cursor_t);
1154         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t);
1155         xcb_parts_idx++;
1156         xcb_align_to = ALIGNOF(xcb_cursor_t);
1157     }
1158     /* insert padding */
1159     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1160     xcb_buffer_len += xcb_block_len + xcb_pad;
1161     if (0 != xcb_pad) {
1162         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
1163         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
1164         xcb_parts_idx++;
1165         xcb_pad = 0;
1166     }
1167     xcb_block_len = 0;
1168     xcb_padding_offset = 0;
1169 
1170     if (NULL == xcb_out) {
1171         /* allocate memory */
1172         xcb_out = malloc(xcb_buffer_len);
1173         *_buffer = xcb_out;
1174     }
1175 
1176     xcb_tmp = xcb_out;
1177     for(i=0; i<xcb_parts_idx; i++) {
1178         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
1179             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
1180         if (0 != xcb_parts[i].iov_len)
1181             xcb_tmp += xcb_parts[i].iov_len;
1182     }
1183 
1184     return xcb_buffer_len;
1185 }
1186 
1187 int
xcb_create_window_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_create_window_value_list_t * _aux)1188 xcb_create_window_value_list_unpack (const void                      *_buffer,
1189                                      uint32_t                         value_mask,
1190                                      xcb_create_window_value_list_t  *_aux)
1191 {
1192     char *xcb_tmp = (char *)_buffer;
1193     unsigned int xcb_buffer_len = 0;
1194     unsigned int xcb_block_len = 0;
1195     unsigned int xcb_pad = 0;
1196     unsigned int xcb_align_to = 0;
1197     unsigned int xcb_padding_offset = 0;
1198 
1199 
1200     if(value_mask & XCB_CW_BACK_PIXMAP) {
1201         /* xcb_create_window_value_list_t.background_pixmap */
1202         _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp;
1203         xcb_block_len += sizeof(xcb_pixmap_t);
1204         xcb_tmp += sizeof(xcb_pixmap_t);
1205         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1206     }
1207     if(value_mask & XCB_CW_BACK_PIXEL) {
1208         /* xcb_create_window_value_list_t.background_pixel */
1209         _aux->background_pixel = *(uint32_t *)xcb_tmp;
1210         xcb_block_len += sizeof(uint32_t);
1211         xcb_tmp += sizeof(uint32_t);
1212         xcb_align_to = ALIGNOF(uint32_t);
1213     }
1214     if(value_mask & XCB_CW_BORDER_PIXMAP) {
1215         /* xcb_create_window_value_list_t.border_pixmap */
1216         _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp;
1217         xcb_block_len += sizeof(xcb_pixmap_t);
1218         xcb_tmp += sizeof(xcb_pixmap_t);
1219         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1220     }
1221     if(value_mask & XCB_CW_BORDER_PIXEL) {
1222         /* xcb_create_window_value_list_t.border_pixel */
1223         _aux->border_pixel = *(uint32_t *)xcb_tmp;
1224         xcb_block_len += sizeof(uint32_t);
1225         xcb_tmp += sizeof(uint32_t);
1226         xcb_align_to = ALIGNOF(uint32_t);
1227     }
1228     if(value_mask & XCB_CW_BIT_GRAVITY) {
1229         /* xcb_create_window_value_list_t.bit_gravity */
1230         _aux->bit_gravity = *(uint32_t *)xcb_tmp;
1231         xcb_block_len += sizeof(uint32_t);
1232         xcb_tmp += sizeof(uint32_t);
1233         xcb_align_to = ALIGNOF(uint32_t);
1234     }
1235     if(value_mask & XCB_CW_WIN_GRAVITY) {
1236         /* xcb_create_window_value_list_t.win_gravity */
1237         _aux->win_gravity = *(uint32_t *)xcb_tmp;
1238         xcb_block_len += sizeof(uint32_t);
1239         xcb_tmp += sizeof(uint32_t);
1240         xcb_align_to = ALIGNOF(uint32_t);
1241     }
1242     if(value_mask & XCB_CW_BACKING_STORE) {
1243         /* xcb_create_window_value_list_t.backing_store */
1244         _aux->backing_store = *(uint32_t *)xcb_tmp;
1245         xcb_block_len += sizeof(uint32_t);
1246         xcb_tmp += sizeof(uint32_t);
1247         xcb_align_to = ALIGNOF(uint32_t);
1248     }
1249     if(value_mask & XCB_CW_BACKING_PLANES) {
1250         /* xcb_create_window_value_list_t.backing_planes */
1251         _aux->backing_planes = *(uint32_t *)xcb_tmp;
1252         xcb_block_len += sizeof(uint32_t);
1253         xcb_tmp += sizeof(uint32_t);
1254         xcb_align_to = ALIGNOF(uint32_t);
1255     }
1256     if(value_mask & XCB_CW_BACKING_PIXEL) {
1257         /* xcb_create_window_value_list_t.backing_pixel */
1258         _aux->backing_pixel = *(uint32_t *)xcb_tmp;
1259         xcb_block_len += sizeof(uint32_t);
1260         xcb_tmp += sizeof(uint32_t);
1261         xcb_align_to = ALIGNOF(uint32_t);
1262     }
1263     if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
1264         /* xcb_create_window_value_list_t.override_redirect */
1265         _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp;
1266         xcb_block_len += sizeof(xcb_bool32_t);
1267         xcb_tmp += sizeof(xcb_bool32_t);
1268         xcb_align_to = ALIGNOF(xcb_bool32_t);
1269     }
1270     if(value_mask & XCB_CW_SAVE_UNDER) {
1271         /* xcb_create_window_value_list_t.save_under */
1272         _aux->save_under = *(xcb_bool32_t *)xcb_tmp;
1273         xcb_block_len += sizeof(xcb_bool32_t);
1274         xcb_tmp += sizeof(xcb_bool32_t);
1275         xcb_align_to = ALIGNOF(xcb_bool32_t);
1276     }
1277     if(value_mask & XCB_CW_EVENT_MASK) {
1278         /* xcb_create_window_value_list_t.event_mask */
1279         _aux->event_mask = *(uint32_t *)xcb_tmp;
1280         xcb_block_len += sizeof(uint32_t);
1281         xcb_tmp += sizeof(uint32_t);
1282         xcb_align_to = ALIGNOF(uint32_t);
1283     }
1284     if(value_mask & XCB_CW_DONT_PROPAGATE) {
1285         /* xcb_create_window_value_list_t.do_not_propogate_mask */
1286         _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp;
1287         xcb_block_len += sizeof(uint32_t);
1288         xcb_tmp += sizeof(uint32_t);
1289         xcb_align_to = ALIGNOF(uint32_t);
1290     }
1291     if(value_mask & XCB_CW_COLORMAP) {
1292         /* xcb_create_window_value_list_t.colormap */
1293         _aux->colormap = *(xcb_colormap_t *)xcb_tmp;
1294         xcb_block_len += sizeof(xcb_colormap_t);
1295         xcb_tmp += sizeof(xcb_colormap_t);
1296         xcb_align_to = ALIGNOF(xcb_colormap_t);
1297     }
1298     if(value_mask & XCB_CW_CURSOR) {
1299         /* xcb_create_window_value_list_t.cursor */
1300         _aux->cursor = *(xcb_cursor_t *)xcb_tmp;
1301         xcb_block_len += sizeof(xcb_cursor_t);
1302         xcb_tmp += sizeof(xcb_cursor_t);
1303         xcb_align_to = ALIGNOF(xcb_cursor_t);
1304     }
1305     /* insert padding */
1306     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1307     xcb_buffer_len += xcb_block_len + xcb_pad;
1308     if (0 != xcb_pad) {
1309         xcb_tmp += xcb_pad;
1310         xcb_pad = 0;
1311     }
1312     xcb_block_len = 0;
1313     xcb_padding_offset = 0;
1314 
1315     return xcb_buffer_len;
1316 }
1317 
1318 int
xcb_create_window_value_list_sizeof(const void * _buffer,uint32_t value_mask)1319 xcb_create_window_value_list_sizeof (const void  *_buffer,
1320                                      uint32_t     value_mask)
1321 {
1322     xcb_create_window_value_list_t _aux;
1323     return xcb_create_window_value_list_unpack(_buffer, value_mask, &_aux);
1324 }
1325 
1326 int
xcb_create_window_sizeof(const void * _buffer)1327 xcb_create_window_sizeof (const void  *_buffer)
1328 {
1329     char *xcb_tmp = (char *)_buffer;
1330     const xcb_create_window_request_t *_aux = (xcb_create_window_request_t *)_buffer;
1331     unsigned int xcb_buffer_len = 0;
1332     unsigned int xcb_block_len = 0;
1333     unsigned int xcb_pad = 0;
1334     unsigned int xcb_align_to = 0;
1335 
1336 
1337     xcb_block_len += sizeof(xcb_create_window_request_t);
1338     xcb_tmp += xcb_block_len;
1339     xcb_buffer_len += xcb_block_len;
1340     xcb_block_len = 0;
1341     /* value_list */
1342     xcb_block_len += xcb_create_window_value_list_sizeof(xcb_tmp, _aux->value_mask);
1343     xcb_tmp += xcb_block_len;
1344     xcb_align_to = ALIGNOF(char);
1345     /* insert padding */
1346     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1347     xcb_buffer_len += xcb_block_len + xcb_pad;
1348     if (0 != xcb_pad) {
1349         xcb_tmp += xcb_pad;
1350         xcb_pad = 0;
1351     }
1352     xcb_block_len = 0;
1353 
1354     return xcb_buffer_len;
1355 }
1356 
1357 xcb_void_cookie_t
xcb_create_window_checked(xcb_connection_t * c,uint8_t depth,xcb_window_t wid,xcb_window_t parent,int16_t x,int16_t y,uint16_t width,uint16_t height,uint16_t border_width,uint16_t _class,xcb_visualid_t visual,uint32_t value_mask,const void * value_list)1358 xcb_create_window_checked (xcb_connection_t *c,
1359                            uint8_t           depth,
1360                            xcb_window_t      wid,
1361                            xcb_window_t      parent,
1362                            int16_t           x,
1363                            int16_t           y,
1364                            uint16_t          width,
1365                            uint16_t          height,
1366                            uint16_t          border_width,
1367                            uint16_t          _class,
1368                            xcb_visualid_t    visual,
1369                            uint32_t          value_mask,
1370                            const void       *value_list)
1371 {
1372     static const xcb_protocol_request_t xcb_req = {
1373         .count = 3,
1374         .ext = 0,
1375         .opcode = XCB_CREATE_WINDOW,
1376         .isvoid = 1
1377     };
1378 
1379     struct iovec xcb_parts[5];
1380     xcb_void_cookie_t xcb_ret;
1381     xcb_create_window_request_t xcb_out;
1382 
1383     xcb_out.depth = depth;
1384     xcb_out.wid = wid;
1385     xcb_out.parent = parent;
1386     xcb_out.x = x;
1387     xcb_out.y = y;
1388     xcb_out.width = width;
1389     xcb_out.height = height;
1390     xcb_out.border_width = border_width;
1391     xcb_out._class = _class;
1392     xcb_out.visual = visual;
1393     xcb_out.value_mask = value_mask;
1394 
1395     xcb_parts[2].iov_base = (char *) &xcb_out;
1396     xcb_parts[2].iov_len = sizeof(xcb_out);
1397     xcb_parts[3].iov_base = 0;
1398     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1399     /* xcb_create_window_value_list_t value_list */
1400     xcb_parts[4].iov_base = (char *) value_list;
1401     xcb_parts[4].iov_len =
1402       xcb_create_window_value_list_sizeof (value_list, value_mask);
1403 
1404     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1405     return xcb_ret;
1406 }
1407 
1408 xcb_void_cookie_t
xcb_create_window(xcb_connection_t * c,uint8_t depth,xcb_window_t wid,xcb_window_t parent,int16_t x,int16_t y,uint16_t width,uint16_t height,uint16_t border_width,uint16_t _class,xcb_visualid_t visual,uint32_t value_mask,const void * value_list)1409 xcb_create_window (xcb_connection_t *c,
1410                    uint8_t           depth,
1411                    xcb_window_t      wid,
1412                    xcb_window_t      parent,
1413                    int16_t           x,
1414                    int16_t           y,
1415                    uint16_t          width,
1416                    uint16_t          height,
1417                    uint16_t          border_width,
1418                    uint16_t          _class,
1419                    xcb_visualid_t    visual,
1420                    uint32_t          value_mask,
1421                    const void       *value_list)
1422 {
1423     static const xcb_protocol_request_t xcb_req = {
1424         .count = 3,
1425         .ext = 0,
1426         .opcode = XCB_CREATE_WINDOW,
1427         .isvoid = 1
1428     };
1429 
1430     struct iovec xcb_parts[5];
1431     xcb_void_cookie_t xcb_ret;
1432     xcb_create_window_request_t xcb_out;
1433 
1434     xcb_out.depth = depth;
1435     xcb_out.wid = wid;
1436     xcb_out.parent = parent;
1437     xcb_out.x = x;
1438     xcb_out.y = y;
1439     xcb_out.width = width;
1440     xcb_out.height = height;
1441     xcb_out.border_width = border_width;
1442     xcb_out._class = _class;
1443     xcb_out.visual = visual;
1444     xcb_out.value_mask = value_mask;
1445 
1446     xcb_parts[2].iov_base = (char *) &xcb_out;
1447     xcb_parts[2].iov_len = sizeof(xcb_out);
1448     xcb_parts[3].iov_base = 0;
1449     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1450     /* xcb_create_window_value_list_t value_list */
1451     xcb_parts[4].iov_base = (char *) value_list;
1452     xcb_parts[4].iov_len =
1453       xcb_create_window_value_list_sizeof (value_list, value_mask);
1454 
1455     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1456     return xcb_ret;
1457 }
1458 
1459 xcb_void_cookie_t
xcb_create_window_aux_checked(xcb_connection_t * c,uint8_t depth,xcb_window_t wid,xcb_window_t parent,int16_t x,int16_t y,uint16_t width,uint16_t height,uint16_t border_width,uint16_t _class,xcb_visualid_t visual,uint32_t value_mask,const xcb_create_window_value_list_t * value_list)1460 xcb_create_window_aux_checked (xcb_connection_t                     *c,
1461                                uint8_t                               depth,
1462                                xcb_window_t                          wid,
1463                                xcb_window_t                          parent,
1464                                int16_t                               x,
1465                                int16_t                               y,
1466                                uint16_t                              width,
1467                                uint16_t                              height,
1468                                uint16_t                              border_width,
1469                                uint16_t                              _class,
1470                                xcb_visualid_t                        visual,
1471                                uint32_t                              value_mask,
1472                                const xcb_create_window_value_list_t *value_list)
1473 {
1474     static const xcb_protocol_request_t xcb_req = {
1475         .count = 3,
1476         .ext = 0,
1477         .opcode = XCB_CREATE_WINDOW,
1478         .isvoid = 1
1479     };
1480 
1481     struct iovec xcb_parts[5];
1482     xcb_void_cookie_t xcb_ret;
1483     xcb_create_window_request_t xcb_out;
1484     void *xcb_aux0 = 0;
1485 
1486     xcb_out.depth = depth;
1487     xcb_out.wid = wid;
1488     xcb_out.parent = parent;
1489     xcb_out.x = x;
1490     xcb_out.y = y;
1491     xcb_out.width = width;
1492     xcb_out.height = height;
1493     xcb_out.border_width = border_width;
1494     xcb_out._class = _class;
1495     xcb_out.visual = visual;
1496     xcb_out.value_mask = value_mask;
1497 
1498     xcb_parts[2].iov_base = (char *) &xcb_out;
1499     xcb_parts[2].iov_len = sizeof(xcb_out);
1500     xcb_parts[3].iov_base = 0;
1501     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1502     /* xcb_create_window_value_list_t value_list */
1503     xcb_parts[4].iov_len =
1504       xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
1505     xcb_parts[4].iov_base = xcb_aux0;
1506 
1507     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1508     free(xcb_aux0);
1509     return xcb_ret;
1510 }
1511 
1512 xcb_void_cookie_t
xcb_create_window_aux(xcb_connection_t * c,uint8_t depth,xcb_window_t wid,xcb_window_t parent,int16_t x,int16_t y,uint16_t width,uint16_t height,uint16_t border_width,uint16_t _class,xcb_visualid_t visual,uint32_t value_mask,const xcb_create_window_value_list_t * value_list)1513 xcb_create_window_aux (xcb_connection_t                     *c,
1514                        uint8_t                               depth,
1515                        xcb_window_t                          wid,
1516                        xcb_window_t                          parent,
1517                        int16_t                               x,
1518                        int16_t                               y,
1519                        uint16_t                              width,
1520                        uint16_t                              height,
1521                        uint16_t                              border_width,
1522                        uint16_t                              _class,
1523                        xcb_visualid_t                        visual,
1524                        uint32_t                              value_mask,
1525                        const xcb_create_window_value_list_t *value_list)
1526 {
1527     static const xcb_protocol_request_t xcb_req = {
1528         .count = 3,
1529         .ext = 0,
1530         .opcode = XCB_CREATE_WINDOW,
1531         .isvoid = 1
1532     };
1533 
1534     struct iovec xcb_parts[5];
1535     xcb_void_cookie_t xcb_ret;
1536     xcb_create_window_request_t xcb_out;
1537     void *xcb_aux0 = 0;
1538 
1539     xcb_out.depth = depth;
1540     xcb_out.wid = wid;
1541     xcb_out.parent = parent;
1542     xcb_out.x = x;
1543     xcb_out.y = y;
1544     xcb_out.width = width;
1545     xcb_out.height = height;
1546     xcb_out.border_width = border_width;
1547     xcb_out._class = _class;
1548     xcb_out.visual = visual;
1549     xcb_out.value_mask = value_mask;
1550 
1551     xcb_parts[2].iov_base = (char *) &xcb_out;
1552     xcb_parts[2].iov_len = sizeof(xcb_out);
1553     xcb_parts[3].iov_base = 0;
1554     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1555     /* xcb_create_window_value_list_t value_list */
1556     xcb_parts[4].iov_len =
1557       xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
1558     xcb_parts[4].iov_base = xcb_aux0;
1559 
1560     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1561     free(xcb_aux0);
1562     return xcb_ret;
1563 }
1564 
1565 void *
xcb_create_window_value_list(const xcb_create_window_request_t * R)1566 xcb_create_window_value_list (const xcb_create_window_request_t *R)
1567 {
1568     return (void *) (R + 1);
1569 }
1570 
1571 int
xcb_change_window_attributes_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_change_window_attributes_value_list_t * _aux)1572 xcb_change_window_attributes_value_list_serialize (void                                            **_buffer,
1573                                                    uint32_t                                          value_mask,
1574                                                    const xcb_change_window_attributes_value_list_t  *_aux)
1575 {
1576     char *xcb_out = *_buffer;
1577     unsigned int xcb_buffer_len = 0;
1578     unsigned int xcb_align_to = 0;
1579     unsigned int xcb_padding_offset = 0;
1580 
1581     unsigned int xcb_pad = 0;
1582     char xcb_pad0[3] = {0, 0, 0};
1583     struct iovec xcb_parts[16];
1584     unsigned int xcb_parts_idx = 0;
1585     unsigned int xcb_block_len = 0;
1586     unsigned int i;
1587     char *xcb_tmp;
1588 
1589     if(value_mask & XCB_CW_BACK_PIXMAP) {
1590         /* xcb_change_window_attributes_value_list_t.background_pixmap */
1591         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap;
1592         xcb_block_len += sizeof(xcb_pixmap_t);
1593         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
1594         xcb_parts_idx++;
1595         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1596     }
1597     if(value_mask & XCB_CW_BACK_PIXEL) {
1598         /* xcb_change_window_attributes_value_list_t.background_pixel */
1599         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel;
1600         xcb_block_len += sizeof(uint32_t);
1601         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1602         xcb_parts_idx++;
1603         xcb_align_to = ALIGNOF(uint32_t);
1604     }
1605     if(value_mask & XCB_CW_BORDER_PIXMAP) {
1606         /* xcb_change_window_attributes_value_list_t.border_pixmap */
1607         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap;
1608         xcb_block_len += sizeof(xcb_pixmap_t);
1609         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
1610         xcb_parts_idx++;
1611         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1612     }
1613     if(value_mask & XCB_CW_BORDER_PIXEL) {
1614         /* xcb_change_window_attributes_value_list_t.border_pixel */
1615         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel;
1616         xcb_block_len += sizeof(uint32_t);
1617         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1618         xcb_parts_idx++;
1619         xcb_align_to = ALIGNOF(uint32_t);
1620     }
1621     if(value_mask & XCB_CW_BIT_GRAVITY) {
1622         /* xcb_change_window_attributes_value_list_t.bit_gravity */
1623         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity;
1624         xcb_block_len += sizeof(uint32_t);
1625         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1626         xcb_parts_idx++;
1627         xcb_align_to = ALIGNOF(uint32_t);
1628     }
1629     if(value_mask & XCB_CW_WIN_GRAVITY) {
1630         /* xcb_change_window_attributes_value_list_t.win_gravity */
1631         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity;
1632         xcb_block_len += sizeof(uint32_t);
1633         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1634         xcb_parts_idx++;
1635         xcb_align_to = ALIGNOF(uint32_t);
1636     }
1637     if(value_mask & XCB_CW_BACKING_STORE) {
1638         /* xcb_change_window_attributes_value_list_t.backing_store */
1639         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store;
1640         xcb_block_len += sizeof(uint32_t);
1641         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1642         xcb_parts_idx++;
1643         xcb_align_to = ALIGNOF(uint32_t);
1644     }
1645     if(value_mask & XCB_CW_BACKING_PLANES) {
1646         /* xcb_change_window_attributes_value_list_t.backing_planes */
1647         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes;
1648         xcb_block_len += sizeof(uint32_t);
1649         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1650         xcb_parts_idx++;
1651         xcb_align_to = ALIGNOF(uint32_t);
1652     }
1653     if(value_mask & XCB_CW_BACKING_PIXEL) {
1654         /* xcb_change_window_attributes_value_list_t.backing_pixel */
1655         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel;
1656         xcb_block_len += sizeof(uint32_t);
1657         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1658         xcb_parts_idx++;
1659         xcb_align_to = ALIGNOF(uint32_t);
1660     }
1661     if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
1662         /* xcb_change_window_attributes_value_list_t.override_redirect */
1663         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect;
1664         xcb_block_len += sizeof(xcb_bool32_t);
1665         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
1666         xcb_parts_idx++;
1667         xcb_align_to = ALIGNOF(xcb_bool32_t);
1668     }
1669     if(value_mask & XCB_CW_SAVE_UNDER) {
1670         /* xcb_change_window_attributes_value_list_t.save_under */
1671         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under;
1672         xcb_block_len += sizeof(xcb_bool32_t);
1673         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
1674         xcb_parts_idx++;
1675         xcb_align_to = ALIGNOF(xcb_bool32_t);
1676     }
1677     if(value_mask & XCB_CW_EVENT_MASK) {
1678         /* xcb_change_window_attributes_value_list_t.event_mask */
1679         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask;
1680         xcb_block_len += sizeof(uint32_t);
1681         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1682         xcb_parts_idx++;
1683         xcb_align_to = ALIGNOF(uint32_t);
1684     }
1685     if(value_mask & XCB_CW_DONT_PROPAGATE) {
1686         /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */
1687         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask;
1688         xcb_block_len += sizeof(uint32_t);
1689         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1690         xcb_parts_idx++;
1691         xcb_align_to = ALIGNOF(uint32_t);
1692     }
1693     if(value_mask & XCB_CW_COLORMAP) {
1694         /* xcb_change_window_attributes_value_list_t.colormap */
1695         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap;
1696         xcb_block_len += sizeof(xcb_colormap_t);
1697         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t);
1698         xcb_parts_idx++;
1699         xcb_align_to = ALIGNOF(xcb_colormap_t);
1700     }
1701     if(value_mask & XCB_CW_CURSOR) {
1702         /* xcb_change_window_attributes_value_list_t.cursor */
1703         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor;
1704         xcb_block_len += sizeof(xcb_cursor_t);
1705         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t);
1706         xcb_parts_idx++;
1707         xcb_align_to = ALIGNOF(xcb_cursor_t);
1708     }
1709     /* insert padding */
1710     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1711     xcb_buffer_len += xcb_block_len + xcb_pad;
1712     if (0 != xcb_pad) {
1713         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
1714         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
1715         xcb_parts_idx++;
1716         xcb_pad = 0;
1717     }
1718     xcb_block_len = 0;
1719     xcb_padding_offset = 0;
1720 
1721     if (NULL == xcb_out) {
1722         /* allocate memory */
1723         xcb_out = malloc(xcb_buffer_len);
1724         *_buffer = xcb_out;
1725     }
1726 
1727     xcb_tmp = xcb_out;
1728     for(i=0; i<xcb_parts_idx; i++) {
1729         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
1730             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
1731         if (0 != xcb_parts[i].iov_len)
1732             xcb_tmp += xcb_parts[i].iov_len;
1733     }
1734 
1735     return xcb_buffer_len;
1736 }
1737 
1738 int
xcb_change_window_attributes_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_change_window_attributes_value_list_t * _aux)1739 xcb_change_window_attributes_value_list_unpack (const void                                 *_buffer,
1740                                                 uint32_t                                    value_mask,
1741                                                 xcb_change_window_attributes_value_list_t  *_aux)
1742 {
1743     char *xcb_tmp = (char *)_buffer;
1744     unsigned int xcb_buffer_len = 0;
1745     unsigned int xcb_block_len = 0;
1746     unsigned int xcb_pad = 0;
1747     unsigned int xcb_align_to = 0;
1748     unsigned int xcb_padding_offset = 0;
1749 
1750 
1751     if(value_mask & XCB_CW_BACK_PIXMAP) {
1752         /* xcb_change_window_attributes_value_list_t.background_pixmap */
1753         _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp;
1754         xcb_block_len += sizeof(xcb_pixmap_t);
1755         xcb_tmp += sizeof(xcb_pixmap_t);
1756         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1757     }
1758     if(value_mask & XCB_CW_BACK_PIXEL) {
1759         /* xcb_change_window_attributes_value_list_t.background_pixel */
1760         _aux->background_pixel = *(uint32_t *)xcb_tmp;
1761         xcb_block_len += sizeof(uint32_t);
1762         xcb_tmp += sizeof(uint32_t);
1763         xcb_align_to = ALIGNOF(uint32_t);
1764     }
1765     if(value_mask & XCB_CW_BORDER_PIXMAP) {
1766         /* xcb_change_window_attributes_value_list_t.border_pixmap */
1767         _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp;
1768         xcb_block_len += sizeof(xcb_pixmap_t);
1769         xcb_tmp += sizeof(xcb_pixmap_t);
1770         xcb_align_to = ALIGNOF(xcb_pixmap_t);
1771     }
1772     if(value_mask & XCB_CW_BORDER_PIXEL) {
1773         /* xcb_change_window_attributes_value_list_t.border_pixel */
1774         _aux->border_pixel = *(uint32_t *)xcb_tmp;
1775         xcb_block_len += sizeof(uint32_t);
1776         xcb_tmp += sizeof(uint32_t);
1777         xcb_align_to = ALIGNOF(uint32_t);
1778     }
1779     if(value_mask & XCB_CW_BIT_GRAVITY) {
1780         /* xcb_change_window_attributes_value_list_t.bit_gravity */
1781         _aux->bit_gravity = *(uint32_t *)xcb_tmp;
1782         xcb_block_len += sizeof(uint32_t);
1783         xcb_tmp += sizeof(uint32_t);
1784         xcb_align_to = ALIGNOF(uint32_t);
1785     }
1786     if(value_mask & XCB_CW_WIN_GRAVITY) {
1787         /* xcb_change_window_attributes_value_list_t.win_gravity */
1788         _aux->win_gravity = *(uint32_t *)xcb_tmp;
1789         xcb_block_len += sizeof(uint32_t);
1790         xcb_tmp += sizeof(uint32_t);
1791         xcb_align_to = ALIGNOF(uint32_t);
1792     }
1793     if(value_mask & XCB_CW_BACKING_STORE) {
1794         /* xcb_change_window_attributes_value_list_t.backing_store */
1795         _aux->backing_store = *(uint32_t *)xcb_tmp;
1796         xcb_block_len += sizeof(uint32_t);
1797         xcb_tmp += sizeof(uint32_t);
1798         xcb_align_to = ALIGNOF(uint32_t);
1799     }
1800     if(value_mask & XCB_CW_BACKING_PLANES) {
1801         /* xcb_change_window_attributes_value_list_t.backing_planes */
1802         _aux->backing_planes = *(uint32_t *)xcb_tmp;
1803         xcb_block_len += sizeof(uint32_t);
1804         xcb_tmp += sizeof(uint32_t);
1805         xcb_align_to = ALIGNOF(uint32_t);
1806     }
1807     if(value_mask & XCB_CW_BACKING_PIXEL) {
1808         /* xcb_change_window_attributes_value_list_t.backing_pixel */
1809         _aux->backing_pixel = *(uint32_t *)xcb_tmp;
1810         xcb_block_len += sizeof(uint32_t);
1811         xcb_tmp += sizeof(uint32_t);
1812         xcb_align_to = ALIGNOF(uint32_t);
1813     }
1814     if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
1815         /* xcb_change_window_attributes_value_list_t.override_redirect */
1816         _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp;
1817         xcb_block_len += sizeof(xcb_bool32_t);
1818         xcb_tmp += sizeof(xcb_bool32_t);
1819         xcb_align_to = ALIGNOF(xcb_bool32_t);
1820     }
1821     if(value_mask & XCB_CW_SAVE_UNDER) {
1822         /* xcb_change_window_attributes_value_list_t.save_under */
1823         _aux->save_under = *(xcb_bool32_t *)xcb_tmp;
1824         xcb_block_len += sizeof(xcb_bool32_t);
1825         xcb_tmp += sizeof(xcb_bool32_t);
1826         xcb_align_to = ALIGNOF(xcb_bool32_t);
1827     }
1828     if(value_mask & XCB_CW_EVENT_MASK) {
1829         /* xcb_change_window_attributes_value_list_t.event_mask */
1830         _aux->event_mask = *(uint32_t *)xcb_tmp;
1831         xcb_block_len += sizeof(uint32_t);
1832         xcb_tmp += sizeof(uint32_t);
1833         xcb_align_to = ALIGNOF(uint32_t);
1834     }
1835     if(value_mask & XCB_CW_DONT_PROPAGATE) {
1836         /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */
1837         _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp;
1838         xcb_block_len += sizeof(uint32_t);
1839         xcb_tmp += sizeof(uint32_t);
1840         xcb_align_to = ALIGNOF(uint32_t);
1841     }
1842     if(value_mask & XCB_CW_COLORMAP) {
1843         /* xcb_change_window_attributes_value_list_t.colormap */
1844         _aux->colormap = *(xcb_colormap_t *)xcb_tmp;
1845         xcb_block_len += sizeof(xcb_colormap_t);
1846         xcb_tmp += sizeof(xcb_colormap_t);
1847         xcb_align_to = ALIGNOF(xcb_colormap_t);
1848     }
1849     if(value_mask & XCB_CW_CURSOR) {
1850         /* xcb_change_window_attributes_value_list_t.cursor */
1851         _aux->cursor = *(xcb_cursor_t *)xcb_tmp;
1852         xcb_block_len += sizeof(xcb_cursor_t);
1853         xcb_tmp += sizeof(xcb_cursor_t);
1854         xcb_align_to = ALIGNOF(xcb_cursor_t);
1855     }
1856     /* insert padding */
1857     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1858     xcb_buffer_len += xcb_block_len + xcb_pad;
1859     if (0 != xcb_pad) {
1860         xcb_tmp += xcb_pad;
1861         xcb_pad = 0;
1862     }
1863     xcb_block_len = 0;
1864     xcb_padding_offset = 0;
1865 
1866     return xcb_buffer_len;
1867 }
1868 
1869 int
xcb_change_window_attributes_value_list_sizeof(const void * _buffer,uint32_t value_mask)1870 xcb_change_window_attributes_value_list_sizeof (const void  *_buffer,
1871                                                 uint32_t     value_mask)
1872 {
1873     xcb_change_window_attributes_value_list_t _aux;
1874     return xcb_change_window_attributes_value_list_unpack(_buffer, value_mask, &_aux);
1875 }
1876 
1877 int
xcb_change_window_attributes_sizeof(const void * _buffer)1878 xcb_change_window_attributes_sizeof (const void  *_buffer)
1879 {
1880     char *xcb_tmp = (char *)_buffer;
1881     const xcb_change_window_attributes_request_t *_aux = (xcb_change_window_attributes_request_t *)_buffer;
1882     unsigned int xcb_buffer_len = 0;
1883     unsigned int xcb_block_len = 0;
1884     unsigned int xcb_pad = 0;
1885     unsigned int xcb_align_to = 0;
1886 
1887 
1888     xcb_block_len += sizeof(xcb_change_window_attributes_request_t);
1889     xcb_tmp += xcb_block_len;
1890     xcb_buffer_len += xcb_block_len;
1891     xcb_block_len = 0;
1892     /* value_list */
1893     xcb_block_len += xcb_change_window_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask);
1894     xcb_tmp += xcb_block_len;
1895     xcb_align_to = ALIGNOF(char);
1896     /* insert padding */
1897     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1898     xcb_buffer_len += xcb_block_len + xcb_pad;
1899     if (0 != xcb_pad) {
1900         xcb_tmp += xcb_pad;
1901         xcb_pad = 0;
1902     }
1903     xcb_block_len = 0;
1904 
1905     return xcb_buffer_len;
1906 }
1907 
1908 xcb_void_cookie_t
xcb_change_window_attributes_checked(xcb_connection_t * c,xcb_window_t window,uint32_t value_mask,const void * value_list)1909 xcb_change_window_attributes_checked (xcb_connection_t *c,
1910                                       xcb_window_t      window,
1911                                       uint32_t          value_mask,
1912                                       const void       *value_list)
1913 {
1914     static const xcb_protocol_request_t xcb_req = {
1915         .count = 3,
1916         .ext = 0,
1917         .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
1918         .isvoid = 1
1919     };
1920 
1921     struct iovec xcb_parts[5];
1922     xcb_void_cookie_t xcb_ret;
1923     xcb_change_window_attributes_request_t xcb_out;
1924 
1925     xcb_out.pad0 = 0;
1926     xcb_out.window = window;
1927     xcb_out.value_mask = value_mask;
1928 
1929     xcb_parts[2].iov_base = (char *) &xcb_out;
1930     xcb_parts[2].iov_len = sizeof(xcb_out);
1931     xcb_parts[3].iov_base = 0;
1932     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1933     /* xcb_change_window_attributes_value_list_t value_list */
1934     xcb_parts[4].iov_base = (char *) value_list;
1935     xcb_parts[4].iov_len =
1936       xcb_change_window_attributes_value_list_sizeof (value_list, value_mask);
1937 
1938     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1939     return xcb_ret;
1940 }
1941 
1942 xcb_void_cookie_t
xcb_change_window_attributes(xcb_connection_t * c,xcb_window_t window,uint32_t value_mask,const void * value_list)1943 xcb_change_window_attributes (xcb_connection_t *c,
1944                               xcb_window_t      window,
1945                               uint32_t          value_mask,
1946                               const void       *value_list)
1947 {
1948     static const xcb_protocol_request_t xcb_req = {
1949         .count = 3,
1950         .ext = 0,
1951         .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
1952         .isvoid = 1
1953     };
1954 
1955     struct iovec xcb_parts[5];
1956     xcb_void_cookie_t xcb_ret;
1957     xcb_change_window_attributes_request_t xcb_out;
1958 
1959     xcb_out.pad0 = 0;
1960     xcb_out.window = window;
1961     xcb_out.value_mask = value_mask;
1962 
1963     xcb_parts[2].iov_base = (char *) &xcb_out;
1964     xcb_parts[2].iov_len = sizeof(xcb_out);
1965     xcb_parts[3].iov_base = 0;
1966     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1967     /* xcb_change_window_attributes_value_list_t value_list */
1968     xcb_parts[4].iov_base = (char *) value_list;
1969     xcb_parts[4].iov_len =
1970       xcb_change_window_attributes_value_list_sizeof (value_list, value_mask);
1971 
1972     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1973     return xcb_ret;
1974 }
1975 
1976 xcb_void_cookie_t
xcb_change_window_attributes_aux_checked(xcb_connection_t * c,xcb_window_t window,uint32_t value_mask,const xcb_change_window_attributes_value_list_t * value_list)1977 xcb_change_window_attributes_aux_checked (xcb_connection_t                                *c,
1978                                           xcb_window_t                                     window,
1979                                           uint32_t                                         value_mask,
1980                                           const xcb_change_window_attributes_value_list_t *value_list)
1981 {
1982     static const xcb_protocol_request_t xcb_req = {
1983         .count = 3,
1984         .ext = 0,
1985         .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
1986         .isvoid = 1
1987     };
1988 
1989     struct iovec xcb_parts[5];
1990     xcb_void_cookie_t xcb_ret;
1991     xcb_change_window_attributes_request_t xcb_out;
1992     void *xcb_aux0 = 0;
1993 
1994     xcb_out.pad0 = 0;
1995     xcb_out.window = window;
1996     xcb_out.value_mask = value_mask;
1997 
1998     xcb_parts[2].iov_base = (char *) &xcb_out;
1999     xcb_parts[2].iov_len = sizeof(xcb_out);
2000     xcb_parts[3].iov_base = 0;
2001     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2002     /* xcb_change_window_attributes_value_list_t value_list */
2003     xcb_parts[4].iov_len =
2004       xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
2005     xcb_parts[4].iov_base = xcb_aux0;
2006 
2007     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2008     free(xcb_aux0);
2009     return xcb_ret;
2010 }
2011 
2012 xcb_void_cookie_t
xcb_change_window_attributes_aux(xcb_connection_t * c,xcb_window_t window,uint32_t value_mask,const xcb_change_window_attributes_value_list_t * value_list)2013 xcb_change_window_attributes_aux (xcb_connection_t                                *c,
2014                                   xcb_window_t                                     window,
2015                                   uint32_t                                         value_mask,
2016                                   const xcb_change_window_attributes_value_list_t *value_list)
2017 {
2018     static const xcb_protocol_request_t xcb_req = {
2019         .count = 3,
2020         .ext = 0,
2021         .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
2022         .isvoid = 1
2023     };
2024 
2025     struct iovec xcb_parts[5];
2026     xcb_void_cookie_t xcb_ret;
2027     xcb_change_window_attributes_request_t xcb_out;
2028     void *xcb_aux0 = 0;
2029 
2030     xcb_out.pad0 = 0;
2031     xcb_out.window = window;
2032     xcb_out.value_mask = value_mask;
2033 
2034     xcb_parts[2].iov_base = (char *) &xcb_out;
2035     xcb_parts[2].iov_len = sizeof(xcb_out);
2036     xcb_parts[3].iov_base = 0;
2037     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2038     /* xcb_change_window_attributes_value_list_t value_list */
2039     xcb_parts[4].iov_len =
2040       xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
2041     xcb_parts[4].iov_base = xcb_aux0;
2042 
2043     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2044     free(xcb_aux0);
2045     return xcb_ret;
2046 }
2047 
2048 void *
xcb_change_window_attributes_value_list(const xcb_change_window_attributes_request_t * R)2049 xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R)
2050 {
2051     return (void *) (R + 1);
2052 }
2053 
2054 xcb_get_window_attributes_cookie_t
xcb_get_window_attributes(xcb_connection_t * c,xcb_window_t window)2055 xcb_get_window_attributes (xcb_connection_t *c,
2056                            xcb_window_t      window)
2057 {
2058     static const xcb_protocol_request_t xcb_req = {
2059         .count = 2,
2060         .ext = 0,
2061         .opcode = XCB_GET_WINDOW_ATTRIBUTES,
2062         .isvoid = 0
2063     };
2064 
2065     struct iovec xcb_parts[4];
2066     xcb_get_window_attributes_cookie_t xcb_ret;
2067     xcb_get_window_attributes_request_t xcb_out;
2068 
2069     xcb_out.pad0 = 0;
2070     xcb_out.window = window;
2071 
2072     xcb_parts[2].iov_base = (char *) &xcb_out;
2073     xcb_parts[2].iov_len = sizeof(xcb_out);
2074     xcb_parts[3].iov_base = 0;
2075     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2076 
2077     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2078     return xcb_ret;
2079 }
2080 
2081 xcb_get_window_attributes_cookie_t
xcb_get_window_attributes_unchecked(xcb_connection_t * c,xcb_window_t window)2082 xcb_get_window_attributes_unchecked (xcb_connection_t *c,
2083                                      xcb_window_t      window)
2084 {
2085     static const xcb_protocol_request_t xcb_req = {
2086         .count = 2,
2087         .ext = 0,
2088         .opcode = XCB_GET_WINDOW_ATTRIBUTES,
2089         .isvoid = 0
2090     };
2091 
2092     struct iovec xcb_parts[4];
2093     xcb_get_window_attributes_cookie_t xcb_ret;
2094     xcb_get_window_attributes_request_t xcb_out;
2095 
2096     xcb_out.pad0 = 0;
2097     xcb_out.window = window;
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 
2104     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2105     return xcb_ret;
2106 }
2107 
2108 xcb_get_window_attributes_reply_t *
xcb_get_window_attributes_reply(xcb_connection_t * c,xcb_get_window_attributes_cookie_t cookie,xcb_generic_error_t ** e)2109 xcb_get_window_attributes_reply (xcb_connection_t                    *c,
2110                                  xcb_get_window_attributes_cookie_t   cookie  /**< */,
2111                                  xcb_generic_error_t                **e)
2112 {
2113     return (xcb_get_window_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2114 }
2115 
2116 xcb_void_cookie_t
xcb_destroy_window_checked(xcb_connection_t * c,xcb_window_t window)2117 xcb_destroy_window_checked (xcb_connection_t *c,
2118                             xcb_window_t      window)
2119 {
2120     static const xcb_protocol_request_t xcb_req = {
2121         .count = 2,
2122         .ext = 0,
2123         .opcode = XCB_DESTROY_WINDOW,
2124         .isvoid = 1
2125     };
2126 
2127     struct iovec xcb_parts[4];
2128     xcb_void_cookie_t xcb_ret;
2129     xcb_destroy_window_request_t xcb_out;
2130 
2131     xcb_out.pad0 = 0;
2132     xcb_out.window = window;
2133 
2134     xcb_parts[2].iov_base = (char *) &xcb_out;
2135     xcb_parts[2].iov_len = sizeof(xcb_out);
2136     xcb_parts[3].iov_base = 0;
2137     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2138 
2139     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2140     return xcb_ret;
2141 }
2142 
2143 xcb_void_cookie_t
xcb_destroy_window(xcb_connection_t * c,xcb_window_t window)2144 xcb_destroy_window (xcb_connection_t *c,
2145                     xcb_window_t      window)
2146 {
2147     static const xcb_protocol_request_t xcb_req = {
2148         .count = 2,
2149         .ext = 0,
2150         .opcode = XCB_DESTROY_WINDOW,
2151         .isvoid = 1
2152     };
2153 
2154     struct iovec xcb_parts[4];
2155     xcb_void_cookie_t xcb_ret;
2156     xcb_destroy_window_request_t xcb_out;
2157 
2158     xcb_out.pad0 = 0;
2159     xcb_out.window = window;
2160 
2161     xcb_parts[2].iov_base = (char *) &xcb_out;
2162     xcb_parts[2].iov_len = sizeof(xcb_out);
2163     xcb_parts[3].iov_base = 0;
2164     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2165 
2166     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2167     return xcb_ret;
2168 }
2169 
2170 xcb_void_cookie_t
xcb_destroy_subwindows_checked(xcb_connection_t * c,xcb_window_t window)2171 xcb_destroy_subwindows_checked (xcb_connection_t *c,
2172                                 xcb_window_t      window)
2173 {
2174     static const xcb_protocol_request_t xcb_req = {
2175         .count = 2,
2176         .ext = 0,
2177         .opcode = XCB_DESTROY_SUBWINDOWS,
2178         .isvoid = 1
2179     };
2180 
2181     struct iovec xcb_parts[4];
2182     xcb_void_cookie_t xcb_ret;
2183     xcb_destroy_subwindows_request_t xcb_out;
2184 
2185     xcb_out.pad0 = 0;
2186     xcb_out.window = window;
2187 
2188     xcb_parts[2].iov_base = (char *) &xcb_out;
2189     xcb_parts[2].iov_len = sizeof(xcb_out);
2190     xcb_parts[3].iov_base = 0;
2191     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2192 
2193     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2194     return xcb_ret;
2195 }
2196 
2197 xcb_void_cookie_t
xcb_destroy_subwindows(xcb_connection_t * c,xcb_window_t window)2198 xcb_destroy_subwindows (xcb_connection_t *c,
2199                         xcb_window_t      window)
2200 {
2201     static const xcb_protocol_request_t xcb_req = {
2202         .count = 2,
2203         .ext = 0,
2204         .opcode = XCB_DESTROY_SUBWINDOWS,
2205         .isvoid = 1
2206     };
2207 
2208     struct iovec xcb_parts[4];
2209     xcb_void_cookie_t xcb_ret;
2210     xcb_destroy_subwindows_request_t xcb_out;
2211 
2212     xcb_out.pad0 = 0;
2213     xcb_out.window = window;
2214 
2215     xcb_parts[2].iov_base = (char *) &xcb_out;
2216     xcb_parts[2].iov_len = sizeof(xcb_out);
2217     xcb_parts[3].iov_base = 0;
2218     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2219 
2220     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2221     return xcb_ret;
2222 }
2223 
2224 xcb_void_cookie_t
xcb_change_save_set_checked(xcb_connection_t * c,uint8_t mode,xcb_window_t window)2225 xcb_change_save_set_checked (xcb_connection_t *c,
2226                              uint8_t           mode,
2227                              xcb_window_t      window)
2228 {
2229     static const xcb_protocol_request_t xcb_req = {
2230         .count = 2,
2231         .ext = 0,
2232         .opcode = XCB_CHANGE_SAVE_SET,
2233         .isvoid = 1
2234     };
2235 
2236     struct iovec xcb_parts[4];
2237     xcb_void_cookie_t xcb_ret;
2238     xcb_change_save_set_request_t xcb_out;
2239 
2240     xcb_out.mode = mode;
2241     xcb_out.window = window;
2242 
2243     xcb_parts[2].iov_base = (char *) &xcb_out;
2244     xcb_parts[2].iov_len = sizeof(xcb_out);
2245     xcb_parts[3].iov_base = 0;
2246     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2247 
2248     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2249     return xcb_ret;
2250 }
2251 
2252 xcb_void_cookie_t
xcb_change_save_set(xcb_connection_t * c,uint8_t mode,xcb_window_t window)2253 xcb_change_save_set (xcb_connection_t *c,
2254                      uint8_t           mode,
2255                      xcb_window_t      window)
2256 {
2257     static const xcb_protocol_request_t xcb_req = {
2258         .count = 2,
2259         .ext = 0,
2260         .opcode = XCB_CHANGE_SAVE_SET,
2261         .isvoid = 1
2262     };
2263 
2264     struct iovec xcb_parts[4];
2265     xcb_void_cookie_t xcb_ret;
2266     xcb_change_save_set_request_t xcb_out;
2267 
2268     xcb_out.mode = mode;
2269     xcb_out.window = window;
2270 
2271     xcb_parts[2].iov_base = (char *) &xcb_out;
2272     xcb_parts[2].iov_len = sizeof(xcb_out);
2273     xcb_parts[3].iov_base = 0;
2274     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2275 
2276     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2277     return xcb_ret;
2278 }
2279 
2280 xcb_void_cookie_t
xcb_reparent_window_checked(xcb_connection_t * c,xcb_window_t window,xcb_window_t parent,int16_t x,int16_t y)2281 xcb_reparent_window_checked (xcb_connection_t *c,
2282                              xcb_window_t      window,
2283                              xcb_window_t      parent,
2284                              int16_t           x,
2285                              int16_t           y)
2286 {
2287     static const xcb_protocol_request_t xcb_req = {
2288         .count = 2,
2289         .ext = 0,
2290         .opcode = XCB_REPARENT_WINDOW,
2291         .isvoid = 1
2292     };
2293 
2294     struct iovec xcb_parts[4];
2295     xcb_void_cookie_t xcb_ret;
2296     xcb_reparent_window_request_t xcb_out;
2297 
2298     xcb_out.pad0 = 0;
2299     xcb_out.window = window;
2300     xcb_out.parent = parent;
2301     xcb_out.x = x;
2302     xcb_out.y = y;
2303 
2304     xcb_parts[2].iov_base = (char *) &xcb_out;
2305     xcb_parts[2].iov_len = sizeof(xcb_out);
2306     xcb_parts[3].iov_base = 0;
2307     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2308 
2309     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2310     return xcb_ret;
2311 }
2312 
2313 xcb_void_cookie_t
xcb_reparent_window(xcb_connection_t * c,xcb_window_t window,xcb_window_t parent,int16_t x,int16_t y)2314 xcb_reparent_window (xcb_connection_t *c,
2315                      xcb_window_t      window,
2316                      xcb_window_t      parent,
2317                      int16_t           x,
2318                      int16_t           y)
2319 {
2320     static const xcb_protocol_request_t xcb_req = {
2321         .count = 2,
2322         .ext = 0,
2323         .opcode = XCB_REPARENT_WINDOW,
2324         .isvoid = 1
2325     };
2326 
2327     struct iovec xcb_parts[4];
2328     xcb_void_cookie_t xcb_ret;
2329     xcb_reparent_window_request_t xcb_out;
2330 
2331     xcb_out.pad0 = 0;
2332     xcb_out.window = window;
2333     xcb_out.parent = parent;
2334     xcb_out.x = x;
2335     xcb_out.y = y;
2336 
2337     xcb_parts[2].iov_base = (char *) &xcb_out;
2338     xcb_parts[2].iov_len = sizeof(xcb_out);
2339     xcb_parts[3].iov_base = 0;
2340     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2341 
2342     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2343     return xcb_ret;
2344 }
2345 
2346 xcb_void_cookie_t
xcb_map_window_checked(xcb_connection_t * c,xcb_window_t window)2347 xcb_map_window_checked (xcb_connection_t *c,
2348                         xcb_window_t      window)
2349 {
2350     static const xcb_protocol_request_t xcb_req = {
2351         .count = 2,
2352         .ext = 0,
2353         .opcode = XCB_MAP_WINDOW,
2354         .isvoid = 1
2355     };
2356 
2357     struct iovec xcb_parts[4];
2358     xcb_void_cookie_t xcb_ret;
2359     xcb_map_window_request_t xcb_out;
2360 
2361     xcb_out.pad0 = 0;
2362     xcb_out.window = window;
2363 
2364     xcb_parts[2].iov_base = (char *) &xcb_out;
2365     xcb_parts[2].iov_len = sizeof(xcb_out);
2366     xcb_parts[3].iov_base = 0;
2367     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2368 
2369     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2370     return xcb_ret;
2371 }
2372 
2373 xcb_void_cookie_t
xcb_map_window(xcb_connection_t * c,xcb_window_t window)2374 xcb_map_window (xcb_connection_t *c,
2375                 xcb_window_t      window)
2376 {
2377     static const xcb_protocol_request_t xcb_req = {
2378         .count = 2,
2379         .ext = 0,
2380         .opcode = XCB_MAP_WINDOW,
2381         .isvoid = 1
2382     };
2383 
2384     struct iovec xcb_parts[4];
2385     xcb_void_cookie_t xcb_ret;
2386     xcb_map_window_request_t xcb_out;
2387 
2388     xcb_out.pad0 = 0;
2389     xcb_out.window = window;
2390 
2391     xcb_parts[2].iov_base = (char *) &xcb_out;
2392     xcb_parts[2].iov_len = sizeof(xcb_out);
2393     xcb_parts[3].iov_base = 0;
2394     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2395 
2396     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2397     return xcb_ret;
2398 }
2399 
2400 xcb_void_cookie_t
xcb_map_subwindows_checked(xcb_connection_t * c,xcb_window_t window)2401 xcb_map_subwindows_checked (xcb_connection_t *c,
2402                             xcb_window_t      window)
2403 {
2404     static const xcb_protocol_request_t xcb_req = {
2405         .count = 2,
2406         .ext = 0,
2407         .opcode = XCB_MAP_SUBWINDOWS,
2408         .isvoid = 1
2409     };
2410 
2411     struct iovec xcb_parts[4];
2412     xcb_void_cookie_t xcb_ret;
2413     xcb_map_subwindows_request_t xcb_out;
2414 
2415     xcb_out.pad0 = 0;
2416     xcb_out.window = window;
2417 
2418     xcb_parts[2].iov_base = (char *) &xcb_out;
2419     xcb_parts[2].iov_len = sizeof(xcb_out);
2420     xcb_parts[3].iov_base = 0;
2421     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2422 
2423     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2424     return xcb_ret;
2425 }
2426 
2427 xcb_void_cookie_t
xcb_map_subwindows(xcb_connection_t * c,xcb_window_t window)2428 xcb_map_subwindows (xcb_connection_t *c,
2429                     xcb_window_t      window)
2430 {
2431     static const xcb_protocol_request_t xcb_req = {
2432         .count = 2,
2433         .ext = 0,
2434         .opcode = XCB_MAP_SUBWINDOWS,
2435         .isvoid = 1
2436     };
2437 
2438     struct iovec xcb_parts[4];
2439     xcb_void_cookie_t xcb_ret;
2440     xcb_map_subwindows_request_t xcb_out;
2441 
2442     xcb_out.pad0 = 0;
2443     xcb_out.window = window;
2444 
2445     xcb_parts[2].iov_base = (char *) &xcb_out;
2446     xcb_parts[2].iov_len = sizeof(xcb_out);
2447     xcb_parts[3].iov_base = 0;
2448     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2449 
2450     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2451     return xcb_ret;
2452 }
2453 
2454 xcb_void_cookie_t
xcb_unmap_window_checked(xcb_connection_t * c,xcb_window_t window)2455 xcb_unmap_window_checked (xcb_connection_t *c,
2456                           xcb_window_t      window)
2457 {
2458     static const xcb_protocol_request_t xcb_req = {
2459         .count = 2,
2460         .ext = 0,
2461         .opcode = XCB_UNMAP_WINDOW,
2462         .isvoid = 1
2463     };
2464 
2465     struct iovec xcb_parts[4];
2466     xcb_void_cookie_t xcb_ret;
2467     xcb_unmap_window_request_t xcb_out;
2468 
2469     xcb_out.pad0 = 0;
2470     xcb_out.window = window;
2471 
2472     xcb_parts[2].iov_base = (char *) &xcb_out;
2473     xcb_parts[2].iov_len = sizeof(xcb_out);
2474     xcb_parts[3].iov_base = 0;
2475     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2476 
2477     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2478     return xcb_ret;
2479 }
2480 
2481 xcb_void_cookie_t
xcb_unmap_window(xcb_connection_t * c,xcb_window_t window)2482 xcb_unmap_window (xcb_connection_t *c,
2483                   xcb_window_t      window)
2484 {
2485     static const xcb_protocol_request_t xcb_req = {
2486         .count = 2,
2487         .ext = 0,
2488         .opcode = XCB_UNMAP_WINDOW,
2489         .isvoid = 1
2490     };
2491 
2492     struct iovec xcb_parts[4];
2493     xcb_void_cookie_t xcb_ret;
2494     xcb_unmap_window_request_t xcb_out;
2495 
2496     xcb_out.pad0 = 0;
2497     xcb_out.window = window;
2498 
2499     xcb_parts[2].iov_base = (char *) &xcb_out;
2500     xcb_parts[2].iov_len = sizeof(xcb_out);
2501     xcb_parts[3].iov_base = 0;
2502     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2503 
2504     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2505     return xcb_ret;
2506 }
2507 
2508 xcb_void_cookie_t
xcb_unmap_subwindows_checked(xcb_connection_t * c,xcb_window_t window)2509 xcb_unmap_subwindows_checked (xcb_connection_t *c,
2510                               xcb_window_t      window)
2511 {
2512     static const xcb_protocol_request_t xcb_req = {
2513         .count = 2,
2514         .ext = 0,
2515         .opcode = XCB_UNMAP_SUBWINDOWS,
2516         .isvoid = 1
2517     };
2518 
2519     struct iovec xcb_parts[4];
2520     xcb_void_cookie_t xcb_ret;
2521     xcb_unmap_subwindows_request_t xcb_out;
2522 
2523     xcb_out.pad0 = 0;
2524     xcb_out.window = window;
2525 
2526     xcb_parts[2].iov_base = (char *) &xcb_out;
2527     xcb_parts[2].iov_len = sizeof(xcb_out);
2528     xcb_parts[3].iov_base = 0;
2529     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2530 
2531     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2532     return xcb_ret;
2533 }
2534 
2535 xcb_void_cookie_t
xcb_unmap_subwindows(xcb_connection_t * c,xcb_window_t window)2536 xcb_unmap_subwindows (xcb_connection_t *c,
2537                       xcb_window_t      window)
2538 {
2539     static const xcb_protocol_request_t xcb_req = {
2540         .count = 2,
2541         .ext = 0,
2542         .opcode = XCB_UNMAP_SUBWINDOWS,
2543         .isvoid = 1
2544     };
2545 
2546     struct iovec xcb_parts[4];
2547     xcb_void_cookie_t xcb_ret;
2548     xcb_unmap_subwindows_request_t xcb_out;
2549 
2550     xcb_out.pad0 = 0;
2551     xcb_out.window = window;
2552 
2553     xcb_parts[2].iov_base = (char *) &xcb_out;
2554     xcb_parts[2].iov_len = sizeof(xcb_out);
2555     xcb_parts[3].iov_base = 0;
2556     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2557 
2558     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2559     return xcb_ret;
2560 }
2561 
2562 int
xcb_configure_window_value_list_serialize(void ** _buffer,uint16_t value_mask,const xcb_configure_window_value_list_t * _aux)2563 xcb_configure_window_value_list_serialize (void                                    **_buffer,
2564                                            uint16_t                                  value_mask,
2565                                            const xcb_configure_window_value_list_t  *_aux)
2566 {
2567     char *xcb_out = *_buffer;
2568     unsigned int xcb_buffer_len = 0;
2569     unsigned int xcb_align_to = 0;
2570     unsigned int xcb_padding_offset = 0;
2571 
2572     unsigned int xcb_pad = 0;
2573     char xcb_pad0[3] = {0, 0, 0};
2574     struct iovec xcb_parts[8];
2575     unsigned int xcb_parts_idx = 0;
2576     unsigned int xcb_block_len = 0;
2577     unsigned int i;
2578     char *xcb_tmp;
2579 
2580     if(value_mask & XCB_CONFIG_WINDOW_X) {
2581         /* xcb_configure_window_value_list_t.x */
2582         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->x;
2583         xcb_block_len += sizeof(int32_t);
2584         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
2585         xcb_parts_idx++;
2586         xcb_align_to = ALIGNOF(int32_t);
2587     }
2588     if(value_mask & XCB_CONFIG_WINDOW_Y) {
2589         /* xcb_configure_window_value_list_t.y */
2590         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->y;
2591         xcb_block_len += sizeof(int32_t);
2592         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
2593         xcb_parts_idx++;
2594         xcb_align_to = ALIGNOF(int32_t);
2595     }
2596     if(value_mask & XCB_CONFIG_WINDOW_WIDTH) {
2597         /* xcb_configure_window_value_list_t.width */
2598         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->width;
2599         xcb_block_len += sizeof(uint32_t);
2600         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2601         xcb_parts_idx++;
2602         xcb_align_to = ALIGNOF(uint32_t);
2603     }
2604     if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
2605         /* xcb_configure_window_value_list_t.height */
2606         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->height;
2607         xcb_block_len += sizeof(uint32_t);
2608         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2609         xcb_parts_idx++;
2610         xcb_align_to = ALIGNOF(uint32_t);
2611     }
2612     if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
2613         /* xcb_configure_window_value_list_t.border_width */
2614         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_width;
2615         xcb_block_len += sizeof(uint32_t);
2616         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2617         xcb_parts_idx++;
2618         xcb_align_to = ALIGNOF(uint32_t);
2619     }
2620     if(value_mask & XCB_CONFIG_WINDOW_SIBLING) {
2621         /* xcb_configure_window_value_list_t.sibling */
2622         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->sibling;
2623         xcb_block_len += sizeof(xcb_window_t);
2624         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_window_t);
2625         xcb_parts_idx++;
2626         xcb_align_to = ALIGNOF(xcb_window_t);
2627     }
2628     if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
2629         /* xcb_configure_window_value_list_t.stack_mode */
2630         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stack_mode;
2631         xcb_block_len += sizeof(uint32_t);
2632         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2633         xcb_parts_idx++;
2634         xcb_align_to = ALIGNOF(uint32_t);
2635     }
2636     /* insert padding */
2637     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
2638     xcb_buffer_len += xcb_block_len + xcb_pad;
2639     if (0 != xcb_pad) {
2640         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
2641         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
2642         xcb_parts_idx++;
2643         xcb_pad = 0;
2644     }
2645     xcb_block_len = 0;
2646     xcb_padding_offset = 0;
2647 
2648     if (NULL == xcb_out) {
2649         /* allocate memory */
2650         xcb_out = malloc(xcb_buffer_len);
2651         *_buffer = xcb_out;
2652     }
2653 
2654     xcb_tmp = xcb_out;
2655     for(i=0; i<xcb_parts_idx; i++) {
2656         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
2657             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
2658         if (0 != xcb_parts[i].iov_len)
2659             xcb_tmp += xcb_parts[i].iov_len;
2660     }
2661 
2662     return xcb_buffer_len;
2663 }
2664 
2665 int
xcb_configure_window_value_list_unpack(const void * _buffer,uint16_t value_mask,xcb_configure_window_value_list_t * _aux)2666 xcb_configure_window_value_list_unpack (const void                         *_buffer,
2667                                         uint16_t                            value_mask,
2668                                         xcb_configure_window_value_list_t  *_aux)
2669 {
2670     char *xcb_tmp = (char *)_buffer;
2671     unsigned int xcb_buffer_len = 0;
2672     unsigned int xcb_block_len = 0;
2673     unsigned int xcb_pad = 0;
2674     unsigned int xcb_align_to = 0;
2675     unsigned int xcb_padding_offset = 0;
2676 
2677 
2678     if(value_mask & XCB_CONFIG_WINDOW_X) {
2679         /* xcb_configure_window_value_list_t.x */
2680         _aux->x = *(int32_t *)xcb_tmp;
2681         xcb_block_len += sizeof(int32_t);
2682         xcb_tmp += sizeof(int32_t);
2683         xcb_align_to = ALIGNOF(int32_t);
2684     }
2685     if(value_mask & XCB_CONFIG_WINDOW_Y) {
2686         /* xcb_configure_window_value_list_t.y */
2687         _aux->y = *(int32_t *)xcb_tmp;
2688         xcb_block_len += sizeof(int32_t);
2689         xcb_tmp += sizeof(int32_t);
2690         xcb_align_to = ALIGNOF(int32_t);
2691     }
2692     if(value_mask & XCB_CONFIG_WINDOW_WIDTH) {
2693         /* xcb_configure_window_value_list_t.width */
2694         _aux->width = *(uint32_t *)xcb_tmp;
2695         xcb_block_len += sizeof(uint32_t);
2696         xcb_tmp += sizeof(uint32_t);
2697         xcb_align_to = ALIGNOF(uint32_t);
2698     }
2699     if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
2700         /* xcb_configure_window_value_list_t.height */
2701         _aux->height = *(uint32_t *)xcb_tmp;
2702         xcb_block_len += sizeof(uint32_t);
2703         xcb_tmp += sizeof(uint32_t);
2704         xcb_align_to = ALIGNOF(uint32_t);
2705     }
2706     if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
2707         /* xcb_configure_window_value_list_t.border_width */
2708         _aux->border_width = *(uint32_t *)xcb_tmp;
2709         xcb_block_len += sizeof(uint32_t);
2710         xcb_tmp += sizeof(uint32_t);
2711         xcb_align_to = ALIGNOF(uint32_t);
2712     }
2713     if(value_mask & XCB_CONFIG_WINDOW_SIBLING) {
2714         /* xcb_configure_window_value_list_t.sibling */
2715         _aux->sibling = *(xcb_window_t *)xcb_tmp;
2716         xcb_block_len += sizeof(xcb_window_t);
2717         xcb_tmp += sizeof(xcb_window_t);
2718         xcb_align_to = ALIGNOF(xcb_window_t);
2719     }
2720     if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
2721         /* xcb_configure_window_value_list_t.stack_mode */
2722         _aux->stack_mode = *(uint32_t *)xcb_tmp;
2723         xcb_block_len += sizeof(uint32_t);
2724         xcb_tmp += sizeof(uint32_t);
2725         xcb_align_to = ALIGNOF(uint32_t);
2726     }
2727     /* insert padding */
2728     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
2729     xcb_buffer_len += xcb_block_len + xcb_pad;
2730     if (0 != xcb_pad) {
2731         xcb_tmp += xcb_pad;
2732         xcb_pad = 0;
2733     }
2734     xcb_block_len = 0;
2735     xcb_padding_offset = 0;
2736 
2737     return xcb_buffer_len;
2738 }
2739 
2740 int
xcb_configure_window_value_list_sizeof(const void * _buffer,uint16_t value_mask)2741 xcb_configure_window_value_list_sizeof (const void  *_buffer,
2742                                         uint16_t     value_mask)
2743 {
2744     xcb_configure_window_value_list_t _aux;
2745     return xcb_configure_window_value_list_unpack(_buffer, value_mask, &_aux);
2746 }
2747 
2748 int
xcb_configure_window_sizeof(const void * _buffer)2749 xcb_configure_window_sizeof (const void  *_buffer)
2750 {
2751     char *xcb_tmp = (char *)_buffer;
2752     const xcb_configure_window_request_t *_aux = (xcb_configure_window_request_t *)_buffer;
2753     unsigned int xcb_buffer_len = 0;
2754     unsigned int xcb_block_len = 0;
2755     unsigned int xcb_pad = 0;
2756     unsigned int xcb_align_to = 0;
2757 
2758 
2759     xcb_block_len += sizeof(xcb_configure_window_request_t);
2760     xcb_tmp += xcb_block_len;
2761     xcb_buffer_len += xcb_block_len;
2762     xcb_block_len = 0;
2763     /* value_list */
2764     xcb_block_len += xcb_configure_window_value_list_sizeof(xcb_tmp, _aux->value_mask);
2765     xcb_tmp += xcb_block_len;
2766     xcb_align_to = ALIGNOF(char);
2767     /* insert padding */
2768     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2769     xcb_buffer_len += xcb_block_len + xcb_pad;
2770     if (0 != xcb_pad) {
2771         xcb_tmp += xcb_pad;
2772         xcb_pad = 0;
2773     }
2774     xcb_block_len = 0;
2775 
2776     return xcb_buffer_len;
2777 }
2778 
2779 xcb_void_cookie_t
xcb_configure_window_checked(xcb_connection_t * c,xcb_window_t window,uint16_t value_mask,const void * value_list)2780 xcb_configure_window_checked (xcb_connection_t *c,
2781                               xcb_window_t      window,
2782                               uint16_t          value_mask,
2783                               const void       *value_list)
2784 {
2785     static const xcb_protocol_request_t xcb_req = {
2786         .count = 3,
2787         .ext = 0,
2788         .opcode = XCB_CONFIGURE_WINDOW,
2789         .isvoid = 1
2790     };
2791 
2792     struct iovec xcb_parts[5];
2793     xcb_void_cookie_t xcb_ret;
2794     xcb_configure_window_request_t xcb_out;
2795 
2796     xcb_out.pad0 = 0;
2797     xcb_out.window = window;
2798     xcb_out.value_mask = value_mask;
2799     memset(xcb_out.pad1, 0, 2);
2800 
2801     xcb_parts[2].iov_base = (char *) &xcb_out;
2802     xcb_parts[2].iov_len = sizeof(xcb_out);
2803     xcb_parts[3].iov_base = 0;
2804     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2805     /* xcb_configure_window_value_list_t value_list */
2806     xcb_parts[4].iov_base = (char *) value_list;
2807     xcb_parts[4].iov_len =
2808       xcb_configure_window_value_list_sizeof (value_list, value_mask);
2809 
2810     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2811     return xcb_ret;
2812 }
2813 
2814 xcb_void_cookie_t
xcb_configure_window(xcb_connection_t * c,xcb_window_t window,uint16_t value_mask,const void * value_list)2815 xcb_configure_window (xcb_connection_t *c,
2816                       xcb_window_t      window,
2817                       uint16_t          value_mask,
2818                       const void       *value_list)
2819 {
2820     static const xcb_protocol_request_t xcb_req = {
2821         .count = 3,
2822         .ext = 0,
2823         .opcode = XCB_CONFIGURE_WINDOW,
2824         .isvoid = 1
2825     };
2826 
2827     struct iovec xcb_parts[5];
2828     xcb_void_cookie_t xcb_ret;
2829     xcb_configure_window_request_t xcb_out;
2830 
2831     xcb_out.pad0 = 0;
2832     xcb_out.window = window;
2833     xcb_out.value_mask = value_mask;
2834     memset(xcb_out.pad1, 0, 2);
2835 
2836     xcb_parts[2].iov_base = (char *) &xcb_out;
2837     xcb_parts[2].iov_len = sizeof(xcb_out);
2838     xcb_parts[3].iov_base = 0;
2839     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2840     /* xcb_configure_window_value_list_t value_list */
2841     xcb_parts[4].iov_base = (char *) value_list;
2842     xcb_parts[4].iov_len =
2843       xcb_configure_window_value_list_sizeof (value_list, value_mask);
2844 
2845     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2846     return xcb_ret;
2847 }
2848 
2849 xcb_void_cookie_t
xcb_configure_window_aux_checked(xcb_connection_t * c,xcb_window_t window,uint16_t value_mask,const xcb_configure_window_value_list_t * value_list)2850 xcb_configure_window_aux_checked (xcb_connection_t                        *c,
2851                                   xcb_window_t                             window,
2852                                   uint16_t                                 value_mask,
2853                                   const xcb_configure_window_value_list_t *value_list)
2854 {
2855     static const xcb_protocol_request_t xcb_req = {
2856         .count = 3,
2857         .ext = 0,
2858         .opcode = XCB_CONFIGURE_WINDOW,
2859         .isvoid = 1
2860     };
2861 
2862     struct iovec xcb_parts[5];
2863     xcb_void_cookie_t xcb_ret;
2864     xcb_configure_window_request_t xcb_out;
2865     void *xcb_aux0 = 0;
2866 
2867     xcb_out.pad0 = 0;
2868     xcb_out.window = window;
2869     xcb_out.value_mask = value_mask;
2870     memset(xcb_out.pad1, 0, 2);
2871 
2872     xcb_parts[2].iov_base = (char *) &xcb_out;
2873     xcb_parts[2].iov_len = sizeof(xcb_out);
2874     xcb_parts[3].iov_base = 0;
2875     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2876     /* xcb_configure_window_value_list_t value_list */
2877     xcb_parts[4].iov_len =
2878       xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
2879     xcb_parts[4].iov_base = xcb_aux0;
2880 
2881     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2882     free(xcb_aux0);
2883     return xcb_ret;
2884 }
2885 
2886 xcb_void_cookie_t
xcb_configure_window_aux(xcb_connection_t * c,xcb_window_t window,uint16_t value_mask,const xcb_configure_window_value_list_t * value_list)2887 xcb_configure_window_aux (xcb_connection_t                        *c,
2888                           xcb_window_t                             window,
2889                           uint16_t                                 value_mask,
2890                           const xcb_configure_window_value_list_t *value_list)
2891 {
2892     static const xcb_protocol_request_t xcb_req = {
2893         .count = 3,
2894         .ext = 0,
2895         .opcode = XCB_CONFIGURE_WINDOW,
2896         .isvoid = 1
2897     };
2898 
2899     struct iovec xcb_parts[5];
2900     xcb_void_cookie_t xcb_ret;
2901     xcb_configure_window_request_t xcb_out;
2902     void *xcb_aux0 = 0;
2903 
2904     xcb_out.pad0 = 0;
2905     xcb_out.window = window;
2906     xcb_out.value_mask = value_mask;
2907     memset(xcb_out.pad1, 0, 2);
2908 
2909     xcb_parts[2].iov_base = (char *) &xcb_out;
2910     xcb_parts[2].iov_len = sizeof(xcb_out);
2911     xcb_parts[3].iov_base = 0;
2912     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2913     /* xcb_configure_window_value_list_t value_list */
2914     xcb_parts[4].iov_len =
2915       xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
2916     xcb_parts[4].iov_base = xcb_aux0;
2917 
2918     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2919     free(xcb_aux0);
2920     return xcb_ret;
2921 }
2922 
2923 void *
xcb_configure_window_value_list(const xcb_configure_window_request_t * R)2924 xcb_configure_window_value_list (const xcb_configure_window_request_t *R)
2925 {
2926     return (void *) (R + 1);
2927 }
2928 
2929 xcb_void_cookie_t
xcb_circulate_window_checked(xcb_connection_t * c,uint8_t direction,xcb_window_t window)2930 xcb_circulate_window_checked (xcb_connection_t *c,
2931                               uint8_t           direction,
2932                               xcb_window_t      window)
2933 {
2934     static const xcb_protocol_request_t xcb_req = {
2935         .count = 2,
2936         .ext = 0,
2937         .opcode = XCB_CIRCULATE_WINDOW,
2938         .isvoid = 1
2939     };
2940 
2941     struct iovec xcb_parts[4];
2942     xcb_void_cookie_t xcb_ret;
2943     xcb_circulate_window_request_t xcb_out;
2944 
2945     xcb_out.direction = direction;
2946     xcb_out.window = window;
2947 
2948     xcb_parts[2].iov_base = (char *) &xcb_out;
2949     xcb_parts[2].iov_len = sizeof(xcb_out);
2950     xcb_parts[3].iov_base = 0;
2951     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2952 
2953     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2954     return xcb_ret;
2955 }
2956 
2957 xcb_void_cookie_t
xcb_circulate_window(xcb_connection_t * c,uint8_t direction,xcb_window_t window)2958 xcb_circulate_window (xcb_connection_t *c,
2959                       uint8_t           direction,
2960                       xcb_window_t      window)
2961 {
2962     static const xcb_protocol_request_t xcb_req = {
2963         .count = 2,
2964         .ext = 0,
2965         .opcode = XCB_CIRCULATE_WINDOW,
2966         .isvoid = 1
2967     };
2968 
2969     struct iovec xcb_parts[4];
2970     xcb_void_cookie_t xcb_ret;
2971     xcb_circulate_window_request_t xcb_out;
2972 
2973     xcb_out.direction = direction;
2974     xcb_out.window = window;
2975 
2976     xcb_parts[2].iov_base = (char *) &xcb_out;
2977     xcb_parts[2].iov_len = sizeof(xcb_out);
2978     xcb_parts[3].iov_base = 0;
2979     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2980 
2981     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2982     return xcb_ret;
2983 }
2984 
2985 xcb_get_geometry_cookie_t
xcb_get_geometry(xcb_connection_t * c,xcb_drawable_t drawable)2986 xcb_get_geometry (xcb_connection_t *c,
2987                   xcb_drawable_t    drawable)
2988 {
2989     static const xcb_protocol_request_t xcb_req = {
2990         .count = 2,
2991         .ext = 0,
2992         .opcode = XCB_GET_GEOMETRY,
2993         .isvoid = 0
2994     };
2995 
2996     struct iovec xcb_parts[4];
2997     xcb_get_geometry_cookie_t xcb_ret;
2998     xcb_get_geometry_request_t xcb_out;
2999 
3000     xcb_out.pad0 = 0;
3001     xcb_out.drawable = drawable;
3002 
3003     xcb_parts[2].iov_base = (char *) &xcb_out;
3004     xcb_parts[2].iov_len = sizeof(xcb_out);
3005     xcb_parts[3].iov_base = 0;
3006     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3007 
3008     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3009     return xcb_ret;
3010 }
3011 
3012 xcb_get_geometry_cookie_t
xcb_get_geometry_unchecked(xcb_connection_t * c,xcb_drawable_t drawable)3013 xcb_get_geometry_unchecked (xcb_connection_t *c,
3014                             xcb_drawable_t    drawable)
3015 {
3016     static const xcb_protocol_request_t xcb_req = {
3017         .count = 2,
3018         .ext = 0,
3019         .opcode = XCB_GET_GEOMETRY,
3020         .isvoid = 0
3021     };
3022 
3023     struct iovec xcb_parts[4];
3024     xcb_get_geometry_cookie_t xcb_ret;
3025     xcb_get_geometry_request_t xcb_out;
3026 
3027     xcb_out.pad0 = 0;
3028     xcb_out.drawable = drawable;
3029 
3030     xcb_parts[2].iov_base = (char *) &xcb_out;
3031     xcb_parts[2].iov_len = sizeof(xcb_out);
3032     xcb_parts[3].iov_base = 0;
3033     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3034 
3035     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3036     return xcb_ret;
3037 }
3038 
3039 xcb_get_geometry_reply_t *
xcb_get_geometry_reply(xcb_connection_t * c,xcb_get_geometry_cookie_t cookie,xcb_generic_error_t ** e)3040 xcb_get_geometry_reply (xcb_connection_t           *c,
3041                         xcb_get_geometry_cookie_t   cookie  /**< */,
3042                         xcb_generic_error_t       **e)
3043 {
3044     return (xcb_get_geometry_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3045 }
3046 
3047 int
xcb_query_tree_sizeof(const void * _buffer)3048 xcb_query_tree_sizeof (const void  *_buffer)
3049 {
3050     char *xcb_tmp = (char *)_buffer;
3051     const xcb_query_tree_reply_t *_aux = (xcb_query_tree_reply_t *)_buffer;
3052     unsigned int xcb_buffer_len = 0;
3053     unsigned int xcb_block_len = 0;
3054     unsigned int xcb_pad = 0;
3055     unsigned int xcb_align_to = 0;
3056 
3057 
3058     xcb_block_len += sizeof(xcb_query_tree_reply_t);
3059     xcb_tmp += xcb_block_len;
3060     xcb_buffer_len += xcb_block_len;
3061     xcb_block_len = 0;
3062     /* children */
3063     xcb_block_len += _aux->children_len * sizeof(xcb_window_t);
3064     xcb_tmp += xcb_block_len;
3065     xcb_align_to = ALIGNOF(xcb_window_t);
3066     /* insert padding */
3067     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3068     xcb_buffer_len += xcb_block_len + xcb_pad;
3069     if (0 != xcb_pad) {
3070         xcb_tmp += xcb_pad;
3071         xcb_pad = 0;
3072     }
3073     xcb_block_len = 0;
3074 
3075     return xcb_buffer_len;
3076 }
3077 
3078 xcb_query_tree_cookie_t
xcb_query_tree(xcb_connection_t * c,xcb_window_t window)3079 xcb_query_tree (xcb_connection_t *c,
3080                 xcb_window_t      window)
3081 {
3082     static const xcb_protocol_request_t xcb_req = {
3083         .count = 2,
3084         .ext = 0,
3085         .opcode = XCB_QUERY_TREE,
3086         .isvoid = 0
3087     };
3088 
3089     struct iovec xcb_parts[4];
3090     xcb_query_tree_cookie_t xcb_ret;
3091     xcb_query_tree_request_t xcb_out;
3092 
3093     xcb_out.pad0 = 0;
3094     xcb_out.window = window;
3095 
3096     xcb_parts[2].iov_base = (char *) &xcb_out;
3097     xcb_parts[2].iov_len = sizeof(xcb_out);
3098     xcb_parts[3].iov_base = 0;
3099     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3100 
3101     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3102     return xcb_ret;
3103 }
3104 
3105 xcb_query_tree_cookie_t
xcb_query_tree_unchecked(xcb_connection_t * c,xcb_window_t window)3106 xcb_query_tree_unchecked (xcb_connection_t *c,
3107                           xcb_window_t      window)
3108 {
3109     static const xcb_protocol_request_t xcb_req = {
3110         .count = 2,
3111         .ext = 0,
3112         .opcode = XCB_QUERY_TREE,
3113         .isvoid = 0
3114     };
3115 
3116     struct iovec xcb_parts[4];
3117     xcb_query_tree_cookie_t xcb_ret;
3118     xcb_query_tree_request_t xcb_out;
3119 
3120     xcb_out.pad0 = 0;
3121     xcb_out.window = window;
3122 
3123     xcb_parts[2].iov_base = (char *) &xcb_out;
3124     xcb_parts[2].iov_len = sizeof(xcb_out);
3125     xcb_parts[3].iov_base = 0;
3126     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3127 
3128     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3129     return xcb_ret;
3130 }
3131 
3132 xcb_window_t *
xcb_query_tree_children(const xcb_query_tree_reply_t * R)3133 xcb_query_tree_children (const xcb_query_tree_reply_t *R)
3134 {
3135     return (xcb_window_t *) (R + 1);
3136 }
3137 
3138 int
xcb_query_tree_children_length(const xcb_query_tree_reply_t * R)3139 xcb_query_tree_children_length (const xcb_query_tree_reply_t *R)
3140 {
3141     return R->children_len;
3142 }
3143 
3144 xcb_generic_iterator_t
xcb_query_tree_children_end(const xcb_query_tree_reply_t * R)3145 xcb_query_tree_children_end (const xcb_query_tree_reply_t *R)
3146 {
3147     xcb_generic_iterator_t i;
3148     i.data = ((xcb_window_t *) (R + 1)) + (R->children_len);
3149     i.rem = 0;
3150     i.index = (char *) i.data - (char *) R;
3151     return i;
3152 }
3153 
3154 xcb_query_tree_reply_t *
xcb_query_tree_reply(xcb_connection_t * c,xcb_query_tree_cookie_t cookie,xcb_generic_error_t ** e)3155 xcb_query_tree_reply (xcb_connection_t         *c,
3156                       xcb_query_tree_cookie_t   cookie  /**< */,
3157                       xcb_generic_error_t     **e)
3158 {
3159     return (xcb_query_tree_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3160 }
3161 
3162 int
xcb_intern_atom_sizeof(const void * _buffer)3163 xcb_intern_atom_sizeof (const void  *_buffer)
3164 {
3165     char *xcb_tmp = (char *)_buffer;
3166     const xcb_intern_atom_request_t *_aux = (xcb_intern_atom_request_t *)_buffer;
3167     unsigned int xcb_buffer_len = 0;
3168     unsigned int xcb_block_len = 0;
3169     unsigned int xcb_pad = 0;
3170     unsigned int xcb_align_to = 0;
3171 
3172 
3173     xcb_block_len += sizeof(xcb_intern_atom_request_t);
3174     xcb_tmp += xcb_block_len;
3175     xcb_buffer_len += xcb_block_len;
3176     xcb_block_len = 0;
3177     /* name */
3178     xcb_block_len += _aux->name_len * sizeof(char);
3179     xcb_tmp += xcb_block_len;
3180     xcb_align_to = ALIGNOF(char);
3181     /* insert padding */
3182     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3183     xcb_buffer_len += xcb_block_len + xcb_pad;
3184     if (0 != xcb_pad) {
3185         xcb_tmp += xcb_pad;
3186         xcb_pad = 0;
3187     }
3188     xcb_block_len = 0;
3189 
3190     return xcb_buffer_len;
3191 }
3192 
3193 xcb_intern_atom_cookie_t
xcb_intern_atom(xcb_connection_t * c,uint8_t only_if_exists,uint16_t name_len,const char * name)3194 xcb_intern_atom (xcb_connection_t *c,
3195                  uint8_t           only_if_exists,
3196                  uint16_t          name_len,
3197                  const char       *name)
3198 {
3199     static const xcb_protocol_request_t xcb_req = {
3200         .count = 4,
3201         .ext = 0,
3202         .opcode = XCB_INTERN_ATOM,
3203         .isvoid = 0
3204     };
3205 
3206     struct iovec xcb_parts[6];
3207     xcb_intern_atom_cookie_t xcb_ret;
3208     xcb_intern_atom_request_t xcb_out;
3209 
3210     xcb_out.only_if_exists = only_if_exists;
3211     xcb_out.name_len = name_len;
3212     memset(xcb_out.pad0, 0, 2);
3213 
3214     xcb_parts[2].iov_base = (char *) &xcb_out;
3215     xcb_parts[2].iov_len = sizeof(xcb_out);
3216     xcb_parts[3].iov_base = 0;
3217     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3218     /* char name */
3219     xcb_parts[4].iov_base = (char *) name;
3220     xcb_parts[4].iov_len = name_len * sizeof(char);
3221     xcb_parts[5].iov_base = 0;
3222     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3223 
3224     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3225     return xcb_ret;
3226 }
3227 
3228 xcb_intern_atom_cookie_t
xcb_intern_atom_unchecked(xcb_connection_t * c,uint8_t only_if_exists,uint16_t name_len,const char * name)3229 xcb_intern_atom_unchecked (xcb_connection_t *c,
3230                            uint8_t           only_if_exists,
3231                            uint16_t          name_len,
3232                            const char       *name)
3233 {
3234     static const xcb_protocol_request_t xcb_req = {
3235         .count = 4,
3236         .ext = 0,
3237         .opcode = XCB_INTERN_ATOM,
3238         .isvoid = 0
3239     };
3240 
3241     struct iovec xcb_parts[6];
3242     xcb_intern_atom_cookie_t xcb_ret;
3243     xcb_intern_atom_request_t xcb_out;
3244 
3245     xcb_out.only_if_exists = only_if_exists;
3246     xcb_out.name_len = name_len;
3247     memset(xcb_out.pad0, 0, 2);
3248 
3249     xcb_parts[2].iov_base = (char *) &xcb_out;
3250     xcb_parts[2].iov_len = sizeof(xcb_out);
3251     xcb_parts[3].iov_base = 0;
3252     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3253     /* char name */
3254     xcb_parts[4].iov_base = (char *) name;
3255     xcb_parts[4].iov_len = name_len * sizeof(char);
3256     xcb_parts[5].iov_base = 0;
3257     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3258 
3259     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3260     return xcb_ret;
3261 }
3262 
3263 xcb_intern_atom_reply_t *
xcb_intern_atom_reply(xcb_connection_t * c,xcb_intern_atom_cookie_t cookie,xcb_generic_error_t ** e)3264 xcb_intern_atom_reply (xcb_connection_t          *c,
3265                        xcb_intern_atom_cookie_t   cookie  /**< */,
3266                        xcb_generic_error_t      **e)
3267 {
3268     return (xcb_intern_atom_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3269 }
3270 
3271 int
xcb_get_atom_name_sizeof(const void * _buffer)3272 xcb_get_atom_name_sizeof (const void  *_buffer)
3273 {
3274     char *xcb_tmp = (char *)_buffer;
3275     const xcb_get_atom_name_reply_t *_aux = (xcb_get_atom_name_reply_t *)_buffer;
3276     unsigned int xcb_buffer_len = 0;
3277     unsigned int xcb_block_len = 0;
3278     unsigned int xcb_pad = 0;
3279     unsigned int xcb_align_to = 0;
3280 
3281 
3282     xcb_block_len += sizeof(xcb_get_atom_name_reply_t);
3283     xcb_tmp += xcb_block_len;
3284     xcb_buffer_len += xcb_block_len;
3285     xcb_block_len = 0;
3286     /* name */
3287     xcb_block_len += _aux->name_len * sizeof(char);
3288     xcb_tmp += xcb_block_len;
3289     xcb_align_to = ALIGNOF(char);
3290     /* insert padding */
3291     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3292     xcb_buffer_len += xcb_block_len + xcb_pad;
3293     if (0 != xcb_pad) {
3294         xcb_tmp += xcb_pad;
3295         xcb_pad = 0;
3296     }
3297     xcb_block_len = 0;
3298 
3299     return xcb_buffer_len;
3300 }
3301 
3302 xcb_get_atom_name_cookie_t
xcb_get_atom_name(xcb_connection_t * c,xcb_atom_t atom)3303 xcb_get_atom_name (xcb_connection_t *c,
3304                    xcb_atom_t        atom)
3305 {
3306     static const xcb_protocol_request_t xcb_req = {
3307         .count = 2,
3308         .ext = 0,
3309         .opcode = XCB_GET_ATOM_NAME,
3310         .isvoid = 0
3311     };
3312 
3313     struct iovec xcb_parts[4];
3314     xcb_get_atom_name_cookie_t xcb_ret;
3315     xcb_get_atom_name_request_t xcb_out;
3316 
3317     xcb_out.pad0 = 0;
3318     xcb_out.atom = atom;
3319 
3320     xcb_parts[2].iov_base = (char *) &xcb_out;
3321     xcb_parts[2].iov_len = sizeof(xcb_out);
3322     xcb_parts[3].iov_base = 0;
3323     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3324 
3325     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3326     return xcb_ret;
3327 }
3328 
3329 xcb_get_atom_name_cookie_t
xcb_get_atom_name_unchecked(xcb_connection_t * c,xcb_atom_t atom)3330 xcb_get_atom_name_unchecked (xcb_connection_t *c,
3331                              xcb_atom_t        atom)
3332 {
3333     static const xcb_protocol_request_t xcb_req = {
3334         .count = 2,
3335         .ext = 0,
3336         .opcode = XCB_GET_ATOM_NAME,
3337         .isvoid = 0
3338     };
3339 
3340     struct iovec xcb_parts[4];
3341     xcb_get_atom_name_cookie_t xcb_ret;
3342     xcb_get_atom_name_request_t xcb_out;
3343 
3344     xcb_out.pad0 = 0;
3345     xcb_out.atom = atom;
3346 
3347     xcb_parts[2].iov_base = (char *) &xcb_out;
3348     xcb_parts[2].iov_len = sizeof(xcb_out);
3349     xcb_parts[3].iov_base = 0;
3350     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3351 
3352     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3353     return xcb_ret;
3354 }
3355 
3356 char *
xcb_get_atom_name_name(const xcb_get_atom_name_reply_t * R)3357 xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R)
3358 {
3359     return (char *) (R + 1);
3360 }
3361 
3362 int
xcb_get_atom_name_name_length(const xcb_get_atom_name_reply_t * R)3363 xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R)
3364 {
3365     return R->name_len;
3366 }
3367 
3368 xcb_generic_iterator_t
xcb_get_atom_name_name_end(const xcb_get_atom_name_reply_t * R)3369 xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R)
3370 {
3371     xcb_generic_iterator_t i;
3372     i.data = ((char *) (R + 1)) + (R->name_len);
3373     i.rem = 0;
3374     i.index = (char *) i.data - (char *) R;
3375     return i;
3376 }
3377 
3378 xcb_get_atom_name_reply_t *
xcb_get_atom_name_reply(xcb_connection_t * c,xcb_get_atom_name_cookie_t cookie,xcb_generic_error_t ** e)3379 xcb_get_atom_name_reply (xcb_connection_t            *c,
3380                          xcb_get_atom_name_cookie_t   cookie  /**< */,
3381                          xcb_generic_error_t        **e)
3382 {
3383     return (xcb_get_atom_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3384 }
3385 
3386 int
xcb_change_property_sizeof(const void * _buffer)3387 xcb_change_property_sizeof (const void  *_buffer)
3388 {
3389     char *xcb_tmp = (char *)_buffer;
3390     const xcb_change_property_request_t *_aux = (xcb_change_property_request_t *)_buffer;
3391     unsigned int xcb_buffer_len = 0;
3392     unsigned int xcb_block_len = 0;
3393     unsigned int xcb_pad = 0;
3394     unsigned int xcb_align_to = 0;
3395 
3396 
3397     xcb_block_len += sizeof(xcb_change_property_request_t);
3398     xcb_tmp += xcb_block_len;
3399     xcb_buffer_len += xcb_block_len;
3400     xcb_block_len = 0;
3401     /* data */
3402     xcb_block_len += ((_aux->data_len * _aux->format) / 8) * sizeof(char);
3403     xcb_tmp += xcb_block_len;
3404     xcb_align_to = ALIGNOF(char);
3405     /* insert padding */
3406     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3407     xcb_buffer_len += xcb_block_len + xcb_pad;
3408     if (0 != xcb_pad) {
3409         xcb_tmp += xcb_pad;
3410         xcb_pad = 0;
3411     }
3412     xcb_block_len = 0;
3413 
3414     return xcb_buffer_len;
3415 }
3416 
3417 xcb_void_cookie_t
xcb_change_property_checked(xcb_connection_t * c,uint8_t mode,xcb_window_t window,xcb_atom_t property,xcb_atom_t type,uint8_t format,uint32_t data_len,const void * data)3418 xcb_change_property_checked (xcb_connection_t *c,
3419                              uint8_t           mode,
3420                              xcb_window_t      window,
3421                              xcb_atom_t        property,
3422                              xcb_atom_t        type,
3423                              uint8_t           format,
3424                              uint32_t          data_len,
3425                              const void       *data)
3426 {
3427     static const xcb_protocol_request_t xcb_req = {
3428         .count = 4,
3429         .ext = 0,
3430         .opcode = XCB_CHANGE_PROPERTY,
3431         .isvoid = 1
3432     };
3433 
3434     struct iovec xcb_parts[6];
3435     xcb_void_cookie_t xcb_ret;
3436     xcb_change_property_request_t xcb_out;
3437 
3438     xcb_out.mode = mode;
3439     xcb_out.window = window;
3440     xcb_out.property = property;
3441     xcb_out.type = type;
3442     xcb_out.format = format;
3443     memset(xcb_out.pad0, 0, 3);
3444     xcb_out.data_len = data_len;
3445 
3446     xcb_parts[2].iov_base = (char *) &xcb_out;
3447     xcb_parts[2].iov_len = sizeof(xcb_out);
3448     xcb_parts[3].iov_base = 0;
3449     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3450     /* void data */
3451     xcb_parts[4].iov_base = (char *) data;
3452     xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char);
3453     xcb_parts[5].iov_base = 0;
3454     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3455 
3456     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3457     return xcb_ret;
3458 }
3459 
3460 xcb_void_cookie_t
xcb_change_property(xcb_connection_t * c,uint8_t mode,xcb_window_t window,xcb_atom_t property,xcb_atom_t type,uint8_t format,uint32_t data_len,const void * data)3461 xcb_change_property (xcb_connection_t *c,
3462                      uint8_t           mode,
3463                      xcb_window_t      window,
3464                      xcb_atom_t        property,
3465                      xcb_atom_t        type,
3466                      uint8_t           format,
3467                      uint32_t          data_len,
3468                      const void       *data)
3469 {
3470     static const xcb_protocol_request_t xcb_req = {
3471         .count = 4,
3472         .ext = 0,
3473         .opcode = XCB_CHANGE_PROPERTY,
3474         .isvoid = 1
3475     };
3476 
3477     struct iovec xcb_parts[6];
3478     xcb_void_cookie_t xcb_ret;
3479     xcb_change_property_request_t xcb_out;
3480 
3481     xcb_out.mode = mode;
3482     xcb_out.window = window;
3483     xcb_out.property = property;
3484     xcb_out.type = type;
3485     xcb_out.format = format;
3486     memset(xcb_out.pad0, 0, 3);
3487     xcb_out.data_len = data_len;
3488 
3489     xcb_parts[2].iov_base = (char *) &xcb_out;
3490     xcb_parts[2].iov_len = sizeof(xcb_out);
3491     xcb_parts[3].iov_base = 0;
3492     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3493     /* void data */
3494     xcb_parts[4].iov_base = (char *) data;
3495     xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char);
3496     xcb_parts[5].iov_base = 0;
3497     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
3498 
3499     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3500     return xcb_ret;
3501 }
3502 
3503 void *
xcb_change_property_data(const xcb_change_property_request_t * R)3504 xcb_change_property_data (const xcb_change_property_request_t *R)
3505 {
3506     return (void *) (R + 1);
3507 }
3508 
3509 int
xcb_change_property_data_length(const xcb_change_property_request_t * R)3510 xcb_change_property_data_length (const xcb_change_property_request_t *R)
3511 {
3512     return ((R->data_len * R->format) / 8);
3513 }
3514 
3515 xcb_generic_iterator_t
xcb_change_property_data_end(const xcb_change_property_request_t * R)3516 xcb_change_property_data_end (const xcb_change_property_request_t *R)
3517 {
3518     xcb_generic_iterator_t i;
3519     i.data = ((char *) (R + 1)) + (((R->data_len * R->format) / 8));
3520     i.rem = 0;
3521     i.index = (char *) i.data - (char *) R;
3522     return i;
3523 }
3524 
3525 xcb_void_cookie_t
xcb_delete_property_checked(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)3526 xcb_delete_property_checked (xcb_connection_t *c,
3527                              xcb_window_t      window,
3528                              xcb_atom_t        property)
3529 {
3530     static const xcb_protocol_request_t xcb_req = {
3531         .count = 2,
3532         .ext = 0,
3533         .opcode = XCB_DELETE_PROPERTY,
3534         .isvoid = 1
3535     };
3536 
3537     struct iovec xcb_parts[4];
3538     xcb_void_cookie_t xcb_ret;
3539     xcb_delete_property_request_t xcb_out;
3540 
3541     xcb_out.pad0 = 0;
3542     xcb_out.window = window;
3543     xcb_out.property = property;
3544 
3545     xcb_parts[2].iov_base = (char *) &xcb_out;
3546     xcb_parts[2].iov_len = sizeof(xcb_out);
3547     xcb_parts[3].iov_base = 0;
3548     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3549 
3550     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3551     return xcb_ret;
3552 }
3553 
3554 xcb_void_cookie_t
xcb_delete_property(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)3555 xcb_delete_property (xcb_connection_t *c,
3556                      xcb_window_t      window,
3557                      xcb_atom_t        property)
3558 {
3559     static const xcb_protocol_request_t xcb_req = {
3560         .count = 2,
3561         .ext = 0,
3562         .opcode = XCB_DELETE_PROPERTY,
3563         .isvoid = 1
3564     };
3565 
3566     struct iovec xcb_parts[4];
3567     xcb_void_cookie_t xcb_ret;
3568     xcb_delete_property_request_t xcb_out;
3569 
3570     xcb_out.pad0 = 0;
3571     xcb_out.window = window;
3572     xcb_out.property = property;
3573 
3574     xcb_parts[2].iov_base = (char *) &xcb_out;
3575     xcb_parts[2].iov_len = sizeof(xcb_out);
3576     xcb_parts[3].iov_base = 0;
3577     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3578 
3579     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3580     return xcb_ret;
3581 }
3582 
3583 int
xcb_get_property_sizeof(const void * _buffer)3584 xcb_get_property_sizeof (const void  *_buffer)
3585 {
3586     char *xcb_tmp = (char *)_buffer;
3587     const xcb_get_property_reply_t *_aux = (xcb_get_property_reply_t *)_buffer;
3588     unsigned int xcb_buffer_len = 0;
3589     unsigned int xcb_block_len = 0;
3590     unsigned int xcb_pad = 0;
3591     unsigned int xcb_align_to = 0;
3592 
3593 
3594     xcb_block_len += sizeof(xcb_get_property_reply_t);
3595     xcb_tmp += xcb_block_len;
3596     xcb_buffer_len += xcb_block_len;
3597     xcb_block_len = 0;
3598     /* value */
3599     xcb_block_len += (_aux->value_len * (_aux->format / 8)) * sizeof(char);
3600     xcb_tmp += xcb_block_len;
3601     xcb_align_to = ALIGNOF(char);
3602     /* insert padding */
3603     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3604     xcb_buffer_len += xcb_block_len + xcb_pad;
3605     if (0 != xcb_pad) {
3606         xcb_tmp += xcb_pad;
3607         xcb_pad = 0;
3608     }
3609     xcb_block_len = 0;
3610 
3611     return xcb_buffer_len;
3612 }
3613 
3614 xcb_get_property_cookie_t
xcb_get_property(xcb_connection_t * c,uint8_t _delete,xcb_window_t window,xcb_atom_t property,xcb_atom_t type,uint32_t long_offset,uint32_t long_length)3615 xcb_get_property (xcb_connection_t *c,
3616                   uint8_t           _delete,
3617                   xcb_window_t      window,
3618                   xcb_atom_t        property,
3619                   xcb_atom_t        type,
3620                   uint32_t          long_offset,
3621                   uint32_t          long_length)
3622 {
3623     static const xcb_protocol_request_t xcb_req = {
3624         .count = 2,
3625         .ext = 0,
3626         .opcode = XCB_GET_PROPERTY,
3627         .isvoid = 0
3628     };
3629 
3630     struct iovec xcb_parts[4];
3631     xcb_get_property_cookie_t xcb_ret;
3632     xcb_get_property_request_t xcb_out;
3633 
3634     xcb_out._delete = _delete;
3635     xcb_out.window = window;
3636     xcb_out.property = property;
3637     xcb_out.type = type;
3638     xcb_out.long_offset = long_offset;
3639     xcb_out.long_length = long_length;
3640 
3641     xcb_parts[2].iov_base = (char *) &xcb_out;
3642     xcb_parts[2].iov_len = sizeof(xcb_out);
3643     xcb_parts[3].iov_base = 0;
3644     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3645 
3646     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3647     return xcb_ret;
3648 }
3649 
3650 xcb_get_property_cookie_t
xcb_get_property_unchecked(xcb_connection_t * c,uint8_t _delete,xcb_window_t window,xcb_atom_t property,xcb_atom_t type,uint32_t long_offset,uint32_t long_length)3651 xcb_get_property_unchecked (xcb_connection_t *c,
3652                             uint8_t           _delete,
3653                             xcb_window_t      window,
3654                             xcb_atom_t        property,
3655                             xcb_atom_t        type,
3656                             uint32_t          long_offset,
3657                             uint32_t          long_length)
3658 {
3659     static const xcb_protocol_request_t xcb_req = {
3660         .count = 2,
3661         .ext = 0,
3662         .opcode = XCB_GET_PROPERTY,
3663         .isvoid = 0
3664     };
3665 
3666     struct iovec xcb_parts[4];
3667     xcb_get_property_cookie_t xcb_ret;
3668     xcb_get_property_request_t xcb_out;
3669 
3670     xcb_out._delete = _delete;
3671     xcb_out.window = window;
3672     xcb_out.property = property;
3673     xcb_out.type = type;
3674     xcb_out.long_offset = long_offset;
3675     xcb_out.long_length = long_length;
3676 
3677     xcb_parts[2].iov_base = (char *) &xcb_out;
3678     xcb_parts[2].iov_len = sizeof(xcb_out);
3679     xcb_parts[3].iov_base = 0;
3680     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3681 
3682     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3683     return xcb_ret;
3684 }
3685 
3686 void *
xcb_get_property_value(const xcb_get_property_reply_t * R)3687 xcb_get_property_value (const xcb_get_property_reply_t *R)
3688 {
3689     return (void *) (R + 1);
3690 }
3691 
3692 int
xcb_get_property_value_length(const xcb_get_property_reply_t * R)3693 xcb_get_property_value_length (const xcb_get_property_reply_t *R)
3694 {
3695     return (R->value_len * (R->format / 8));
3696 }
3697 
3698 xcb_generic_iterator_t
xcb_get_property_value_end(const xcb_get_property_reply_t * R)3699 xcb_get_property_value_end (const xcb_get_property_reply_t *R)
3700 {
3701     xcb_generic_iterator_t i;
3702     i.data = ((char *) (R + 1)) + ((R->value_len * (R->format / 8)));
3703     i.rem = 0;
3704     i.index = (char *) i.data - (char *) R;
3705     return i;
3706 }
3707 
3708 xcb_get_property_reply_t *
xcb_get_property_reply(xcb_connection_t * c,xcb_get_property_cookie_t cookie,xcb_generic_error_t ** e)3709 xcb_get_property_reply (xcb_connection_t           *c,
3710                         xcb_get_property_cookie_t   cookie  /**< */,
3711                         xcb_generic_error_t       **e)
3712 {
3713     return (xcb_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3714 }
3715 
3716 int
xcb_list_properties_sizeof(const void * _buffer)3717 xcb_list_properties_sizeof (const void  *_buffer)
3718 {
3719     char *xcb_tmp = (char *)_buffer;
3720     const xcb_list_properties_reply_t *_aux = (xcb_list_properties_reply_t *)_buffer;
3721     unsigned int xcb_buffer_len = 0;
3722     unsigned int xcb_block_len = 0;
3723     unsigned int xcb_pad = 0;
3724     unsigned int xcb_align_to = 0;
3725 
3726 
3727     xcb_block_len += sizeof(xcb_list_properties_reply_t);
3728     xcb_tmp += xcb_block_len;
3729     xcb_buffer_len += xcb_block_len;
3730     xcb_block_len = 0;
3731     /* atoms */
3732     xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t);
3733     xcb_tmp += xcb_block_len;
3734     xcb_align_to = ALIGNOF(xcb_atom_t);
3735     /* insert padding */
3736     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3737     xcb_buffer_len += xcb_block_len + xcb_pad;
3738     if (0 != xcb_pad) {
3739         xcb_tmp += xcb_pad;
3740         xcb_pad = 0;
3741     }
3742     xcb_block_len = 0;
3743 
3744     return xcb_buffer_len;
3745 }
3746 
3747 xcb_list_properties_cookie_t
xcb_list_properties(xcb_connection_t * c,xcb_window_t window)3748 xcb_list_properties (xcb_connection_t *c,
3749                      xcb_window_t      window)
3750 {
3751     static const xcb_protocol_request_t xcb_req = {
3752         .count = 2,
3753         .ext = 0,
3754         .opcode = XCB_LIST_PROPERTIES,
3755         .isvoid = 0
3756     };
3757 
3758     struct iovec xcb_parts[4];
3759     xcb_list_properties_cookie_t xcb_ret;
3760     xcb_list_properties_request_t xcb_out;
3761 
3762     xcb_out.pad0 = 0;
3763     xcb_out.window = window;
3764 
3765     xcb_parts[2].iov_base = (char *) &xcb_out;
3766     xcb_parts[2].iov_len = sizeof(xcb_out);
3767     xcb_parts[3].iov_base = 0;
3768     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3769 
3770     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3771     return xcb_ret;
3772 }
3773 
3774 xcb_list_properties_cookie_t
xcb_list_properties_unchecked(xcb_connection_t * c,xcb_window_t window)3775 xcb_list_properties_unchecked (xcb_connection_t *c,
3776                                xcb_window_t      window)
3777 {
3778     static const xcb_protocol_request_t xcb_req = {
3779         .count = 2,
3780         .ext = 0,
3781         .opcode = XCB_LIST_PROPERTIES,
3782         .isvoid = 0
3783     };
3784 
3785     struct iovec xcb_parts[4];
3786     xcb_list_properties_cookie_t xcb_ret;
3787     xcb_list_properties_request_t xcb_out;
3788 
3789     xcb_out.pad0 = 0;
3790     xcb_out.window = window;
3791 
3792     xcb_parts[2].iov_base = (char *) &xcb_out;
3793     xcb_parts[2].iov_len = sizeof(xcb_out);
3794     xcb_parts[3].iov_base = 0;
3795     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3796 
3797     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3798     return xcb_ret;
3799 }
3800 
3801 xcb_atom_t *
xcb_list_properties_atoms(const xcb_list_properties_reply_t * R)3802 xcb_list_properties_atoms (const xcb_list_properties_reply_t *R)
3803 {
3804     return (xcb_atom_t *) (R + 1);
3805 }
3806 
3807 int
xcb_list_properties_atoms_length(const xcb_list_properties_reply_t * R)3808 xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R)
3809 {
3810     return R->atoms_len;
3811 }
3812 
3813 xcb_generic_iterator_t
xcb_list_properties_atoms_end(const xcb_list_properties_reply_t * R)3814 xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R)
3815 {
3816     xcb_generic_iterator_t i;
3817     i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len);
3818     i.rem = 0;
3819     i.index = (char *) i.data - (char *) R;
3820     return i;
3821 }
3822 
3823 xcb_list_properties_reply_t *
xcb_list_properties_reply(xcb_connection_t * c,xcb_list_properties_cookie_t cookie,xcb_generic_error_t ** e)3824 xcb_list_properties_reply (xcb_connection_t              *c,
3825                            xcb_list_properties_cookie_t   cookie  /**< */,
3826                            xcb_generic_error_t          **e)
3827 {
3828     return (xcb_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3829 }
3830 
3831 xcb_void_cookie_t
xcb_set_selection_owner_checked(xcb_connection_t * c,xcb_window_t owner,xcb_atom_t selection,xcb_timestamp_t time)3832 xcb_set_selection_owner_checked (xcb_connection_t *c,
3833                                  xcb_window_t      owner,
3834                                  xcb_atom_t        selection,
3835                                  xcb_timestamp_t   time)
3836 {
3837     static const xcb_protocol_request_t xcb_req = {
3838         .count = 2,
3839         .ext = 0,
3840         .opcode = XCB_SET_SELECTION_OWNER,
3841         .isvoid = 1
3842     };
3843 
3844     struct iovec xcb_parts[4];
3845     xcb_void_cookie_t xcb_ret;
3846     xcb_set_selection_owner_request_t xcb_out;
3847 
3848     xcb_out.pad0 = 0;
3849     xcb_out.owner = owner;
3850     xcb_out.selection = selection;
3851     xcb_out.time = time;
3852 
3853     xcb_parts[2].iov_base = (char *) &xcb_out;
3854     xcb_parts[2].iov_len = sizeof(xcb_out);
3855     xcb_parts[3].iov_base = 0;
3856     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3857 
3858     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3859     return xcb_ret;
3860 }
3861 
3862 xcb_void_cookie_t
xcb_set_selection_owner(xcb_connection_t * c,xcb_window_t owner,xcb_atom_t selection,xcb_timestamp_t time)3863 xcb_set_selection_owner (xcb_connection_t *c,
3864                          xcb_window_t      owner,
3865                          xcb_atom_t        selection,
3866                          xcb_timestamp_t   time)
3867 {
3868     static const xcb_protocol_request_t xcb_req = {
3869         .count = 2,
3870         .ext = 0,
3871         .opcode = XCB_SET_SELECTION_OWNER,
3872         .isvoid = 1
3873     };
3874 
3875     struct iovec xcb_parts[4];
3876     xcb_void_cookie_t xcb_ret;
3877     xcb_set_selection_owner_request_t xcb_out;
3878 
3879     xcb_out.pad0 = 0;
3880     xcb_out.owner = owner;
3881     xcb_out.selection = selection;
3882     xcb_out.time = time;
3883 
3884     xcb_parts[2].iov_base = (char *) &xcb_out;
3885     xcb_parts[2].iov_len = sizeof(xcb_out);
3886     xcb_parts[3].iov_base = 0;
3887     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3888 
3889     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3890     return xcb_ret;
3891 }
3892 
3893 xcb_get_selection_owner_cookie_t
xcb_get_selection_owner(xcb_connection_t * c,xcb_atom_t selection)3894 xcb_get_selection_owner (xcb_connection_t *c,
3895                          xcb_atom_t        selection)
3896 {
3897     static const xcb_protocol_request_t xcb_req = {
3898         .count = 2,
3899         .ext = 0,
3900         .opcode = XCB_GET_SELECTION_OWNER,
3901         .isvoid = 0
3902     };
3903 
3904     struct iovec xcb_parts[4];
3905     xcb_get_selection_owner_cookie_t xcb_ret;
3906     xcb_get_selection_owner_request_t xcb_out;
3907 
3908     xcb_out.pad0 = 0;
3909     xcb_out.selection = selection;
3910 
3911     xcb_parts[2].iov_base = (char *) &xcb_out;
3912     xcb_parts[2].iov_len = sizeof(xcb_out);
3913     xcb_parts[3].iov_base = 0;
3914     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3915 
3916     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3917     return xcb_ret;
3918 }
3919 
3920 xcb_get_selection_owner_cookie_t
xcb_get_selection_owner_unchecked(xcb_connection_t * c,xcb_atom_t selection)3921 xcb_get_selection_owner_unchecked (xcb_connection_t *c,
3922                                    xcb_atom_t        selection)
3923 {
3924     static const xcb_protocol_request_t xcb_req = {
3925         .count = 2,
3926         .ext = 0,
3927         .opcode = XCB_GET_SELECTION_OWNER,
3928         .isvoid = 0
3929     };
3930 
3931     struct iovec xcb_parts[4];
3932     xcb_get_selection_owner_cookie_t xcb_ret;
3933     xcb_get_selection_owner_request_t xcb_out;
3934 
3935     xcb_out.pad0 = 0;
3936     xcb_out.selection = selection;
3937 
3938     xcb_parts[2].iov_base = (char *) &xcb_out;
3939     xcb_parts[2].iov_len = sizeof(xcb_out);
3940     xcb_parts[3].iov_base = 0;
3941     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3942 
3943     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3944     return xcb_ret;
3945 }
3946 
3947 xcb_get_selection_owner_reply_t *
xcb_get_selection_owner_reply(xcb_connection_t * c,xcb_get_selection_owner_cookie_t cookie,xcb_generic_error_t ** e)3948 xcb_get_selection_owner_reply (xcb_connection_t                  *c,
3949                                xcb_get_selection_owner_cookie_t   cookie  /**< */,
3950                                xcb_generic_error_t              **e)
3951 {
3952     return (xcb_get_selection_owner_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3953 }
3954 
3955 xcb_void_cookie_t
xcb_convert_selection_checked(xcb_connection_t * c,xcb_window_t requestor,xcb_atom_t selection,xcb_atom_t target,xcb_atom_t property,xcb_timestamp_t time)3956 xcb_convert_selection_checked (xcb_connection_t *c,
3957                                xcb_window_t      requestor,
3958                                xcb_atom_t        selection,
3959                                xcb_atom_t        target,
3960                                xcb_atom_t        property,
3961                                xcb_timestamp_t   time)
3962 {
3963     static const xcb_protocol_request_t xcb_req = {
3964         .count = 2,
3965         .ext = 0,
3966         .opcode = XCB_CONVERT_SELECTION,
3967         .isvoid = 1
3968     };
3969 
3970     struct iovec xcb_parts[4];
3971     xcb_void_cookie_t xcb_ret;
3972     xcb_convert_selection_request_t xcb_out;
3973 
3974     xcb_out.pad0 = 0;
3975     xcb_out.requestor = requestor;
3976     xcb_out.selection = selection;
3977     xcb_out.target = target;
3978     xcb_out.property = property;
3979     xcb_out.time = time;
3980 
3981     xcb_parts[2].iov_base = (char *) &xcb_out;
3982     xcb_parts[2].iov_len = sizeof(xcb_out);
3983     xcb_parts[3].iov_base = 0;
3984     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3985 
3986     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3987     return xcb_ret;
3988 }
3989 
3990 xcb_void_cookie_t
xcb_convert_selection(xcb_connection_t * c,xcb_window_t requestor,xcb_atom_t selection,xcb_atom_t target,xcb_atom_t property,xcb_timestamp_t time)3991 xcb_convert_selection (xcb_connection_t *c,
3992                        xcb_window_t      requestor,
3993                        xcb_atom_t        selection,
3994                        xcb_atom_t        target,
3995                        xcb_atom_t        property,
3996                        xcb_timestamp_t   time)
3997 {
3998     static const xcb_protocol_request_t xcb_req = {
3999         .count = 2,
4000         .ext = 0,
4001         .opcode = XCB_CONVERT_SELECTION,
4002         .isvoid = 1
4003     };
4004 
4005     struct iovec xcb_parts[4];
4006     xcb_void_cookie_t xcb_ret;
4007     xcb_convert_selection_request_t xcb_out;
4008 
4009     xcb_out.pad0 = 0;
4010     xcb_out.requestor = requestor;
4011     xcb_out.selection = selection;
4012     xcb_out.target = target;
4013     xcb_out.property = property;
4014     xcb_out.time = time;
4015 
4016     xcb_parts[2].iov_base = (char *) &xcb_out;
4017     xcb_parts[2].iov_len = sizeof(xcb_out);
4018     xcb_parts[3].iov_base = 0;
4019     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4020 
4021     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4022     return xcb_ret;
4023 }
4024 
4025 xcb_void_cookie_t
xcb_send_event_checked(xcb_connection_t * c,uint8_t propagate,xcb_window_t destination,uint32_t event_mask,const char * event)4026 xcb_send_event_checked (xcb_connection_t *c,
4027                         uint8_t           propagate,
4028                         xcb_window_t      destination,
4029                         uint32_t          event_mask,
4030                         const char       *event)
4031 {
4032     static const xcb_protocol_request_t xcb_req = {
4033         .count = 2,
4034         .ext = 0,
4035         .opcode = XCB_SEND_EVENT,
4036         .isvoid = 1
4037     };
4038 
4039     struct iovec xcb_parts[4];
4040     xcb_void_cookie_t xcb_ret;
4041     xcb_send_event_request_t xcb_out;
4042 
4043     xcb_out.propagate = propagate;
4044     xcb_out.destination = destination;
4045     xcb_out.event_mask = event_mask;
4046     memcpy(xcb_out.event, event, 32);
4047 
4048     xcb_parts[2].iov_base = (char *) &xcb_out;
4049     xcb_parts[2].iov_len = sizeof(xcb_out);
4050     xcb_parts[3].iov_base = 0;
4051     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4052 
4053     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4054     return xcb_ret;
4055 }
4056 
4057 xcb_void_cookie_t
xcb_send_event(xcb_connection_t * c,uint8_t propagate,xcb_window_t destination,uint32_t event_mask,const char * event)4058 xcb_send_event (xcb_connection_t *c,
4059                 uint8_t           propagate,
4060                 xcb_window_t      destination,
4061                 uint32_t          event_mask,
4062                 const char       *event)
4063 {
4064     static const xcb_protocol_request_t xcb_req = {
4065         .count = 2,
4066         .ext = 0,
4067         .opcode = XCB_SEND_EVENT,
4068         .isvoid = 1
4069     };
4070 
4071     struct iovec xcb_parts[4];
4072     xcb_void_cookie_t xcb_ret;
4073     xcb_send_event_request_t xcb_out;
4074 
4075     xcb_out.propagate = propagate;
4076     xcb_out.destination = destination;
4077     xcb_out.event_mask = event_mask;
4078     memcpy(xcb_out.event, event, 32);
4079 
4080     xcb_parts[2].iov_base = (char *) &xcb_out;
4081     xcb_parts[2].iov_len = sizeof(xcb_out);
4082     xcb_parts[3].iov_base = 0;
4083     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4084 
4085     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4086     return xcb_ret;
4087 }
4088 
4089 xcb_grab_pointer_cookie_t
xcb_grab_pointer(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t event_mask,uint8_t pointer_mode,uint8_t keyboard_mode,xcb_window_t confine_to,xcb_cursor_t cursor,xcb_timestamp_t time)4090 xcb_grab_pointer (xcb_connection_t *c,
4091                   uint8_t           owner_events,
4092                   xcb_window_t      grab_window,
4093                   uint16_t          event_mask,
4094                   uint8_t           pointer_mode,
4095                   uint8_t           keyboard_mode,
4096                   xcb_window_t      confine_to,
4097                   xcb_cursor_t      cursor,
4098                   xcb_timestamp_t   time)
4099 {
4100     static const xcb_protocol_request_t xcb_req = {
4101         .count = 2,
4102         .ext = 0,
4103         .opcode = XCB_GRAB_POINTER,
4104         .isvoid = 0
4105     };
4106 
4107     struct iovec xcb_parts[4];
4108     xcb_grab_pointer_cookie_t xcb_ret;
4109     xcb_grab_pointer_request_t xcb_out;
4110 
4111     xcb_out.owner_events = owner_events;
4112     xcb_out.grab_window = grab_window;
4113     xcb_out.event_mask = event_mask;
4114     xcb_out.pointer_mode = pointer_mode;
4115     xcb_out.keyboard_mode = keyboard_mode;
4116     xcb_out.confine_to = confine_to;
4117     xcb_out.cursor = cursor;
4118     xcb_out.time = time;
4119 
4120     xcb_parts[2].iov_base = (char *) &xcb_out;
4121     xcb_parts[2].iov_len = sizeof(xcb_out);
4122     xcb_parts[3].iov_base = 0;
4123     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4124 
4125     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4126     return xcb_ret;
4127 }
4128 
4129 xcb_grab_pointer_cookie_t
xcb_grab_pointer_unchecked(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t event_mask,uint8_t pointer_mode,uint8_t keyboard_mode,xcb_window_t confine_to,xcb_cursor_t cursor,xcb_timestamp_t time)4130 xcb_grab_pointer_unchecked (xcb_connection_t *c,
4131                             uint8_t           owner_events,
4132                             xcb_window_t      grab_window,
4133                             uint16_t          event_mask,
4134                             uint8_t           pointer_mode,
4135                             uint8_t           keyboard_mode,
4136                             xcb_window_t      confine_to,
4137                             xcb_cursor_t      cursor,
4138                             xcb_timestamp_t   time)
4139 {
4140     static const xcb_protocol_request_t xcb_req = {
4141         .count = 2,
4142         .ext = 0,
4143         .opcode = XCB_GRAB_POINTER,
4144         .isvoid = 0
4145     };
4146 
4147     struct iovec xcb_parts[4];
4148     xcb_grab_pointer_cookie_t xcb_ret;
4149     xcb_grab_pointer_request_t xcb_out;
4150 
4151     xcb_out.owner_events = owner_events;
4152     xcb_out.grab_window = grab_window;
4153     xcb_out.event_mask = event_mask;
4154     xcb_out.pointer_mode = pointer_mode;
4155     xcb_out.keyboard_mode = keyboard_mode;
4156     xcb_out.confine_to = confine_to;
4157     xcb_out.cursor = cursor;
4158     xcb_out.time = time;
4159 
4160     xcb_parts[2].iov_base = (char *) &xcb_out;
4161     xcb_parts[2].iov_len = sizeof(xcb_out);
4162     xcb_parts[3].iov_base = 0;
4163     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4164 
4165     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4166     return xcb_ret;
4167 }
4168 
4169 xcb_grab_pointer_reply_t *
xcb_grab_pointer_reply(xcb_connection_t * c,xcb_grab_pointer_cookie_t cookie,xcb_generic_error_t ** e)4170 xcb_grab_pointer_reply (xcb_connection_t           *c,
4171                         xcb_grab_pointer_cookie_t   cookie  /**< */,
4172                         xcb_generic_error_t       **e)
4173 {
4174     return (xcb_grab_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4175 }
4176 
4177 xcb_void_cookie_t
xcb_ungrab_pointer_checked(xcb_connection_t * c,xcb_timestamp_t time)4178 xcb_ungrab_pointer_checked (xcb_connection_t *c,
4179                             xcb_timestamp_t   time)
4180 {
4181     static const xcb_protocol_request_t xcb_req = {
4182         .count = 2,
4183         .ext = 0,
4184         .opcode = XCB_UNGRAB_POINTER,
4185         .isvoid = 1
4186     };
4187 
4188     struct iovec xcb_parts[4];
4189     xcb_void_cookie_t xcb_ret;
4190     xcb_ungrab_pointer_request_t xcb_out;
4191 
4192     xcb_out.pad0 = 0;
4193     xcb_out.time = time;
4194 
4195     xcb_parts[2].iov_base = (char *) &xcb_out;
4196     xcb_parts[2].iov_len = sizeof(xcb_out);
4197     xcb_parts[3].iov_base = 0;
4198     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4199 
4200     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4201     return xcb_ret;
4202 }
4203 
4204 xcb_void_cookie_t
xcb_ungrab_pointer(xcb_connection_t * c,xcb_timestamp_t time)4205 xcb_ungrab_pointer (xcb_connection_t *c,
4206                     xcb_timestamp_t   time)
4207 {
4208     static const xcb_protocol_request_t xcb_req = {
4209         .count = 2,
4210         .ext = 0,
4211         .opcode = XCB_UNGRAB_POINTER,
4212         .isvoid = 1
4213     };
4214 
4215     struct iovec xcb_parts[4];
4216     xcb_void_cookie_t xcb_ret;
4217     xcb_ungrab_pointer_request_t xcb_out;
4218 
4219     xcb_out.pad0 = 0;
4220     xcb_out.time = time;
4221 
4222     xcb_parts[2].iov_base = (char *) &xcb_out;
4223     xcb_parts[2].iov_len = sizeof(xcb_out);
4224     xcb_parts[3].iov_base = 0;
4225     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4226 
4227     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4228     return xcb_ret;
4229 }
4230 
4231 xcb_void_cookie_t
xcb_grab_button_checked(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t event_mask,uint8_t pointer_mode,uint8_t keyboard_mode,xcb_window_t confine_to,xcb_cursor_t cursor,uint8_t button,uint16_t modifiers)4232 xcb_grab_button_checked (xcb_connection_t *c,
4233                          uint8_t           owner_events,
4234                          xcb_window_t      grab_window,
4235                          uint16_t          event_mask,
4236                          uint8_t           pointer_mode,
4237                          uint8_t           keyboard_mode,
4238                          xcb_window_t      confine_to,
4239                          xcb_cursor_t      cursor,
4240                          uint8_t           button,
4241                          uint16_t          modifiers)
4242 {
4243     static const xcb_protocol_request_t xcb_req = {
4244         .count = 2,
4245         .ext = 0,
4246         .opcode = XCB_GRAB_BUTTON,
4247         .isvoid = 1
4248     };
4249 
4250     struct iovec xcb_parts[4];
4251     xcb_void_cookie_t xcb_ret;
4252     xcb_grab_button_request_t xcb_out;
4253 
4254     xcb_out.owner_events = owner_events;
4255     xcb_out.grab_window = grab_window;
4256     xcb_out.event_mask = event_mask;
4257     xcb_out.pointer_mode = pointer_mode;
4258     xcb_out.keyboard_mode = keyboard_mode;
4259     xcb_out.confine_to = confine_to;
4260     xcb_out.cursor = cursor;
4261     xcb_out.button = button;
4262     xcb_out.pad0 = 0;
4263     xcb_out.modifiers = modifiers;
4264 
4265     xcb_parts[2].iov_base = (char *) &xcb_out;
4266     xcb_parts[2].iov_len = sizeof(xcb_out);
4267     xcb_parts[3].iov_base = 0;
4268     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4269 
4270     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4271     return xcb_ret;
4272 }
4273 
4274 xcb_void_cookie_t
xcb_grab_button(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t event_mask,uint8_t pointer_mode,uint8_t keyboard_mode,xcb_window_t confine_to,xcb_cursor_t cursor,uint8_t button,uint16_t modifiers)4275 xcb_grab_button (xcb_connection_t *c,
4276                  uint8_t           owner_events,
4277                  xcb_window_t      grab_window,
4278                  uint16_t          event_mask,
4279                  uint8_t           pointer_mode,
4280                  uint8_t           keyboard_mode,
4281                  xcb_window_t      confine_to,
4282                  xcb_cursor_t      cursor,
4283                  uint8_t           button,
4284                  uint16_t          modifiers)
4285 {
4286     static const xcb_protocol_request_t xcb_req = {
4287         .count = 2,
4288         .ext = 0,
4289         .opcode = XCB_GRAB_BUTTON,
4290         .isvoid = 1
4291     };
4292 
4293     struct iovec xcb_parts[4];
4294     xcb_void_cookie_t xcb_ret;
4295     xcb_grab_button_request_t xcb_out;
4296 
4297     xcb_out.owner_events = owner_events;
4298     xcb_out.grab_window = grab_window;
4299     xcb_out.event_mask = event_mask;
4300     xcb_out.pointer_mode = pointer_mode;
4301     xcb_out.keyboard_mode = keyboard_mode;
4302     xcb_out.confine_to = confine_to;
4303     xcb_out.cursor = cursor;
4304     xcb_out.button = button;
4305     xcb_out.pad0 = 0;
4306     xcb_out.modifiers = modifiers;
4307 
4308     xcb_parts[2].iov_base = (char *) &xcb_out;
4309     xcb_parts[2].iov_len = sizeof(xcb_out);
4310     xcb_parts[3].iov_base = 0;
4311     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4312 
4313     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4314     return xcb_ret;
4315 }
4316 
4317 xcb_void_cookie_t
xcb_ungrab_button_checked(xcb_connection_t * c,uint8_t button,xcb_window_t grab_window,uint16_t modifiers)4318 xcb_ungrab_button_checked (xcb_connection_t *c,
4319                            uint8_t           button,
4320                            xcb_window_t      grab_window,
4321                            uint16_t          modifiers)
4322 {
4323     static const xcb_protocol_request_t xcb_req = {
4324         .count = 2,
4325         .ext = 0,
4326         .opcode = XCB_UNGRAB_BUTTON,
4327         .isvoid = 1
4328     };
4329 
4330     struct iovec xcb_parts[4];
4331     xcb_void_cookie_t xcb_ret;
4332     xcb_ungrab_button_request_t xcb_out;
4333 
4334     xcb_out.button = button;
4335     xcb_out.grab_window = grab_window;
4336     xcb_out.modifiers = modifiers;
4337     memset(xcb_out.pad0, 0, 2);
4338 
4339     xcb_parts[2].iov_base = (char *) &xcb_out;
4340     xcb_parts[2].iov_len = sizeof(xcb_out);
4341     xcb_parts[3].iov_base = 0;
4342     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4343 
4344     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4345     return xcb_ret;
4346 }
4347 
4348 xcb_void_cookie_t
xcb_ungrab_button(xcb_connection_t * c,uint8_t button,xcb_window_t grab_window,uint16_t modifiers)4349 xcb_ungrab_button (xcb_connection_t *c,
4350                    uint8_t           button,
4351                    xcb_window_t      grab_window,
4352                    uint16_t          modifiers)
4353 {
4354     static const xcb_protocol_request_t xcb_req = {
4355         .count = 2,
4356         .ext = 0,
4357         .opcode = XCB_UNGRAB_BUTTON,
4358         .isvoid = 1
4359     };
4360 
4361     struct iovec xcb_parts[4];
4362     xcb_void_cookie_t xcb_ret;
4363     xcb_ungrab_button_request_t xcb_out;
4364 
4365     xcb_out.button = button;
4366     xcb_out.grab_window = grab_window;
4367     xcb_out.modifiers = modifiers;
4368     memset(xcb_out.pad0, 0, 2);
4369 
4370     xcb_parts[2].iov_base = (char *) &xcb_out;
4371     xcb_parts[2].iov_len = sizeof(xcb_out);
4372     xcb_parts[3].iov_base = 0;
4373     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4374 
4375     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4376     return xcb_ret;
4377 }
4378 
4379 xcb_void_cookie_t
xcb_change_active_pointer_grab_checked(xcb_connection_t * c,xcb_cursor_t cursor,xcb_timestamp_t time,uint16_t event_mask)4380 xcb_change_active_pointer_grab_checked (xcb_connection_t *c,
4381                                         xcb_cursor_t      cursor,
4382                                         xcb_timestamp_t   time,
4383                                         uint16_t          event_mask)
4384 {
4385     static const xcb_protocol_request_t xcb_req = {
4386         .count = 2,
4387         .ext = 0,
4388         .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB,
4389         .isvoid = 1
4390     };
4391 
4392     struct iovec xcb_parts[4];
4393     xcb_void_cookie_t xcb_ret;
4394     xcb_change_active_pointer_grab_request_t xcb_out;
4395 
4396     xcb_out.pad0 = 0;
4397     xcb_out.cursor = cursor;
4398     xcb_out.time = time;
4399     xcb_out.event_mask = event_mask;
4400     memset(xcb_out.pad1, 0, 2);
4401 
4402     xcb_parts[2].iov_base = (char *) &xcb_out;
4403     xcb_parts[2].iov_len = sizeof(xcb_out);
4404     xcb_parts[3].iov_base = 0;
4405     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4406 
4407     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4408     return xcb_ret;
4409 }
4410 
4411 xcb_void_cookie_t
xcb_change_active_pointer_grab(xcb_connection_t * c,xcb_cursor_t cursor,xcb_timestamp_t time,uint16_t event_mask)4412 xcb_change_active_pointer_grab (xcb_connection_t *c,
4413                                 xcb_cursor_t      cursor,
4414                                 xcb_timestamp_t   time,
4415                                 uint16_t          event_mask)
4416 {
4417     static const xcb_protocol_request_t xcb_req = {
4418         .count = 2,
4419         .ext = 0,
4420         .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB,
4421         .isvoid = 1
4422     };
4423 
4424     struct iovec xcb_parts[4];
4425     xcb_void_cookie_t xcb_ret;
4426     xcb_change_active_pointer_grab_request_t xcb_out;
4427 
4428     xcb_out.pad0 = 0;
4429     xcb_out.cursor = cursor;
4430     xcb_out.time = time;
4431     xcb_out.event_mask = event_mask;
4432     memset(xcb_out.pad1, 0, 2);
4433 
4434     xcb_parts[2].iov_base = (char *) &xcb_out;
4435     xcb_parts[2].iov_len = sizeof(xcb_out);
4436     xcb_parts[3].iov_base = 0;
4437     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4438 
4439     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4440     return xcb_ret;
4441 }
4442 
4443 xcb_grab_keyboard_cookie_t
xcb_grab_keyboard(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,xcb_timestamp_t time,uint8_t pointer_mode,uint8_t keyboard_mode)4444 xcb_grab_keyboard (xcb_connection_t *c,
4445                    uint8_t           owner_events,
4446                    xcb_window_t      grab_window,
4447                    xcb_timestamp_t   time,
4448                    uint8_t           pointer_mode,
4449                    uint8_t           keyboard_mode)
4450 {
4451     static const xcb_protocol_request_t xcb_req = {
4452         .count = 2,
4453         .ext = 0,
4454         .opcode = XCB_GRAB_KEYBOARD,
4455         .isvoid = 0
4456     };
4457 
4458     struct iovec xcb_parts[4];
4459     xcb_grab_keyboard_cookie_t xcb_ret;
4460     xcb_grab_keyboard_request_t xcb_out;
4461 
4462     xcb_out.owner_events = owner_events;
4463     xcb_out.grab_window = grab_window;
4464     xcb_out.time = time;
4465     xcb_out.pointer_mode = pointer_mode;
4466     xcb_out.keyboard_mode = keyboard_mode;
4467     memset(xcb_out.pad0, 0, 2);
4468 
4469     xcb_parts[2].iov_base = (char *) &xcb_out;
4470     xcb_parts[2].iov_len = sizeof(xcb_out);
4471     xcb_parts[3].iov_base = 0;
4472     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4473 
4474     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4475     return xcb_ret;
4476 }
4477 
4478 xcb_grab_keyboard_cookie_t
xcb_grab_keyboard_unchecked(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,xcb_timestamp_t time,uint8_t pointer_mode,uint8_t keyboard_mode)4479 xcb_grab_keyboard_unchecked (xcb_connection_t *c,
4480                              uint8_t           owner_events,
4481                              xcb_window_t      grab_window,
4482                              xcb_timestamp_t   time,
4483                              uint8_t           pointer_mode,
4484                              uint8_t           keyboard_mode)
4485 {
4486     static const xcb_protocol_request_t xcb_req = {
4487         .count = 2,
4488         .ext = 0,
4489         .opcode = XCB_GRAB_KEYBOARD,
4490         .isvoid = 0
4491     };
4492 
4493     struct iovec xcb_parts[4];
4494     xcb_grab_keyboard_cookie_t xcb_ret;
4495     xcb_grab_keyboard_request_t xcb_out;
4496 
4497     xcb_out.owner_events = owner_events;
4498     xcb_out.grab_window = grab_window;
4499     xcb_out.time = time;
4500     xcb_out.pointer_mode = pointer_mode;
4501     xcb_out.keyboard_mode = keyboard_mode;
4502     memset(xcb_out.pad0, 0, 2);
4503 
4504     xcb_parts[2].iov_base = (char *) &xcb_out;
4505     xcb_parts[2].iov_len = sizeof(xcb_out);
4506     xcb_parts[3].iov_base = 0;
4507     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4508 
4509     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4510     return xcb_ret;
4511 }
4512 
4513 xcb_grab_keyboard_reply_t *
xcb_grab_keyboard_reply(xcb_connection_t * c,xcb_grab_keyboard_cookie_t cookie,xcb_generic_error_t ** e)4514 xcb_grab_keyboard_reply (xcb_connection_t            *c,
4515                          xcb_grab_keyboard_cookie_t   cookie  /**< */,
4516                          xcb_generic_error_t        **e)
4517 {
4518     return (xcb_grab_keyboard_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4519 }
4520 
4521 xcb_void_cookie_t
xcb_ungrab_keyboard_checked(xcb_connection_t * c,xcb_timestamp_t time)4522 xcb_ungrab_keyboard_checked (xcb_connection_t *c,
4523                              xcb_timestamp_t   time)
4524 {
4525     static const xcb_protocol_request_t xcb_req = {
4526         .count = 2,
4527         .ext = 0,
4528         .opcode = XCB_UNGRAB_KEYBOARD,
4529         .isvoid = 1
4530     };
4531 
4532     struct iovec xcb_parts[4];
4533     xcb_void_cookie_t xcb_ret;
4534     xcb_ungrab_keyboard_request_t xcb_out;
4535 
4536     xcb_out.pad0 = 0;
4537     xcb_out.time = time;
4538 
4539     xcb_parts[2].iov_base = (char *) &xcb_out;
4540     xcb_parts[2].iov_len = sizeof(xcb_out);
4541     xcb_parts[3].iov_base = 0;
4542     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4543 
4544     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4545     return xcb_ret;
4546 }
4547 
4548 xcb_void_cookie_t
xcb_ungrab_keyboard(xcb_connection_t * c,xcb_timestamp_t time)4549 xcb_ungrab_keyboard (xcb_connection_t *c,
4550                      xcb_timestamp_t   time)
4551 {
4552     static const xcb_protocol_request_t xcb_req = {
4553         .count = 2,
4554         .ext = 0,
4555         .opcode = XCB_UNGRAB_KEYBOARD,
4556         .isvoid = 1
4557     };
4558 
4559     struct iovec xcb_parts[4];
4560     xcb_void_cookie_t xcb_ret;
4561     xcb_ungrab_keyboard_request_t xcb_out;
4562 
4563     xcb_out.pad0 = 0;
4564     xcb_out.time = time;
4565 
4566     xcb_parts[2].iov_base = (char *) &xcb_out;
4567     xcb_parts[2].iov_len = sizeof(xcb_out);
4568     xcb_parts[3].iov_base = 0;
4569     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4570 
4571     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4572     return xcb_ret;
4573 }
4574 
4575 xcb_void_cookie_t
xcb_grab_key_checked(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t modifiers,xcb_keycode_t key,uint8_t pointer_mode,uint8_t keyboard_mode)4576 xcb_grab_key_checked (xcb_connection_t *c,
4577                       uint8_t           owner_events,
4578                       xcb_window_t      grab_window,
4579                       uint16_t          modifiers,
4580                       xcb_keycode_t     key,
4581                       uint8_t           pointer_mode,
4582                       uint8_t           keyboard_mode)
4583 {
4584     static const xcb_protocol_request_t xcb_req = {
4585         .count = 2,
4586         .ext = 0,
4587         .opcode = XCB_GRAB_KEY,
4588         .isvoid = 1
4589     };
4590 
4591     struct iovec xcb_parts[4];
4592     xcb_void_cookie_t xcb_ret;
4593     xcb_grab_key_request_t xcb_out;
4594 
4595     xcb_out.owner_events = owner_events;
4596     xcb_out.grab_window = grab_window;
4597     xcb_out.modifiers = modifiers;
4598     xcb_out.key = key;
4599     xcb_out.pointer_mode = pointer_mode;
4600     xcb_out.keyboard_mode = keyboard_mode;
4601     memset(xcb_out.pad0, 0, 3);
4602 
4603     xcb_parts[2].iov_base = (char *) &xcb_out;
4604     xcb_parts[2].iov_len = sizeof(xcb_out);
4605     xcb_parts[3].iov_base = 0;
4606     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4607 
4608     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4609     return xcb_ret;
4610 }
4611 
4612 xcb_void_cookie_t
xcb_grab_key(xcb_connection_t * c,uint8_t owner_events,xcb_window_t grab_window,uint16_t modifiers,xcb_keycode_t key,uint8_t pointer_mode,uint8_t keyboard_mode)4613 xcb_grab_key (xcb_connection_t *c,
4614               uint8_t           owner_events,
4615               xcb_window_t      grab_window,
4616               uint16_t          modifiers,
4617               xcb_keycode_t     key,
4618               uint8_t           pointer_mode,
4619               uint8_t           keyboard_mode)
4620 {
4621     static const xcb_protocol_request_t xcb_req = {
4622         .count = 2,
4623         .ext = 0,
4624         .opcode = XCB_GRAB_KEY,
4625         .isvoid = 1
4626     };
4627 
4628     struct iovec xcb_parts[4];
4629     xcb_void_cookie_t xcb_ret;
4630     xcb_grab_key_request_t xcb_out;
4631 
4632     xcb_out.owner_events = owner_events;
4633     xcb_out.grab_window = grab_window;
4634     xcb_out.modifiers = modifiers;
4635     xcb_out.key = key;
4636     xcb_out.pointer_mode = pointer_mode;
4637     xcb_out.keyboard_mode = keyboard_mode;
4638     memset(xcb_out.pad0, 0, 3);
4639 
4640     xcb_parts[2].iov_base = (char *) &xcb_out;
4641     xcb_parts[2].iov_len = sizeof(xcb_out);
4642     xcb_parts[3].iov_base = 0;
4643     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4644 
4645     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4646     return xcb_ret;
4647 }
4648 
4649 xcb_void_cookie_t
xcb_ungrab_key_checked(xcb_connection_t * c,xcb_keycode_t key,xcb_window_t grab_window,uint16_t modifiers)4650 xcb_ungrab_key_checked (xcb_connection_t *c,
4651                         xcb_keycode_t     key,
4652                         xcb_window_t      grab_window,
4653                         uint16_t          modifiers)
4654 {
4655     static const xcb_protocol_request_t xcb_req = {
4656         .count = 2,
4657         .ext = 0,
4658         .opcode = XCB_UNGRAB_KEY,
4659         .isvoid = 1
4660     };
4661 
4662     struct iovec xcb_parts[4];
4663     xcb_void_cookie_t xcb_ret;
4664     xcb_ungrab_key_request_t xcb_out;
4665 
4666     xcb_out.key = key;
4667     xcb_out.grab_window = grab_window;
4668     xcb_out.modifiers = modifiers;
4669     memset(xcb_out.pad0, 0, 2);
4670 
4671     xcb_parts[2].iov_base = (char *) &xcb_out;
4672     xcb_parts[2].iov_len = sizeof(xcb_out);
4673     xcb_parts[3].iov_base = 0;
4674     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4675 
4676     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4677     return xcb_ret;
4678 }
4679 
4680 xcb_void_cookie_t
xcb_ungrab_key(xcb_connection_t * c,xcb_keycode_t key,xcb_window_t grab_window,uint16_t modifiers)4681 xcb_ungrab_key (xcb_connection_t *c,
4682                 xcb_keycode_t     key,
4683                 xcb_window_t      grab_window,
4684                 uint16_t          modifiers)
4685 {
4686     static const xcb_protocol_request_t xcb_req = {
4687         .count = 2,
4688         .ext = 0,
4689         .opcode = XCB_UNGRAB_KEY,
4690         .isvoid = 1
4691     };
4692 
4693     struct iovec xcb_parts[4];
4694     xcb_void_cookie_t xcb_ret;
4695     xcb_ungrab_key_request_t xcb_out;
4696 
4697     xcb_out.key = key;
4698     xcb_out.grab_window = grab_window;
4699     xcb_out.modifiers = modifiers;
4700     memset(xcb_out.pad0, 0, 2);
4701 
4702     xcb_parts[2].iov_base = (char *) &xcb_out;
4703     xcb_parts[2].iov_len = sizeof(xcb_out);
4704     xcb_parts[3].iov_base = 0;
4705     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4706 
4707     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4708     return xcb_ret;
4709 }
4710 
4711 xcb_void_cookie_t
xcb_allow_events_checked(xcb_connection_t * c,uint8_t mode,xcb_timestamp_t time)4712 xcb_allow_events_checked (xcb_connection_t *c,
4713                           uint8_t           mode,
4714                           xcb_timestamp_t   time)
4715 {
4716     static const xcb_protocol_request_t xcb_req = {
4717         .count = 2,
4718         .ext = 0,
4719         .opcode = XCB_ALLOW_EVENTS,
4720         .isvoid = 1
4721     };
4722 
4723     struct iovec xcb_parts[4];
4724     xcb_void_cookie_t xcb_ret;
4725     xcb_allow_events_request_t xcb_out;
4726 
4727     xcb_out.mode = mode;
4728     xcb_out.time = time;
4729 
4730     xcb_parts[2].iov_base = (char *) &xcb_out;
4731     xcb_parts[2].iov_len = sizeof(xcb_out);
4732     xcb_parts[3].iov_base = 0;
4733     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4734 
4735     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4736     return xcb_ret;
4737 }
4738 
4739 xcb_void_cookie_t
xcb_allow_events(xcb_connection_t * c,uint8_t mode,xcb_timestamp_t time)4740 xcb_allow_events (xcb_connection_t *c,
4741                   uint8_t           mode,
4742                   xcb_timestamp_t   time)
4743 {
4744     static const xcb_protocol_request_t xcb_req = {
4745         .count = 2,
4746         .ext = 0,
4747         .opcode = XCB_ALLOW_EVENTS,
4748         .isvoid = 1
4749     };
4750 
4751     struct iovec xcb_parts[4];
4752     xcb_void_cookie_t xcb_ret;
4753     xcb_allow_events_request_t xcb_out;
4754 
4755     xcb_out.mode = mode;
4756     xcb_out.time = time;
4757 
4758     xcb_parts[2].iov_base = (char *) &xcb_out;
4759     xcb_parts[2].iov_len = sizeof(xcb_out);
4760     xcb_parts[3].iov_base = 0;
4761     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4762 
4763     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4764     return xcb_ret;
4765 }
4766 
4767 xcb_void_cookie_t
xcb_grab_server_checked(xcb_connection_t * c)4768 xcb_grab_server_checked (xcb_connection_t *c)
4769 {
4770     static const xcb_protocol_request_t xcb_req = {
4771         .count = 2,
4772         .ext = 0,
4773         .opcode = XCB_GRAB_SERVER,
4774         .isvoid = 1
4775     };
4776 
4777     struct iovec xcb_parts[4];
4778     xcb_void_cookie_t xcb_ret;
4779     xcb_grab_server_request_t xcb_out;
4780 
4781     xcb_out.pad0 = 0;
4782 
4783     xcb_parts[2].iov_base = (char *) &xcb_out;
4784     xcb_parts[2].iov_len = sizeof(xcb_out);
4785     xcb_parts[3].iov_base = 0;
4786     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4787 
4788     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4789     return xcb_ret;
4790 }
4791 
4792 xcb_void_cookie_t
xcb_grab_server(xcb_connection_t * c)4793 xcb_grab_server (xcb_connection_t *c)
4794 {
4795     static const xcb_protocol_request_t xcb_req = {
4796         .count = 2,
4797         .ext = 0,
4798         .opcode = XCB_GRAB_SERVER,
4799         .isvoid = 1
4800     };
4801 
4802     struct iovec xcb_parts[4];
4803     xcb_void_cookie_t xcb_ret;
4804     xcb_grab_server_request_t xcb_out;
4805 
4806     xcb_out.pad0 = 0;
4807 
4808     xcb_parts[2].iov_base = (char *) &xcb_out;
4809     xcb_parts[2].iov_len = sizeof(xcb_out);
4810     xcb_parts[3].iov_base = 0;
4811     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4812 
4813     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4814     return xcb_ret;
4815 }
4816 
4817 xcb_void_cookie_t
xcb_ungrab_server_checked(xcb_connection_t * c)4818 xcb_ungrab_server_checked (xcb_connection_t *c)
4819 {
4820     static const xcb_protocol_request_t xcb_req = {
4821         .count = 2,
4822         .ext = 0,
4823         .opcode = XCB_UNGRAB_SERVER,
4824         .isvoid = 1
4825     };
4826 
4827     struct iovec xcb_parts[4];
4828     xcb_void_cookie_t xcb_ret;
4829     xcb_ungrab_server_request_t xcb_out;
4830 
4831     xcb_out.pad0 = 0;
4832 
4833     xcb_parts[2].iov_base = (char *) &xcb_out;
4834     xcb_parts[2].iov_len = sizeof(xcb_out);
4835     xcb_parts[3].iov_base = 0;
4836     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4837 
4838     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4839     return xcb_ret;
4840 }
4841 
4842 xcb_void_cookie_t
xcb_ungrab_server(xcb_connection_t * c)4843 xcb_ungrab_server (xcb_connection_t *c)
4844 {
4845     static const xcb_protocol_request_t xcb_req = {
4846         .count = 2,
4847         .ext = 0,
4848         .opcode = XCB_UNGRAB_SERVER,
4849         .isvoid = 1
4850     };
4851 
4852     struct iovec xcb_parts[4];
4853     xcb_void_cookie_t xcb_ret;
4854     xcb_ungrab_server_request_t xcb_out;
4855 
4856     xcb_out.pad0 = 0;
4857 
4858     xcb_parts[2].iov_base = (char *) &xcb_out;
4859     xcb_parts[2].iov_len = sizeof(xcb_out);
4860     xcb_parts[3].iov_base = 0;
4861     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4862 
4863     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4864     return xcb_ret;
4865 }
4866 
4867 xcb_query_pointer_cookie_t
xcb_query_pointer(xcb_connection_t * c,xcb_window_t window)4868 xcb_query_pointer (xcb_connection_t *c,
4869                    xcb_window_t      window)
4870 {
4871     static const xcb_protocol_request_t xcb_req = {
4872         .count = 2,
4873         .ext = 0,
4874         .opcode = XCB_QUERY_POINTER,
4875         .isvoid = 0
4876     };
4877 
4878     struct iovec xcb_parts[4];
4879     xcb_query_pointer_cookie_t xcb_ret;
4880     xcb_query_pointer_request_t xcb_out;
4881 
4882     xcb_out.pad0 = 0;
4883     xcb_out.window = window;
4884 
4885     xcb_parts[2].iov_base = (char *) &xcb_out;
4886     xcb_parts[2].iov_len = sizeof(xcb_out);
4887     xcb_parts[3].iov_base = 0;
4888     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4889 
4890     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4891     return xcb_ret;
4892 }
4893 
4894 xcb_query_pointer_cookie_t
xcb_query_pointer_unchecked(xcb_connection_t * c,xcb_window_t window)4895 xcb_query_pointer_unchecked (xcb_connection_t *c,
4896                              xcb_window_t      window)
4897 {
4898     static const xcb_protocol_request_t xcb_req = {
4899         .count = 2,
4900         .ext = 0,
4901         .opcode = XCB_QUERY_POINTER,
4902         .isvoid = 0
4903     };
4904 
4905     struct iovec xcb_parts[4];
4906     xcb_query_pointer_cookie_t xcb_ret;
4907     xcb_query_pointer_request_t xcb_out;
4908 
4909     xcb_out.pad0 = 0;
4910     xcb_out.window = window;
4911 
4912     xcb_parts[2].iov_base = (char *) &xcb_out;
4913     xcb_parts[2].iov_len = sizeof(xcb_out);
4914     xcb_parts[3].iov_base = 0;
4915     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4916 
4917     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4918     return xcb_ret;
4919 }
4920 
4921 xcb_query_pointer_reply_t *
xcb_query_pointer_reply(xcb_connection_t * c,xcb_query_pointer_cookie_t cookie,xcb_generic_error_t ** e)4922 xcb_query_pointer_reply (xcb_connection_t            *c,
4923                          xcb_query_pointer_cookie_t   cookie  /**< */,
4924                          xcb_generic_error_t        **e)
4925 {
4926     return (xcb_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4927 }
4928 
4929 void
xcb_timecoord_next(xcb_timecoord_iterator_t * i)4930 xcb_timecoord_next (xcb_timecoord_iterator_t *i)
4931 {
4932     --i->rem;
4933     ++i->data;
4934     i->index += sizeof(xcb_timecoord_t);
4935 }
4936 
4937 xcb_generic_iterator_t
xcb_timecoord_end(xcb_timecoord_iterator_t i)4938 xcb_timecoord_end (xcb_timecoord_iterator_t i)
4939 {
4940     xcb_generic_iterator_t ret;
4941     ret.data = i.data + i.rem;
4942     ret.index = i.index + ((char *) ret.data - (char *) i.data);
4943     ret.rem = 0;
4944     return ret;
4945 }
4946 
4947 int
xcb_get_motion_events_sizeof(const void * _buffer)4948 xcb_get_motion_events_sizeof (const void  *_buffer)
4949 {
4950     char *xcb_tmp = (char *)_buffer;
4951     const xcb_get_motion_events_reply_t *_aux = (xcb_get_motion_events_reply_t *)_buffer;
4952     unsigned int xcb_buffer_len = 0;
4953     unsigned int xcb_block_len = 0;
4954     unsigned int xcb_pad = 0;
4955     unsigned int xcb_align_to = 0;
4956 
4957 
4958     xcb_block_len += sizeof(xcb_get_motion_events_reply_t);
4959     xcb_tmp += xcb_block_len;
4960     xcb_buffer_len += xcb_block_len;
4961     xcb_block_len = 0;
4962     /* events */
4963     xcb_block_len += _aux->events_len * sizeof(xcb_timecoord_t);
4964     xcb_tmp += xcb_block_len;
4965     xcb_align_to = ALIGNOF(xcb_timecoord_t);
4966     /* insert padding */
4967     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4968     xcb_buffer_len += xcb_block_len + xcb_pad;
4969     if (0 != xcb_pad) {
4970         xcb_tmp += xcb_pad;
4971         xcb_pad = 0;
4972     }
4973     xcb_block_len = 0;
4974 
4975     return xcb_buffer_len;
4976 }
4977 
4978 xcb_get_motion_events_cookie_t
xcb_get_motion_events(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t start,xcb_timestamp_t stop)4979 xcb_get_motion_events (xcb_connection_t *c,
4980                        xcb_window_t      window,
4981                        xcb_timestamp_t   start,
4982                        xcb_timestamp_t   stop)
4983 {
4984     static const xcb_protocol_request_t xcb_req = {
4985         .count = 2,
4986         .ext = 0,
4987         .opcode = XCB_GET_MOTION_EVENTS,
4988         .isvoid = 0
4989     };
4990 
4991     struct iovec xcb_parts[4];
4992     xcb_get_motion_events_cookie_t xcb_ret;
4993     xcb_get_motion_events_request_t xcb_out;
4994 
4995     xcb_out.pad0 = 0;
4996     xcb_out.window = window;
4997     xcb_out.start = start;
4998     xcb_out.stop = stop;
4999 
5000     xcb_parts[2].iov_base = (char *) &xcb_out;
5001     xcb_parts[2].iov_len = sizeof(xcb_out);
5002     xcb_parts[3].iov_base = 0;
5003     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5004 
5005     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5006     return xcb_ret;
5007 }
5008 
5009 xcb_get_motion_events_cookie_t
xcb_get_motion_events_unchecked(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t start,xcb_timestamp_t stop)5010 xcb_get_motion_events_unchecked (xcb_connection_t *c,
5011                                  xcb_window_t      window,
5012                                  xcb_timestamp_t   start,
5013                                  xcb_timestamp_t   stop)
5014 {
5015     static const xcb_protocol_request_t xcb_req = {
5016         .count = 2,
5017         .ext = 0,
5018         .opcode = XCB_GET_MOTION_EVENTS,
5019         .isvoid = 0
5020     };
5021 
5022     struct iovec xcb_parts[4];
5023     xcb_get_motion_events_cookie_t xcb_ret;
5024     xcb_get_motion_events_request_t xcb_out;
5025 
5026     xcb_out.pad0 = 0;
5027     xcb_out.window = window;
5028     xcb_out.start = start;
5029     xcb_out.stop = stop;
5030 
5031     xcb_parts[2].iov_base = (char *) &xcb_out;
5032     xcb_parts[2].iov_len = sizeof(xcb_out);
5033     xcb_parts[3].iov_base = 0;
5034     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5035 
5036     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5037     return xcb_ret;
5038 }
5039 
5040 xcb_timecoord_t *
xcb_get_motion_events_events(const xcb_get_motion_events_reply_t * R)5041 xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R)
5042 {
5043     return (xcb_timecoord_t *) (R + 1);
5044 }
5045 
5046 int
xcb_get_motion_events_events_length(const xcb_get_motion_events_reply_t * R)5047 xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R)
5048 {
5049     return R->events_len;
5050 }
5051 
5052 xcb_timecoord_iterator_t
xcb_get_motion_events_events_iterator(const xcb_get_motion_events_reply_t * R)5053 xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R)
5054 {
5055     xcb_timecoord_iterator_t i;
5056     i.data = (xcb_timecoord_t *) (R + 1);
5057     i.rem = R->events_len;
5058     i.index = (char *) i.data - (char *) R;
5059     return i;
5060 }
5061 
5062 xcb_get_motion_events_reply_t *
xcb_get_motion_events_reply(xcb_connection_t * c,xcb_get_motion_events_cookie_t cookie,xcb_generic_error_t ** e)5063 xcb_get_motion_events_reply (xcb_connection_t                *c,
5064                              xcb_get_motion_events_cookie_t   cookie  /**< */,
5065                              xcb_generic_error_t            **e)
5066 {
5067     return (xcb_get_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5068 }
5069 
5070 xcb_translate_coordinates_cookie_t
xcb_translate_coordinates(xcb_connection_t * c,xcb_window_t src_window,xcb_window_t dst_window,int16_t src_x,int16_t src_y)5071 xcb_translate_coordinates (xcb_connection_t *c,
5072                            xcb_window_t      src_window,
5073                            xcb_window_t      dst_window,
5074                            int16_t           src_x,
5075                            int16_t           src_y)
5076 {
5077     static const xcb_protocol_request_t xcb_req = {
5078         .count = 2,
5079         .ext = 0,
5080         .opcode = XCB_TRANSLATE_COORDINATES,
5081         .isvoid = 0
5082     };
5083 
5084     struct iovec xcb_parts[4];
5085     xcb_translate_coordinates_cookie_t xcb_ret;
5086     xcb_translate_coordinates_request_t xcb_out;
5087 
5088     xcb_out.pad0 = 0;
5089     xcb_out.src_window = src_window;
5090     xcb_out.dst_window = dst_window;
5091     xcb_out.src_x = src_x;
5092     xcb_out.src_y = src_y;
5093 
5094     xcb_parts[2].iov_base = (char *) &xcb_out;
5095     xcb_parts[2].iov_len = sizeof(xcb_out);
5096     xcb_parts[3].iov_base = 0;
5097     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5098 
5099     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5100     return xcb_ret;
5101 }
5102 
5103 xcb_translate_coordinates_cookie_t
xcb_translate_coordinates_unchecked(xcb_connection_t * c,xcb_window_t src_window,xcb_window_t dst_window,int16_t src_x,int16_t src_y)5104 xcb_translate_coordinates_unchecked (xcb_connection_t *c,
5105                                      xcb_window_t      src_window,
5106                                      xcb_window_t      dst_window,
5107                                      int16_t           src_x,
5108                                      int16_t           src_y)
5109 {
5110     static const xcb_protocol_request_t xcb_req = {
5111         .count = 2,
5112         .ext = 0,
5113         .opcode = XCB_TRANSLATE_COORDINATES,
5114         .isvoid = 0
5115     };
5116 
5117     struct iovec xcb_parts[4];
5118     xcb_translate_coordinates_cookie_t xcb_ret;
5119     xcb_translate_coordinates_request_t xcb_out;
5120 
5121     xcb_out.pad0 = 0;
5122     xcb_out.src_window = src_window;
5123     xcb_out.dst_window = dst_window;
5124     xcb_out.src_x = src_x;
5125     xcb_out.src_y = src_y;
5126 
5127     xcb_parts[2].iov_base = (char *) &xcb_out;
5128     xcb_parts[2].iov_len = sizeof(xcb_out);
5129     xcb_parts[3].iov_base = 0;
5130     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5131 
5132     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5133     return xcb_ret;
5134 }
5135 
5136 xcb_translate_coordinates_reply_t *
xcb_translate_coordinates_reply(xcb_connection_t * c,xcb_translate_coordinates_cookie_t cookie,xcb_generic_error_t ** e)5137 xcb_translate_coordinates_reply (xcb_connection_t                    *c,
5138                                  xcb_translate_coordinates_cookie_t   cookie  /**< */,
5139                                  xcb_generic_error_t                **e)
5140 {
5141     return (xcb_translate_coordinates_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5142 }
5143 
5144 xcb_void_cookie_t
xcb_warp_pointer_checked(xcb_connection_t * c,xcb_window_t src_window,xcb_window_t dst_window,int16_t src_x,int16_t src_y,uint16_t src_width,uint16_t src_height,int16_t dst_x,int16_t dst_y)5145 xcb_warp_pointer_checked (xcb_connection_t *c,
5146                           xcb_window_t      src_window,
5147                           xcb_window_t      dst_window,
5148                           int16_t           src_x,
5149                           int16_t           src_y,
5150                           uint16_t          src_width,
5151                           uint16_t          src_height,
5152                           int16_t           dst_x,
5153                           int16_t           dst_y)
5154 {
5155     static const xcb_protocol_request_t xcb_req = {
5156         .count = 2,
5157         .ext = 0,
5158         .opcode = XCB_WARP_POINTER,
5159         .isvoid = 1
5160     };
5161 
5162     struct iovec xcb_parts[4];
5163     xcb_void_cookie_t xcb_ret;
5164     xcb_warp_pointer_request_t xcb_out;
5165 
5166     xcb_out.pad0 = 0;
5167     xcb_out.src_window = src_window;
5168     xcb_out.dst_window = dst_window;
5169     xcb_out.src_x = src_x;
5170     xcb_out.src_y = src_y;
5171     xcb_out.src_width = src_width;
5172     xcb_out.src_height = src_height;
5173     xcb_out.dst_x = dst_x;
5174     xcb_out.dst_y = dst_y;
5175 
5176     xcb_parts[2].iov_base = (char *) &xcb_out;
5177     xcb_parts[2].iov_len = sizeof(xcb_out);
5178     xcb_parts[3].iov_base = 0;
5179     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5180 
5181     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5182     return xcb_ret;
5183 }
5184 
5185 xcb_void_cookie_t
xcb_warp_pointer(xcb_connection_t * c,xcb_window_t src_window,xcb_window_t dst_window,int16_t src_x,int16_t src_y,uint16_t src_width,uint16_t src_height,int16_t dst_x,int16_t dst_y)5186 xcb_warp_pointer (xcb_connection_t *c,
5187                   xcb_window_t      src_window,
5188                   xcb_window_t      dst_window,
5189                   int16_t           src_x,
5190                   int16_t           src_y,
5191                   uint16_t          src_width,
5192                   uint16_t          src_height,
5193                   int16_t           dst_x,
5194                   int16_t           dst_y)
5195 {
5196     static const xcb_protocol_request_t xcb_req = {
5197         .count = 2,
5198         .ext = 0,
5199         .opcode = XCB_WARP_POINTER,
5200         .isvoid = 1
5201     };
5202 
5203     struct iovec xcb_parts[4];
5204     xcb_void_cookie_t xcb_ret;
5205     xcb_warp_pointer_request_t xcb_out;
5206 
5207     xcb_out.pad0 = 0;
5208     xcb_out.src_window = src_window;
5209     xcb_out.dst_window = dst_window;
5210     xcb_out.src_x = src_x;
5211     xcb_out.src_y = src_y;
5212     xcb_out.src_width = src_width;
5213     xcb_out.src_height = src_height;
5214     xcb_out.dst_x = dst_x;
5215     xcb_out.dst_y = dst_y;
5216 
5217     xcb_parts[2].iov_base = (char *) &xcb_out;
5218     xcb_parts[2].iov_len = sizeof(xcb_out);
5219     xcb_parts[3].iov_base = 0;
5220     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5221 
5222     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5223     return xcb_ret;
5224 }
5225 
5226 xcb_void_cookie_t
xcb_set_input_focus_checked(xcb_connection_t * c,uint8_t revert_to,xcb_window_t focus,xcb_timestamp_t time)5227 xcb_set_input_focus_checked (xcb_connection_t *c,
5228                              uint8_t           revert_to,
5229                              xcb_window_t      focus,
5230                              xcb_timestamp_t   time)
5231 {
5232     static const xcb_protocol_request_t xcb_req = {
5233         .count = 2,
5234         .ext = 0,
5235         .opcode = XCB_SET_INPUT_FOCUS,
5236         .isvoid = 1
5237     };
5238 
5239     struct iovec xcb_parts[4];
5240     xcb_void_cookie_t xcb_ret;
5241     xcb_set_input_focus_request_t xcb_out;
5242 
5243     xcb_out.revert_to = revert_to;
5244     xcb_out.focus = focus;
5245     xcb_out.time = time;
5246 
5247     xcb_parts[2].iov_base = (char *) &xcb_out;
5248     xcb_parts[2].iov_len = sizeof(xcb_out);
5249     xcb_parts[3].iov_base = 0;
5250     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5251 
5252     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5253     return xcb_ret;
5254 }
5255 
5256 xcb_void_cookie_t
xcb_set_input_focus(xcb_connection_t * c,uint8_t revert_to,xcb_window_t focus,xcb_timestamp_t time)5257 xcb_set_input_focus (xcb_connection_t *c,
5258                      uint8_t           revert_to,
5259                      xcb_window_t      focus,
5260                      xcb_timestamp_t   time)
5261 {
5262     static const xcb_protocol_request_t xcb_req = {
5263         .count = 2,
5264         .ext = 0,
5265         .opcode = XCB_SET_INPUT_FOCUS,
5266         .isvoid = 1
5267     };
5268 
5269     struct iovec xcb_parts[4];
5270     xcb_void_cookie_t xcb_ret;
5271     xcb_set_input_focus_request_t xcb_out;
5272 
5273     xcb_out.revert_to = revert_to;
5274     xcb_out.focus = focus;
5275     xcb_out.time = time;
5276 
5277     xcb_parts[2].iov_base = (char *) &xcb_out;
5278     xcb_parts[2].iov_len = sizeof(xcb_out);
5279     xcb_parts[3].iov_base = 0;
5280     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5281 
5282     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5283     return xcb_ret;
5284 }
5285 
5286 xcb_get_input_focus_cookie_t
xcb_get_input_focus(xcb_connection_t * c)5287 xcb_get_input_focus (xcb_connection_t *c)
5288 {
5289     static const xcb_protocol_request_t xcb_req = {
5290         .count = 2,
5291         .ext = 0,
5292         .opcode = XCB_GET_INPUT_FOCUS,
5293         .isvoid = 0
5294     };
5295 
5296     struct iovec xcb_parts[4];
5297     xcb_get_input_focus_cookie_t xcb_ret;
5298     xcb_get_input_focus_request_t xcb_out;
5299 
5300     xcb_out.pad0 = 0;
5301 
5302     xcb_parts[2].iov_base = (char *) &xcb_out;
5303     xcb_parts[2].iov_len = sizeof(xcb_out);
5304     xcb_parts[3].iov_base = 0;
5305     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5306 
5307     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5308     return xcb_ret;
5309 }
5310 
5311 xcb_get_input_focus_cookie_t
xcb_get_input_focus_unchecked(xcb_connection_t * c)5312 xcb_get_input_focus_unchecked (xcb_connection_t *c)
5313 {
5314     static const xcb_protocol_request_t xcb_req = {
5315         .count = 2,
5316         .ext = 0,
5317         .opcode = XCB_GET_INPUT_FOCUS,
5318         .isvoid = 0
5319     };
5320 
5321     struct iovec xcb_parts[4];
5322     xcb_get_input_focus_cookie_t xcb_ret;
5323     xcb_get_input_focus_request_t xcb_out;
5324 
5325     xcb_out.pad0 = 0;
5326 
5327     xcb_parts[2].iov_base = (char *) &xcb_out;
5328     xcb_parts[2].iov_len = sizeof(xcb_out);
5329     xcb_parts[3].iov_base = 0;
5330     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5331 
5332     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5333     return xcb_ret;
5334 }
5335 
5336 xcb_get_input_focus_reply_t *
xcb_get_input_focus_reply(xcb_connection_t * c,xcb_get_input_focus_cookie_t cookie,xcb_generic_error_t ** e)5337 xcb_get_input_focus_reply (xcb_connection_t              *c,
5338                            xcb_get_input_focus_cookie_t   cookie  /**< */,
5339                            xcb_generic_error_t          **e)
5340 {
5341     return (xcb_get_input_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5342 }
5343 
5344 xcb_query_keymap_cookie_t
xcb_query_keymap(xcb_connection_t * c)5345 xcb_query_keymap (xcb_connection_t *c)
5346 {
5347     static const xcb_protocol_request_t xcb_req = {
5348         .count = 2,
5349         .ext = 0,
5350         .opcode = XCB_QUERY_KEYMAP,
5351         .isvoid = 0
5352     };
5353 
5354     struct iovec xcb_parts[4];
5355     xcb_query_keymap_cookie_t xcb_ret;
5356     xcb_query_keymap_request_t xcb_out;
5357 
5358     xcb_out.pad0 = 0;
5359 
5360     xcb_parts[2].iov_base = (char *) &xcb_out;
5361     xcb_parts[2].iov_len = sizeof(xcb_out);
5362     xcb_parts[3].iov_base = 0;
5363     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5364 
5365     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5366     return xcb_ret;
5367 }
5368 
5369 xcb_query_keymap_cookie_t
xcb_query_keymap_unchecked(xcb_connection_t * c)5370 xcb_query_keymap_unchecked (xcb_connection_t *c)
5371 {
5372     static const xcb_protocol_request_t xcb_req = {
5373         .count = 2,
5374         .ext = 0,
5375         .opcode = XCB_QUERY_KEYMAP,
5376         .isvoid = 0
5377     };
5378 
5379     struct iovec xcb_parts[4];
5380     xcb_query_keymap_cookie_t xcb_ret;
5381     xcb_query_keymap_request_t xcb_out;
5382 
5383     xcb_out.pad0 = 0;
5384 
5385     xcb_parts[2].iov_base = (char *) &xcb_out;
5386     xcb_parts[2].iov_len = sizeof(xcb_out);
5387     xcb_parts[3].iov_base = 0;
5388     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5389 
5390     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5391     return xcb_ret;
5392 }
5393 
5394 xcb_query_keymap_reply_t *
xcb_query_keymap_reply(xcb_connection_t * c,xcb_query_keymap_cookie_t cookie,xcb_generic_error_t ** e)5395 xcb_query_keymap_reply (xcb_connection_t           *c,
5396                         xcb_query_keymap_cookie_t   cookie  /**< */,
5397                         xcb_generic_error_t       **e)
5398 {
5399     return (xcb_query_keymap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5400 }
5401 
5402 int
xcb_open_font_sizeof(const void * _buffer)5403 xcb_open_font_sizeof (const void  *_buffer)
5404 {
5405     char *xcb_tmp = (char *)_buffer;
5406     const xcb_open_font_request_t *_aux = (xcb_open_font_request_t *)_buffer;
5407     unsigned int xcb_buffer_len = 0;
5408     unsigned int xcb_block_len = 0;
5409     unsigned int xcb_pad = 0;
5410     unsigned int xcb_align_to = 0;
5411 
5412 
5413     xcb_block_len += sizeof(xcb_open_font_request_t);
5414     xcb_tmp += xcb_block_len;
5415     xcb_buffer_len += xcb_block_len;
5416     xcb_block_len = 0;
5417     /* name */
5418     xcb_block_len += _aux->name_len * sizeof(char);
5419     xcb_tmp += xcb_block_len;
5420     xcb_align_to = ALIGNOF(char);
5421     /* insert padding */
5422     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5423     xcb_buffer_len += xcb_block_len + xcb_pad;
5424     if (0 != xcb_pad) {
5425         xcb_tmp += xcb_pad;
5426         xcb_pad = 0;
5427     }
5428     xcb_block_len = 0;
5429 
5430     return xcb_buffer_len;
5431 }
5432 
5433 xcb_void_cookie_t
xcb_open_font_checked(xcb_connection_t * c,xcb_font_t fid,uint16_t name_len,const char * name)5434 xcb_open_font_checked (xcb_connection_t *c,
5435                        xcb_font_t        fid,
5436                        uint16_t          name_len,
5437                        const char       *name)
5438 {
5439     static const xcb_protocol_request_t xcb_req = {
5440         .count = 4,
5441         .ext = 0,
5442         .opcode = XCB_OPEN_FONT,
5443         .isvoid = 1
5444     };
5445 
5446     struct iovec xcb_parts[6];
5447     xcb_void_cookie_t xcb_ret;
5448     xcb_open_font_request_t xcb_out;
5449 
5450     xcb_out.pad0 = 0;
5451     xcb_out.fid = fid;
5452     xcb_out.name_len = name_len;
5453     memset(xcb_out.pad1, 0, 2);
5454 
5455     xcb_parts[2].iov_base = (char *) &xcb_out;
5456     xcb_parts[2].iov_len = sizeof(xcb_out);
5457     xcb_parts[3].iov_base = 0;
5458     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5459     /* char name */
5460     xcb_parts[4].iov_base = (char *) name;
5461     xcb_parts[4].iov_len = name_len * sizeof(char);
5462     xcb_parts[5].iov_base = 0;
5463     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5464 
5465     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5466     return xcb_ret;
5467 }
5468 
5469 xcb_void_cookie_t
xcb_open_font(xcb_connection_t * c,xcb_font_t fid,uint16_t name_len,const char * name)5470 xcb_open_font (xcb_connection_t *c,
5471                xcb_font_t        fid,
5472                uint16_t          name_len,
5473                const char       *name)
5474 {
5475     static const xcb_protocol_request_t xcb_req = {
5476         .count = 4,
5477         .ext = 0,
5478         .opcode = XCB_OPEN_FONT,
5479         .isvoid = 1
5480     };
5481 
5482     struct iovec xcb_parts[6];
5483     xcb_void_cookie_t xcb_ret;
5484     xcb_open_font_request_t xcb_out;
5485 
5486     xcb_out.pad0 = 0;
5487     xcb_out.fid = fid;
5488     xcb_out.name_len = name_len;
5489     memset(xcb_out.pad1, 0, 2);
5490 
5491     xcb_parts[2].iov_base = (char *) &xcb_out;
5492     xcb_parts[2].iov_len = sizeof(xcb_out);
5493     xcb_parts[3].iov_base = 0;
5494     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5495     /* char name */
5496     xcb_parts[4].iov_base = (char *) name;
5497     xcb_parts[4].iov_len = name_len * sizeof(char);
5498     xcb_parts[5].iov_base = 0;
5499     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5500 
5501     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5502     return xcb_ret;
5503 }
5504 
5505 char *
xcb_open_font_name(const xcb_open_font_request_t * R)5506 xcb_open_font_name (const xcb_open_font_request_t *R)
5507 {
5508     return (char *) (R + 1);
5509 }
5510 
5511 int
xcb_open_font_name_length(const xcb_open_font_request_t * R)5512 xcb_open_font_name_length (const xcb_open_font_request_t *R)
5513 {
5514     return R->name_len;
5515 }
5516 
5517 xcb_generic_iterator_t
xcb_open_font_name_end(const xcb_open_font_request_t * R)5518 xcb_open_font_name_end (const xcb_open_font_request_t *R)
5519 {
5520     xcb_generic_iterator_t i;
5521     i.data = ((char *) (R + 1)) + (R->name_len);
5522     i.rem = 0;
5523     i.index = (char *) i.data - (char *) R;
5524     return i;
5525 }
5526 
5527 xcb_void_cookie_t
xcb_close_font_checked(xcb_connection_t * c,xcb_font_t font)5528 xcb_close_font_checked (xcb_connection_t *c,
5529                         xcb_font_t        font)
5530 {
5531     static const xcb_protocol_request_t xcb_req = {
5532         .count = 2,
5533         .ext = 0,
5534         .opcode = XCB_CLOSE_FONT,
5535         .isvoid = 1
5536     };
5537 
5538     struct iovec xcb_parts[4];
5539     xcb_void_cookie_t xcb_ret;
5540     xcb_close_font_request_t xcb_out;
5541 
5542     xcb_out.pad0 = 0;
5543     xcb_out.font = font;
5544 
5545     xcb_parts[2].iov_base = (char *) &xcb_out;
5546     xcb_parts[2].iov_len = sizeof(xcb_out);
5547     xcb_parts[3].iov_base = 0;
5548     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5549 
5550     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5551     return xcb_ret;
5552 }
5553 
5554 xcb_void_cookie_t
xcb_close_font(xcb_connection_t * c,xcb_font_t font)5555 xcb_close_font (xcb_connection_t *c,
5556                 xcb_font_t        font)
5557 {
5558     static const xcb_protocol_request_t xcb_req = {
5559         .count = 2,
5560         .ext = 0,
5561         .opcode = XCB_CLOSE_FONT,
5562         .isvoid = 1
5563     };
5564 
5565     struct iovec xcb_parts[4];
5566     xcb_void_cookie_t xcb_ret;
5567     xcb_close_font_request_t xcb_out;
5568 
5569     xcb_out.pad0 = 0;
5570     xcb_out.font = font;
5571 
5572     xcb_parts[2].iov_base = (char *) &xcb_out;
5573     xcb_parts[2].iov_len = sizeof(xcb_out);
5574     xcb_parts[3].iov_base = 0;
5575     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5576 
5577     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5578     return xcb_ret;
5579 }
5580 
5581 void
xcb_fontprop_next(xcb_fontprop_iterator_t * i)5582 xcb_fontprop_next (xcb_fontprop_iterator_t *i)
5583 {
5584     --i->rem;
5585     ++i->data;
5586     i->index += sizeof(xcb_fontprop_t);
5587 }
5588 
5589 xcb_generic_iterator_t
xcb_fontprop_end(xcb_fontprop_iterator_t i)5590 xcb_fontprop_end (xcb_fontprop_iterator_t i)
5591 {
5592     xcb_generic_iterator_t ret;
5593     ret.data = i.data + i.rem;
5594     ret.index = i.index + ((char *) ret.data - (char *) i.data);
5595     ret.rem = 0;
5596     return ret;
5597 }
5598 
5599 void
xcb_charinfo_next(xcb_charinfo_iterator_t * i)5600 xcb_charinfo_next (xcb_charinfo_iterator_t *i)
5601 {
5602     --i->rem;
5603     ++i->data;
5604     i->index += sizeof(xcb_charinfo_t);
5605 }
5606 
5607 xcb_generic_iterator_t
xcb_charinfo_end(xcb_charinfo_iterator_t i)5608 xcb_charinfo_end (xcb_charinfo_iterator_t i)
5609 {
5610     xcb_generic_iterator_t ret;
5611     ret.data = i.data + i.rem;
5612     ret.index = i.index + ((char *) ret.data - (char *) i.data);
5613     ret.rem = 0;
5614     return ret;
5615 }
5616 
5617 int
xcb_query_font_sizeof(const void * _buffer)5618 xcb_query_font_sizeof (const void  *_buffer)
5619 {
5620     char *xcb_tmp = (char *)_buffer;
5621     const xcb_query_font_reply_t *_aux = (xcb_query_font_reply_t *)_buffer;
5622     unsigned int xcb_buffer_len = 0;
5623     unsigned int xcb_block_len = 0;
5624     unsigned int xcb_pad = 0;
5625     unsigned int xcb_align_to = 0;
5626 
5627 
5628     xcb_block_len += sizeof(xcb_query_font_reply_t);
5629     xcb_tmp += xcb_block_len;
5630     xcb_buffer_len += xcb_block_len;
5631     xcb_block_len = 0;
5632     /* properties */
5633     xcb_block_len += _aux->properties_len * sizeof(xcb_fontprop_t);
5634     xcb_tmp += xcb_block_len;
5635     xcb_align_to = ALIGNOF(xcb_fontprop_t);
5636     /* insert padding */
5637     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5638     xcb_buffer_len += xcb_block_len + xcb_pad;
5639     if (0 != xcb_pad) {
5640         xcb_tmp += xcb_pad;
5641         xcb_pad = 0;
5642     }
5643     xcb_block_len = 0;
5644     /* char_infos */
5645     xcb_block_len += _aux->char_infos_len * sizeof(xcb_charinfo_t);
5646     xcb_tmp += xcb_block_len;
5647     xcb_align_to = ALIGNOF(xcb_charinfo_t);
5648     /* insert padding */
5649     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5650     xcb_buffer_len += xcb_block_len + xcb_pad;
5651     if (0 != xcb_pad) {
5652         xcb_tmp += xcb_pad;
5653         xcb_pad = 0;
5654     }
5655     xcb_block_len = 0;
5656 
5657     return xcb_buffer_len;
5658 }
5659 
5660 xcb_query_font_cookie_t
xcb_query_font(xcb_connection_t * c,xcb_fontable_t font)5661 xcb_query_font (xcb_connection_t *c,
5662                 xcb_fontable_t    font)
5663 {
5664     static const xcb_protocol_request_t xcb_req = {
5665         .count = 2,
5666         .ext = 0,
5667         .opcode = XCB_QUERY_FONT,
5668         .isvoid = 0
5669     };
5670 
5671     struct iovec xcb_parts[4];
5672     xcb_query_font_cookie_t xcb_ret;
5673     xcb_query_font_request_t xcb_out;
5674 
5675     xcb_out.pad0 = 0;
5676     xcb_out.font = font;
5677 
5678     xcb_parts[2].iov_base = (char *) &xcb_out;
5679     xcb_parts[2].iov_len = sizeof(xcb_out);
5680     xcb_parts[3].iov_base = 0;
5681     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5682 
5683     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5684     return xcb_ret;
5685 }
5686 
5687 xcb_query_font_cookie_t
xcb_query_font_unchecked(xcb_connection_t * c,xcb_fontable_t font)5688 xcb_query_font_unchecked (xcb_connection_t *c,
5689                           xcb_fontable_t    font)
5690 {
5691     static const xcb_protocol_request_t xcb_req = {
5692         .count = 2,
5693         .ext = 0,
5694         .opcode = XCB_QUERY_FONT,
5695         .isvoid = 0
5696     };
5697 
5698     struct iovec xcb_parts[4];
5699     xcb_query_font_cookie_t xcb_ret;
5700     xcb_query_font_request_t xcb_out;
5701 
5702     xcb_out.pad0 = 0;
5703     xcb_out.font = font;
5704 
5705     xcb_parts[2].iov_base = (char *) &xcb_out;
5706     xcb_parts[2].iov_len = sizeof(xcb_out);
5707     xcb_parts[3].iov_base = 0;
5708     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5709 
5710     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5711     return xcb_ret;
5712 }
5713 
5714 xcb_fontprop_t *
xcb_query_font_properties(const xcb_query_font_reply_t * R)5715 xcb_query_font_properties (const xcb_query_font_reply_t *R)
5716 {
5717     return (xcb_fontprop_t *) (R + 1);
5718 }
5719 
5720 int
xcb_query_font_properties_length(const xcb_query_font_reply_t * R)5721 xcb_query_font_properties_length (const xcb_query_font_reply_t *R)
5722 {
5723     return R->properties_len;
5724 }
5725 
5726 xcb_fontprop_iterator_t
xcb_query_font_properties_iterator(const xcb_query_font_reply_t * R)5727 xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R)
5728 {
5729     xcb_fontprop_iterator_t i;
5730     i.data = (xcb_fontprop_t *) (R + 1);
5731     i.rem = R->properties_len;
5732     i.index = (char *) i.data - (char *) R;
5733     return i;
5734 }
5735 
5736 xcb_charinfo_t *
xcb_query_font_char_infos(const xcb_query_font_reply_t * R)5737 xcb_query_font_char_infos (const xcb_query_font_reply_t *R)
5738 {
5739     xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R));
5740     return (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index) + 0);
5741 }
5742 
5743 int
xcb_query_font_char_infos_length(const xcb_query_font_reply_t * R)5744 xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R)
5745 {
5746     return R->char_infos_len;
5747 }
5748 
5749 xcb_charinfo_iterator_t
xcb_query_font_char_infos_iterator(const xcb_query_font_reply_t * R)5750 xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R)
5751 {
5752     xcb_charinfo_iterator_t i;
5753     xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R));
5754     i.data = (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index));
5755     i.rem = R->char_infos_len;
5756     i.index = (char *) i.data - (char *) R;
5757     return i;
5758 }
5759 
5760 xcb_query_font_reply_t *
xcb_query_font_reply(xcb_connection_t * c,xcb_query_font_cookie_t cookie,xcb_generic_error_t ** e)5761 xcb_query_font_reply (xcb_connection_t         *c,
5762                       xcb_query_font_cookie_t   cookie  /**< */,
5763                       xcb_generic_error_t     **e)
5764 {
5765     return (xcb_query_font_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5766 }
5767 
5768 int
xcb_query_text_extents_sizeof(const void * _buffer,uint32_t string_len)5769 xcb_query_text_extents_sizeof (const void  *_buffer,
5770                                uint32_t     string_len)
5771 {
5772     char *xcb_tmp = (char *)_buffer;
5773     unsigned int xcb_buffer_len = 0;
5774     unsigned int xcb_block_len = 0;
5775     unsigned int xcb_pad = 0;
5776     unsigned int xcb_align_to = 0;
5777 
5778 
5779     xcb_block_len += sizeof(xcb_query_text_extents_request_t);
5780     xcb_tmp += xcb_block_len;
5781     xcb_buffer_len += xcb_block_len;
5782     xcb_block_len = 0;
5783     /* string */
5784     xcb_block_len += string_len * sizeof(xcb_char2b_t);
5785     xcb_tmp += xcb_block_len;
5786     xcb_align_to = ALIGNOF(xcb_char2b_t);
5787     /* insert padding */
5788     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5789     xcb_buffer_len += xcb_block_len + xcb_pad;
5790     if (0 != xcb_pad) {
5791         xcb_tmp += xcb_pad;
5792         xcb_pad = 0;
5793     }
5794     xcb_block_len = 0;
5795 
5796     return xcb_buffer_len;
5797 }
5798 
5799 xcb_query_text_extents_cookie_t
xcb_query_text_extents(xcb_connection_t * c,xcb_fontable_t font,uint32_t string_len,const xcb_char2b_t * string)5800 xcb_query_text_extents (xcb_connection_t   *c,
5801                         xcb_fontable_t      font,
5802                         uint32_t            string_len,
5803                         const xcb_char2b_t *string)
5804 {
5805     static const xcb_protocol_request_t xcb_req = {
5806         .count = 4,
5807         .ext = 0,
5808         .opcode = XCB_QUERY_TEXT_EXTENTS,
5809         .isvoid = 0
5810     };
5811 
5812     struct iovec xcb_parts[6];
5813     xcb_query_text_extents_cookie_t xcb_ret;
5814     xcb_query_text_extents_request_t xcb_out;
5815 
5816     xcb_out.odd_length = (string_len & 1);
5817     xcb_out.font = font;
5818 
5819     xcb_parts[2].iov_base = (char *) &xcb_out;
5820     xcb_parts[2].iov_len = sizeof(xcb_out);
5821     xcb_parts[3].iov_base = 0;
5822     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5823     /* xcb_char2b_t string */
5824     xcb_parts[4].iov_base = (char *) string;
5825     xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
5826     xcb_parts[5].iov_base = 0;
5827     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5828 
5829     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5830     return xcb_ret;
5831 }
5832 
5833 xcb_query_text_extents_cookie_t
xcb_query_text_extents_unchecked(xcb_connection_t * c,xcb_fontable_t font,uint32_t string_len,const xcb_char2b_t * string)5834 xcb_query_text_extents_unchecked (xcb_connection_t   *c,
5835                                   xcb_fontable_t      font,
5836                                   uint32_t            string_len,
5837                                   const xcb_char2b_t *string)
5838 {
5839     static const xcb_protocol_request_t xcb_req = {
5840         .count = 4,
5841         .ext = 0,
5842         .opcode = XCB_QUERY_TEXT_EXTENTS,
5843         .isvoid = 0
5844     };
5845 
5846     struct iovec xcb_parts[6];
5847     xcb_query_text_extents_cookie_t xcb_ret;
5848     xcb_query_text_extents_request_t xcb_out;
5849 
5850     xcb_out.odd_length = (string_len & 1);
5851     xcb_out.font = font;
5852 
5853     xcb_parts[2].iov_base = (char *) &xcb_out;
5854     xcb_parts[2].iov_len = sizeof(xcb_out);
5855     xcb_parts[3].iov_base = 0;
5856     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5857     /* xcb_char2b_t string */
5858     xcb_parts[4].iov_base = (char *) string;
5859     xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
5860     xcb_parts[5].iov_base = 0;
5861     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5862 
5863     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5864     return xcb_ret;
5865 }
5866 
5867 xcb_query_text_extents_reply_t *
xcb_query_text_extents_reply(xcb_connection_t * c,xcb_query_text_extents_cookie_t cookie,xcb_generic_error_t ** e)5868 xcb_query_text_extents_reply (xcb_connection_t                 *c,
5869                               xcb_query_text_extents_cookie_t   cookie  /**< */,
5870                               xcb_generic_error_t             **e)
5871 {
5872     return (xcb_query_text_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5873 }
5874 
5875 int
xcb_str_sizeof(const void * _buffer)5876 xcb_str_sizeof (const void  *_buffer)
5877 {
5878     char *xcb_tmp = (char *)_buffer;
5879     const xcb_str_t *_aux = (xcb_str_t *)_buffer;
5880     unsigned int xcb_buffer_len = 0;
5881     unsigned int xcb_block_len = 0;
5882     unsigned int xcb_pad = 0;
5883     unsigned int xcb_align_to = 0;
5884 
5885 
5886     xcb_block_len += sizeof(xcb_str_t);
5887     xcb_tmp += xcb_block_len;
5888     xcb_buffer_len += xcb_block_len;
5889     xcb_block_len = 0;
5890     /* name */
5891     xcb_block_len += _aux->name_len * sizeof(char);
5892     xcb_tmp += xcb_block_len;
5893     xcb_align_to = ALIGNOF(char);
5894     /* insert padding */
5895     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5896     xcb_buffer_len += xcb_block_len + xcb_pad;
5897     if (0 != xcb_pad) {
5898         xcb_tmp += xcb_pad;
5899         xcb_pad = 0;
5900     }
5901     xcb_block_len = 0;
5902 
5903     return xcb_buffer_len;
5904 }
5905 
5906 char *
xcb_str_name(const xcb_str_t * R)5907 xcb_str_name (const xcb_str_t *R)
5908 {
5909     return (char *) (R + 1);
5910 }
5911 
5912 int
xcb_str_name_length(const xcb_str_t * R)5913 xcb_str_name_length (const xcb_str_t *R)
5914 {
5915     return R->name_len;
5916 }
5917 
5918 xcb_generic_iterator_t
xcb_str_name_end(const xcb_str_t * R)5919 xcb_str_name_end (const xcb_str_t *R)
5920 {
5921     xcb_generic_iterator_t i;
5922     i.data = ((char *) (R + 1)) + (R->name_len);
5923     i.rem = 0;
5924     i.index = (char *) i.data - (char *) R;
5925     return i;
5926 }
5927 
5928 void
xcb_str_next(xcb_str_iterator_t * i)5929 xcb_str_next (xcb_str_iterator_t *i)
5930 {
5931     xcb_str_t *R = i->data;
5932     xcb_generic_iterator_t child;
5933     child.data = (xcb_str_t *)(((char *)R) + xcb_str_sizeof(R));
5934     i->index = (char *) child.data - (char *) i->data;
5935     --i->rem;
5936     i->data = (xcb_str_t *) child.data;
5937 }
5938 
5939 xcb_generic_iterator_t
xcb_str_end(xcb_str_iterator_t i)5940 xcb_str_end (xcb_str_iterator_t i)
5941 {
5942     xcb_generic_iterator_t ret;
5943     while(i.rem > 0)
5944         xcb_str_next(&i);
5945     ret.data = i.data;
5946     ret.rem = i.rem;
5947     ret.index = i.index;
5948     return ret;
5949 }
5950 
5951 int
xcb_list_fonts_sizeof(const void * _buffer)5952 xcb_list_fonts_sizeof (const void  *_buffer)
5953 {
5954     char *xcb_tmp = (char *)_buffer;
5955     const xcb_list_fonts_request_t *_aux = (xcb_list_fonts_request_t *)_buffer;
5956     unsigned int xcb_buffer_len = 0;
5957     unsigned int xcb_block_len = 0;
5958     unsigned int xcb_pad = 0;
5959     unsigned int xcb_align_to = 0;
5960 
5961 
5962     xcb_block_len += sizeof(xcb_list_fonts_request_t);
5963     xcb_tmp += xcb_block_len;
5964     xcb_buffer_len += xcb_block_len;
5965     xcb_block_len = 0;
5966     /* pattern */
5967     xcb_block_len += _aux->pattern_len * sizeof(char);
5968     xcb_tmp += xcb_block_len;
5969     xcb_align_to = ALIGNOF(char);
5970     /* insert padding */
5971     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5972     xcb_buffer_len += xcb_block_len + xcb_pad;
5973     if (0 != xcb_pad) {
5974         xcb_tmp += xcb_pad;
5975         xcb_pad = 0;
5976     }
5977     xcb_block_len = 0;
5978 
5979     return xcb_buffer_len;
5980 }
5981 
5982 xcb_list_fonts_cookie_t
xcb_list_fonts(xcb_connection_t * c,uint16_t max_names,uint16_t pattern_len,const char * pattern)5983 xcb_list_fonts (xcb_connection_t *c,
5984                 uint16_t          max_names,
5985                 uint16_t          pattern_len,
5986                 const char       *pattern)
5987 {
5988     static const xcb_protocol_request_t xcb_req = {
5989         .count = 4,
5990         .ext = 0,
5991         .opcode = XCB_LIST_FONTS,
5992         .isvoid = 0
5993     };
5994 
5995     struct iovec xcb_parts[6];
5996     xcb_list_fonts_cookie_t xcb_ret;
5997     xcb_list_fonts_request_t xcb_out;
5998 
5999     xcb_out.pad0 = 0;
6000     xcb_out.max_names = max_names;
6001     xcb_out.pattern_len = pattern_len;
6002 
6003     xcb_parts[2].iov_base = (char *) &xcb_out;
6004     xcb_parts[2].iov_len = sizeof(xcb_out);
6005     xcb_parts[3].iov_base = 0;
6006     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6007     /* char pattern */
6008     xcb_parts[4].iov_base = (char *) pattern;
6009     xcb_parts[4].iov_len = pattern_len * sizeof(char);
6010     xcb_parts[5].iov_base = 0;
6011     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6012 
6013     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6014     return xcb_ret;
6015 }
6016 
6017 xcb_list_fonts_cookie_t
xcb_list_fonts_unchecked(xcb_connection_t * c,uint16_t max_names,uint16_t pattern_len,const char * pattern)6018 xcb_list_fonts_unchecked (xcb_connection_t *c,
6019                           uint16_t          max_names,
6020                           uint16_t          pattern_len,
6021                           const char       *pattern)
6022 {
6023     static const xcb_protocol_request_t xcb_req = {
6024         .count = 4,
6025         .ext = 0,
6026         .opcode = XCB_LIST_FONTS,
6027         .isvoid = 0
6028     };
6029 
6030     struct iovec xcb_parts[6];
6031     xcb_list_fonts_cookie_t xcb_ret;
6032     xcb_list_fonts_request_t xcb_out;
6033 
6034     xcb_out.pad0 = 0;
6035     xcb_out.max_names = max_names;
6036     xcb_out.pattern_len = pattern_len;
6037 
6038     xcb_parts[2].iov_base = (char *) &xcb_out;
6039     xcb_parts[2].iov_len = sizeof(xcb_out);
6040     xcb_parts[3].iov_base = 0;
6041     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6042     /* char pattern */
6043     xcb_parts[4].iov_base = (char *) pattern;
6044     xcb_parts[4].iov_len = pattern_len * sizeof(char);
6045     xcb_parts[5].iov_base = 0;
6046     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6047 
6048     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6049     return xcb_ret;
6050 }
6051 
6052 int
xcb_list_fonts_names_length(const xcb_list_fonts_reply_t * R)6053 xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R)
6054 {
6055     return R->names_len;
6056 }
6057 
6058 xcb_str_iterator_t
xcb_list_fonts_names_iterator(const xcb_list_fonts_reply_t * R)6059 xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R)
6060 {
6061     xcb_str_iterator_t i;
6062     i.data = (xcb_str_t *) (R + 1);
6063     i.rem = R->names_len;
6064     i.index = (char *) i.data - (char *) R;
6065     return i;
6066 }
6067 
6068 xcb_list_fonts_reply_t *
xcb_list_fonts_reply(xcb_connection_t * c,xcb_list_fonts_cookie_t cookie,xcb_generic_error_t ** e)6069 xcb_list_fonts_reply (xcb_connection_t         *c,
6070                       xcb_list_fonts_cookie_t   cookie  /**< */,
6071                       xcb_generic_error_t     **e)
6072 {
6073     return (xcb_list_fonts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
6074 }
6075 
6076 int
xcb_list_fonts_with_info_sizeof(const void * _buffer)6077 xcb_list_fonts_with_info_sizeof (const void  *_buffer)
6078 {
6079     char *xcb_tmp = (char *)_buffer;
6080     const xcb_list_fonts_with_info_request_t *_aux = (xcb_list_fonts_with_info_request_t *)_buffer;
6081     unsigned int xcb_buffer_len = 0;
6082     unsigned int xcb_block_len = 0;
6083     unsigned int xcb_pad = 0;
6084     unsigned int xcb_align_to = 0;
6085 
6086 
6087     xcb_block_len += sizeof(xcb_list_fonts_with_info_request_t);
6088     xcb_tmp += xcb_block_len;
6089     xcb_buffer_len += xcb_block_len;
6090     xcb_block_len = 0;
6091     /* pattern */
6092     xcb_block_len += _aux->pattern_len * sizeof(char);
6093     xcb_tmp += xcb_block_len;
6094     xcb_align_to = ALIGNOF(char);
6095     /* insert padding */
6096     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6097     xcb_buffer_len += xcb_block_len + xcb_pad;
6098     if (0 != xcb_pad) {
6099         xcb_tmp += xcb_pad;
6100         xcb_pad = 0;
6101     }
6102     xcb_block_len = 0;
6103 
6104     return xcb_buffer_len;
6105 }
6106 
6107 xcb_list_fonts_with_info_cookie_t
xcb_list_fonts_with_info(xcb_connection_t * c,uint16_t max_names,uint16_t pattern_len,const char * pattern)6108 xcb_list_fonts_with_info (xcb_connection_t *c,
6109                           uint16_t          max_names,
6110                           uint16_t          pattern_len,
6111                           const char       *pattern)
6112 {
6113     static const xcb_protocol_request_t xcb_req = {
6114         .count = 4,
6115         .ext = 0,
6116         .opcode = XCB_LIST_FONTS_WITH_INFO,
6117         .isvoid = 0
6118     };
6119 
6120     struct iovec xcb_parts[6];
6121     xcb_list_fonts_with_info_cookie_t xcb_ret;
6122     xcb_list_fonts_with_info_request_t xcb_out;
6123 
6124     xcb_out.pad0 = 0;
6125     xcb_out.max_names = max_names;
6126     xcb_out.pattern_len = pattern_len;
6127 
6128     xcb_parts[2].iov_base = (char *) &xcb_out;
6129     xcb_parts[2].iov_len = sizeof(xcb_out);
6130     xcb_parts[3].iov_base = 0;
6131     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6132     /* char pattern */
6133     xcb_parts[4].iov_base = (char *) pattern;
6134     xcb_parts[4].iov_len = pattern_len * sizeof(char);
6135     xcb_parts[5].iov_base = 0;
6136     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6137 
6138     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6139     return xcb_ret;
6140 }
6141 
6142 xcb_list_fonts_with_info_cookie_t
xcb_list_fonts_with_info_unchecked(xcb_connection_t * c,uint16_t max_names,uint16_t pattern_len,const char * pattern)6143 xcb_list_fonts_with_info_unchecked (xcb_connection_t *c,
6144                                     uint16_t          max_names,
6145                                     uint16_t          pattern_len,
6146                                     const char       *pattern)
6147 {
6148     static const xcb_protocol_request_t xcb_req = {
6149         .count = 4,
6150         .ext = 0,
6151         .opcode = XCB_LIST_FONTS_WITH_INFO,
6152         .isvoid = 0
6153     };
6154 
6155     struct iovec xcb_parts[6];
6156     xcb_list_fonts_with_info_cookie_t xcb_ret;
6157     xcb_list_fonts_with_info_request_t xcb_out;
6158 
6159     xcb_out.pad0 = 0;
6160     xcb_out.max_names = max_names;
6161     xcb_out.pattern_len = pattern_len;
6162 
6163     xcb_parts[2].iov_base = (char *) &xcb_out;
6164     xcb_parts[2].iov_len = sizeof(xcb_out);
6165     xcb_parts[3].iov_base = 0;
6166     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6167     /* char pattern */
6168     xcb_parts[4].iov_base = (char *) pattern;
6169     xcb_parts[4].iov_len = pattern_len * sizeof(char);
6170     xcb_parts[5].iov_base = 0;
6171     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6172 
6173     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6174     return xcb_ret;
6175 }
6176 
6177 xcb_fontprop_t *
xcb_list_fonts_with_info_properties(const xcb_list_fonts_with_info_reply_t * R)6178 xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R)
6179 {
6180     return (xcb_fontprop_t *) (R + 1);
6181 }
6182 
6183 int
xcb_list_fonts_with_info_properties_length(const xcb_list_fonts_with_info_reply_t * R)6184 xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R)
6185 {
6186     return R->properties_len;
6187 }
6188 
6189 xcb_fontprop_iterator_t
xcb_list_fonts_with_info_properties_iterator(const xcb_list_fonts_with_info_reply_t * R)6190 xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R)
6191 {
6192     xcb_fontprop_iterator_t i;
6193     i.data = (xcb_fontprop_t *) (R + 1);
6194     i.rem = R->properties_len;
6195     i.index = (char *) i.data - (char *) R;
6196     return i;
6197 }
6198 
6199 char *
xcb_list_fonts_with_info_name(const xcb_list_fonts_with_info_reply_t * R)6200 xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R)
6201 {
6202     xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R));
6203     return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
6204 }
6205 
6206 int
xcb_list_fonts_with_info_name_length(const xcb_list_fonts_with_info_reply_t * R)6207 xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R)
6208 {
6209     return R->name_len;
6210 }
6211 
6212 xcb_generic_iterator_t
xcb_list_fonts_with_info_name_end(const xcb_list_fonts_with_info_reply_t * R)6213 xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R)
6214 {
6215     xcb_generic_iterator_t i;
6216     xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R));
6217     i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->name_len);
6218     i.rem = 0;
6219     i.index = (char *) i.data - (char *) R;
6220     return i;
6221 }
6222 
6223 xcb_list_fonts_with_info_reply_t *
xcb_list_fonts_with_info_reply(xcb_connection_t * c,xcb_list_fonts_with_info_cookie_t cookie,xcb_generic_error_t ** e)6224 xcb_list_fonts_with_info_reply (xcb_connection_t                   *c,
6225                                 xcb_list_fonts_with_info_cookie_t   cookie  /**< */,
6226                                 xcb_generic_error_t               **e)
6227 {
6228     return (xcb_list_fonts_with_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
6229 }
6230 
6231 int
xcb_set_font_path_sizeof(const void * _buffer)6232 xcb_set_font_path_sizeof (const void  *_buffer)
6233 {
6234     char *xcb_tmp = (char *)_buffer;
6235     const xcb_set_font_path_request_t *_aux = (xcb_set_font_path_request_t *)_buffer;
6236     unsigned int xcb_buffer_len = 0;
6237     unsigned int xcb_block_len = 0;
6238     unsigned int xcb_pad = 0;
6239     unsigned int xcb_align_to = 0;
6240 
6241     unsigned int i;
6242     unsigned int xcb_tmp_len;
6243 
6244     xcb_block_len += sizeof(xcb_set_font_path_request_t);
6245     xcb_tmp += xcb_block_len;
6246     xcb_buffer_len += xcb_block_len;
6247     xcb_block_len = 0;
6248     /* font */
6249     for(i=0; i<_aux->font_qty; i++) {
6250         xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
6251         xcb_block_len += xcb_tmp_len;
6252         xcb_tmp += xcb_tmp_len;
6253     }
6254     xcb_align_to = ALIGNOF(xcb_str_t);
6255     /* insert padding */
6256     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6257     xcb_buffer_len += xcb_block_len + xcb_pad;
6258     if (0 != xcb_pad) {
6259         xcb_tmp += xcb_pad;
6260         xcb_pad = 0;
6261     }
6262     xcb_block_len = 0;
6263 
6264     return xcb_buffer_len;
6265 }
6266 
6267 xcb_void_cookie_t
xcb_set_font_path_checked(xcb_connection_t * c,uint16_t font_qty,const xcb_str_t * font)6268 xcb_set_font_path_checked (xcb_connection_t *c,
6269                            uint16_t          font_qty,
6270                            const xcb_str_t  *font)
6271 {
6272     static const xcb_protocol_request_t xcb_req = {
6273         .count = 4,
6274         .ext = 0,
6275         .opcode = XCB_SET_FONT_PATH,
6276         .isvoid = 1
6277     };
6278 
6279     struct iovec xcb_parts[6];
6280     xcb_void_cookie_t xcb_ret;
6281     xcb_set_font_path_request_t xcb_out;
6282     unsigned int xcb_tmp_len;
6283     char *xcb_tmp;
6284     unsigned int i;
6285 
6286     xcb_out.pad0 = 0;
6287     xcb_out.font_qty = font_qty;
6288     memset(xcb_out.pad1, 0, 2);
6289 
6290     xcb_parts[2].iov_base = (char *) &xcb_out;
6291     xcb_parts[2].iov_len = sizeof(xcb_out);
6292     xcb_parts[3].iov_base = 0;
6293     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6294     /* xcb_str_t font */
6295     xcb_parts[4].iov_base = (char *) font;
6296     xcb_parts[4].iov_len = 0;
6297     xcb_tmp = (char *)font;
6298     for(i=0; i<font_qty; i++) {
6299         xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
6300         xcb_parts[4].iov_len += xcb_tmp_len;
6301         xcb_tmp += xcb_tmp_len;
6302     }
6303     xcb_parts[5].iov_base = 0;
6304     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6305 
6306     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6307     return xcb_ret;
6308 }
6309 
6310 xcb_void_cookie_t
xcb_set_font_path(xcb_connection_t * c,uint16_t font_qty,const xcb_str_t * font)6311 xcb_set_font_path (xcb_connection_t *c,
6312                    uint16_t          font_qty,
6313                    const xcb_str_t  *font)
6314 {
6315     static const xcb_protocol_request_t xcb_req = {
6316         .count = 4,
6317         .ext = 0,
6318         .opcode = XCB_SET_FONT_PATH,
6319         .isvoid = 1
6320     };
6321 
6322     struct iovec xcb_parts[6];
6323     xcb_void_cookie_t xcb_ret;
6324     xcb_set_font_path_request_t xcb_out;
6325     unsigned int xcb_tmp_len;
6326     char *xcb_tmp;
6327     unsigned int i;
6328 
6329     xcb_out.pad0 = 0;
6330     xcb_out.font_qty = font_qty;
6331     memset(xcb_out.pad1, 0, 2);
6332 
6333     xcb_parts[2].iov_base = (char *) &xcb_out;
6334     xcb_parts[2].iov_len = sizeof(xcb_out);
6335     xcb_parts[3].iov_base = 0;
6336     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6337     /* xcb_str_t font */
6338     xcb_parts[4].iov_base = (char *) font;
6339     xcb_parts[4].iov_len = 0;
6340     xcb_tmp = (char *)font;
6341     for(i=0; i<font_qty; i++) {
6342         xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
6343         xcb_parts[4].iov_len += xcb_tmp_len;
6344         xcb_tmp += xcb_tmp_len;
6345     }
6346     xcb_parts[5].iov_base = 0;
6347     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
6348 
6349     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6350     return xcb_ret;
6351 }
6352 
6353 int
xcb_set_font_path_font_length(const xcb_set_font_path_request_t * R)6354 xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R)
6355 {
6356     return R->font_qty;
6357 }
6358 
6359 xcb_str_iterator_t
xcb_set_font_path_font_iterator(const xcb_set_font_path_request_t * R)6360 xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R)
6361 {
6362     xcb_str_iterator_t i;
6363     i.data = (xcb_str_t *) (R + 1);
6364     i.rem = R->font_qty;
6365     i.index = (char *) i.data - (char *) R;
6366     return i;
6367 }
6368 
6369 int
xcb_get_font_path_sizeof(const void * _buffer)6370 xcb_get_font_path_sizeof (const void  *_buffer)
6371 {
6372     char *xcb_tmp = (char *)_buffer;
6373     const xcb_get_font_path_reply_t *_aux = (xcb_get_font_path_reply_t *)_buffer;
6374     unsigned int xcb_buffer_len = 0;
6375     unsigned int xcb_block_len = 0;
6376     unsigned int xcb_pad = 0;
6377     unsigned int xcb_align_to = 0;
6378 
6379     unsigned int i;
6380     unsigned int xcb_tmp_len;
6381 
6382     xcb_block_len += sizeof(xcb_get_font_path_reply_t);
6383     xcb_tmp += xcb_block_len;
6384     xcb_buffer_len += xcb_block_len;
6385     xcb_block_len = 0;
6386     /* path */
6387     for(i=0; i<_aux->path_len; i++) {
6388         xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
6389         xcb_block_len += xcb_tmp_len;
6390         xcb_tmp += xcb_tmp_len;
6391     }
6392     xcb_align_to = ALIGNOF(xcb_str_t);
6393     /* insert padding */
6394     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6395     xcb_buffer_len += xcb_block_len + xcb_pad;
6396     if (0 != xcb_pad) {
6397         xcb_tmp += xcb_pad;
6398         xcb_pad = 0;
6399     }
6400     xcb_block_len = 0;
6401 
6402     return xcb_buffer_len;
6403 }
6404 
6405 xcb_get_font_path_cookie_t
xcb_get_font_path(xcb_connection_t * c)6406 xcb_get_font_path (xcb_connection_t *c)
6407 {
6408     static const xcb_protocol_request_t xcb_req = {
6409         .count = 2,
6410         .ext = 0,
6411         .opcode = XCB_GET_FONT_PATH,
6412         .isvoid = 0
6413     };
6414 
6415     struct iovec xcb_parts[4];
6416     xcb_get_font_path_cookie_t xcb_ret;
6417     xcb_get_font_path_request_t xcb_out;
6418 
6419     xcb_out.pad0 = 0;
6420 
6421     xcb_parts[2].iov_base = (char *) &xcb_out;
6422     xcb_parts[2].iov_len = sizeof(xcb_out);
6423     xcb_parts[3].iov_base = 0;
6424     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6425 
6426     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6427     return xcb_ret;
6428 }
6429 
6430 xcb_get_font_path_cookie_t
xcb_get_font_path_unchecked(xcb_connection_t * c)6431 xcb_get_font_path_unchecked (xcb_connection_t *c)
6432 {
6433     static const xcb_protocol_request_t xcb_req = {
6434         .count = 2,
6435         .ext = 0,
6436         .opcode = XCB_GET_FONT_PATH,
6437         .isvoid = 0
6438     };
6439 
6440     struct iovec xcb_parts[4];
6441     xcb_get_font_path_cookie_t xcb_ret;
6442     xcb_get_font_path_request_t xcb_out;
6443 
6444     xcb_out.pad0 = 0;
6445 
6446     xcb_parts[2].iov_base = (char *) &xcb_out;
6447     xcb_parts[2].iov_len = sizeof(xcb_out);
6448     xcb_parts[3].iov_base = 0;
6449     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6450 
6451     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6452     return xcb_ret;
6453 }
6454 
6455 int
xcb_get_font_path_path_length(const xcb_get_font_path_reply_t * R)6456 xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R)
6457 {
6458     return R->path_len;
6459 }
6460 
6461 xcb_str_iterator_t
xcb_get_font_path_path_iterator(const xcb_get_font_path_reply_t * R)6462 xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R)
6463 {
6464     xcb_str_iterator_t i;
6465     i.data = (xcb_str_t *) (R + 1);
6466     i.rem = R->path_len;
6467     i.index = (char *) i.data - (char *) R;
6468     return i;
6469 }
6470 
6471 xcb_get_font_path_reply_t *
xcb_get_font_path_reply(xcb_connection_t * c,xcb_get_font_path_cookie_t cookie,xcb_generic_error_t ** e)6472 xcb_get_font_path_reply (xcb_connection_t            *c,
6473                          xcb_get_font_path_cookie_t   cookie  /**< */,
6474                          xcb_generic_error_t        **e)
6475 {
6476     return (xcb_get_font_path_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
6477 }
6478 
6479 xcb_void_cookie_t
xcb_create_pixmap_checked(xcb_connection_t * c,uint8_t depth,xcb_pixmap_t pid,xcb_drawable_t drawable,uint16_t width,uint16_t height)6480 xcb_create_pixmap_checked (xcb_connection_t *c,
6481                            uint8_t           depth,
6482                            xcb_pixmap_t      pid,
6483                            xcb_drawable_t    drawable,
6484                            uint16_t          width,
6485                            uint16_t          height)
6486 {
6487     static const xcb_protocol_request_t xcb_req = {
6488         .count = 2,
6489         .ext = 0,
6490         .opcode = XCB_CREATE_PIXMAP,
6491         .isvoid = 1
6492     };
6493 
6494     struct iovec xcb_parts[4];
6495     xcb_void_cookie_t xcb_ret;
6496     xcb_create_pixmap_request_t xcb_out;
6497 
6498     xcb_out.depth = depth;
6499     xcb_out.pid = pid;
6500     xcb_out.drawable = drawable;
6501     xcb_out.width = width;
6502     xcb_out.height = height;
6503 
6504     xcb_parts[2].iov_base = (char *) &xcb_out;
6505     xcb_parts[2].iov_len = sizeof(xcb_out);
6506     xcb_parts[3].iov_base = 0;
6507     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6508 
6509     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6510     return xcb_ret;
6511 }
6512 
6513 xcb_void_cookie_t
xcb_create_pixmap(xcb_connection_t * c,uint8_t depth,xcb_pixmap_t pid,xcb_drawable_t drawable,uint16_t width,uint16_t height)6514 xcb_create_pixmap (xcb_connection_t *c,
6515                    uint8_t           depth,
6516                    xcb_pixmap_t      pid,
6517                    xcb_drawable_t    drawable,
6518                    uint16_t          width,
6519                    uint16_t          height)
6520 {
6521     static const xcb_protocol_request_t xcb_req = {
6522         .count = 2,
6523         .ext = 0,
6524         .opcode = XCB_CREATE_PIXMAP,
6525         .isvoid = 1
6526     };
6527 
6528     struct iovec xcb_parts[4];
6529     xcb_void_cookie_t xcb_ret;
6530     xcb_create_pixmap_request_t xcb_out;
6531 
6532     xcb_out.depth = depth;
6533     xcb_out.pid = pid;
6534     xcb_out.drawable = drawable;
6535     xcb_out.width = width;
6536     xcb_out.height = height;
6537 
6538     xcb_parts[2].iov_base = (char *) &xcb_out;
6539     xcb_parts[2].iov_len = sizeof(xcb_out);
6540     xcb_parts[3].iov_base = 0;
6541     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6542 
6543     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6544     return xcb_ret;
6545 }
6546 
6547 xcb_void_cookie_t
xcb_free_pixmap_checked(xcb_connection_t * c,xcb_pixmap_t pixmap)6548 xcb_free_pixmap_checked (xcb_connection_t *c,
6549                          xcb_pixmap_t      pixmap)
6550 {
6551     static const xcb_protocol_request_t xcb_req = {
6552         .count = 2,
6553         .ext = 0,
6554         .opcode = XCB_FREE_PIXMAP,
6555         .isvoid = 1
6556     };
6557 
6558     struct iovec xcb_parts[4];
6559     xcb_void_cookie_t xcb_ret;
6560     xcb_free_pixmap_request_t xcb_out;
6561 
6562     xcb_out.pad0 = 0;
6563     xcb_out.pixmap = pixmap;
6564 
6565     xcb_parts[2].iov_base = (char *) &xcb_out;
6566     xcb_parts[2].iov_len = sizeof(xcb_out);
6567     xcb_parts[3].iov_base = 0;
6568     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6569 
6570     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6571     return xcb_ret;
6572 }
6573 
6574 xcb_void_cookie_t
xcb_free_pixmap(xcb_connection_t * c,xcb_pixmap_t pixmap)6575 xcb_free_pixmap (xcb_connection_t *c,
6576                  xcb_pixmap_t      pixmap)
6577 {
6578     static const xcb_protocol_request_t xcb_req = {
6579         .count = 2,
6580         .ext = 0,
6581         .opcode = XCB_FREE_PIXMAP,
6582         .isvoid = 1
6583     };
6584 
6585     struct iovec xcb_parts[4];
6586     xcb_void_cookie_t xcb_ret;
6587     xcb_free_pixmap_request_t xcb_out;
6588 
6589     xcb_out.pad0 = 0;
6590     xcb_out.pixmap = pixmap;
6591 
6592     xcb_parts[2].iov_base = (char *) &xcb_out;
6593     xcb_parts[2].iov_len = sizeof(xcb_out);
6594     xcb_parts[3].iov_base = 0;
6595     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6596 
6597     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6598     return xcb_ret;
6599 }
6600 
6601 int
xcb_create_gc_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_create_gc_value_list_t * _aux)6602 xcb_create_gc_value_list_serialize (void                             **_buffer,
6603                                     uint32_t                           value_mask,
6604                                     const xcb_create_gc_value_list_t  *_aux)
6605 {
6606     char *xcb_out = *_buffer;
6607     unsigned int xcb_buffer_len = 0;
6608     unsigned int xcb_align_to = 0;
6609     unsigned int xcb_padding_offset = 0;
6610 
6611     unsigned int xcb_pad = 0;
6612     char xcb_pad0[3] = {0, 0, 0};
6613     struct iovec xcb_parts[24];
6614     unsigned int xcb_parts_idx = 0;
6615     unsigned int xcb_block_len = 0;
6616     unsigned int i;
6617     char *xcb_tmp;
6618 
6619     if(value_mask & XCB_GC_FUNCTION) {
6620         /* xcb_create_gc_value_list_t.function */
6621         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function;
6622         xcb_block_len += sizeof(uint32_t);
6623         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6624         xcb_parts_idx++;
6625         xcb_align_to = ALIGNOF(uint32_t);
6626     }
6627     if(value_mask & XCB_GC_PLANE_MASK) {
6628         /* xcb_create_gc_value_list_t.plane_mask */
6629         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask;
6630         xcb_block_len += sizeof(uint32_t);
6631         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6632         xcb_parts_idx++;
6633         xcb_align_to = ALIGNOF(uint32_t);
6634     }
6635     if(value_mask & XCB_GC_FOREGROUND) {
6636         /* xcb_create_gc_value_list_t.foreground */
6637         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground;
6638         xcb_block_len += sizeof(uint32_t);
6639         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6640         xcb_parts_idx++;
6641         xcb_align_to = ALIGNOF(uint32_t);
6642     }
6643     if(value_mask & XCB_GC_BACKGROUND) {
6644         /* xcb_create_gc_value_list_t.background */
6645         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background;
6646         xcb_block_len += sizeof(uint32_t);
6647         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6648         xcb_parts_idx++;
6649         xcb_align_to = ALIGNOF(uint32_t);
6650     }
6651     if(value_mask & XCB_GC_LINE_WIDTH) {
6652         /* xcb_create_gc_value_list_t.line_width */
6653         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width;
6654         xcb_block_len += sizeof(uint32_t);
6655         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6656         xcb_parts_idx++;
6657         xcb_align_to = ALIGNOF(uint32_t);
6658     }
6659     if(value_mask & XCB_GC_LINE_STYLE) {
6660         /* xcb_create_gc_value_list_t.line_style */
6661         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style;
6662         xcb_block_len += sizeof(uint32_t);
6663         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6664         xcb_parts_idx++;
6665         xcb_align_to = ALIGNOF(uint32_t);
6666     }
6667     if(value_mask & XCB_GC_CAP_STYLE) {
6668         /* xcb_create_gc_value_list_t.cap_style */
6669         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style;
6670         xcb_block_len += sizeof(uint32_t);
6671         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6672         xcb_parts_idx++;
6673         xcb_align_to = ALIGNOF(uint32_t);
6674     }
6675     if(value_mask & XCB_GC_JOIN_STYLE) {
6676         /* xcb_create_gc_value_list_t.join_style */
6677         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style;
6678         xcb_block_len += sizeof(uint32_t);
6679         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6680         xcb_parts_idx++;
6681         xcb_align_to = ALIGNOF(uint32_t);
6682     }
6683     if(value_mask & XCB_GC_FILL_STYLE) {
6684         /* xcb_create_gc_value_list_t.fill_style */
6685         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style;
6686         xcb_block_len += sizeof(uint32_t);
6687         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6688         xcb_parts_idx++;
6689         xcb_align_to = ALIGNOF(uint32_t);
6690     }
6691     if(value_mask & XCB_GC_FILL_RULE) {
6692         /* xcb_create_gc_value_list_t.fill_rule */
6693         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule;
6694         xcb_block_len += sizeof(uint32_t);
6695         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6696         xcb_parts_idx++;
6697         xcb_align_to = ALIGNOF(uint32_t);
6698     }
6699     if(value_mask & XCB_GC_TILE) {
6700         /* xcb_create_gc_value_list_t.tile */
6701         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile;
6702         xcb_block_len += sizeof(xcb_pixmap_t);
6703         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
6704         xcb_parts_idx++;
6705         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6706     }
6707     if(value_mask & XCB_GC_STIPPLE) {
6708         /* xcb_create_gc_value_list_t.stipple */
6709         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple;
6710         xcb_block_len += sizeof(xcb_pixmap_t);
6711         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
6712         xcb_parts_idx++;
6713         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6714     }
6715     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
6716         /* xcb_create_gc_value_list_t.tile_stipple_x_origin */
6717         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin;
6718         xcb_block_len += sizeof(int32_t);
6719         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6720         xcb_parts_idx++;
6721         xcb_align_to = ALIGNOF(int32_t);
6722     }
6723     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
6724         /* xcb_create_gc_value_list_t.tile_stipple_y_origin */
6725         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin;
6726         xcb_block_len += sizeof(int32_t);
6727         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6728         xcb_parts_idx++;
6729         xcb_align_to = ALIGNOF(int32_t);
6730     }
6731     if(value_mask & XCB_GC_FONT) {
6732         /* xcb_create_gc_value_list_t.font */
6733         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font;
6734         xcb_block_len += sizeof(xcb_font_t);
6735         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t);
6736         xcb_parts_idx++;
6737         xcb_align_to = ALIGNOF(xcb_font_t);
6738     }
6739     if(value_mask & XCB_GC_SUBWINDOW_MODE) {
6740         /* xcb_create_gc_value_list_t.subwindow_mode */
6741         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode;
6742         xcb_block_len += sizeof(uint32_t);
6743         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6744         xcb_parts_idx++;
6745         xcb_align_to = ALIGNOF(uint32_t);
6746     }
6747     if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
6748         /* xcb_create_gc_value_list_t.graphics_exposures */
6749         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures;
6750         xcb_block_len += sizeof(xcb_bool32_t);
6751         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
6752         xcb_parts_idx++;
6753         xcb_align_to = ALIGNOF(xcb_bool32_t);
6754     }
6755     if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
6756         /* xcb_create_gc_value_list_t.clip_x_origin */
6757         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin;
6758         xcb_block_len += sizeof(int32_t);
6759         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6760         xcb_parts_idx++;
6761         xcb_align_to = ALIGNOF(int32_t);
6762     }
6763     if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
6764         /* xcb_create_gc_value_list_t.clip_y_origin */
6765         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin;
6766         xcb_block_len += sizeof(int32_t);
6767         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6768         xcb_parts_idx++;
6769         xcb_align_to = ALIGNOF(int32_t);
6770     }
6771     if(value_mask & XCB_GC_CLIP_MASK) {
6772         /* xcb_create_gc_value_list_t.clip_mask */
6773         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask;
6774         xcb_block_len += sizeof(xcb_pixmap_t);
6775         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
6776         xcb_parts_idx++;
6777         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6778     }
6779     if(value_mask & XCB_GC_DASH_OFFSET) {
6780         /* xcb_create_gc_value_list_t.dash_offset */
6781         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset;
6782         xcb_block_len += sizeof(uint32_t);
6783         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6784         xcb_parts_idx++;
6785         xcb_align_to = ALIGNOF(uint32_t);
6786     }
6787     if(value_mask & XCB_GC_DASH_LIST) {
6788         /* xcb_create_gc_value_list_t.dashes */
6789         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes;
6790         xcb_block_len += sizeof(uint32_t);
6791         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6792         xcb_parts_idx++;
6793         xcb_align_to = ALIGNOF(uint32_t);
6794     }
6795     if(value_mask & XCB_GC_ARC_MODE) {
6796         /* xcb_create_gc_value_list_t.arc_mode */
6797         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode;
6798         xcb_block_len += sizeof(uint32_t);
6799         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6800         xcb_parts_idx++;
6801         xcb_align_to = ALIGNOF(uint32_t);
6802     }
6803     /* insert padding */
6804     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6805     xcb_buffer_len += xcb_block_len + xcb_pad;
6806     if (0 != xcb_pad) {
6807         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6808         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6809         xcb_parts_idx++;
6810         xcb_pad = 0;
6811     }
6812     xcb_block_len = 0;
6813     xcb_padding_offset = 0;
6814 
6815     if (NULL == xcb_out) {
6816         /* allocate memory */
6817         xcb_out = malloc(xcb_buffer_len);
6818         *_buffer = xcb_out;
6819     }
6820 
6821     xcb_tmp = xcb_out;
6822     for(i=0; i<xcb_parts_idx; i++) {
6823         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
6824             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
6825         if (0 != xcb_parts[i].iov_len)
6826             xcb_tmp += xcb_parts[i].iov_len;
6827     }
6828 
6829     return xcb_buffer_len;
6830 }
6831 
6832 int
xcb_create_gc_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_create_gc_value_list_t * _aux)6833 xcb_create_gc_value_list_unpack (const void                  *_buffer,
6834                                  uint32_t                     value_mask,
6835                                  xcb_create_gc_value_list_t  *_aux)
6836 {
6837     char *xcb_tmp = (char *)_buffer;
6838     unsigned int xcb_buffer_len = 0;
6839     unsigned int xcb_block_len = 0;
6840     unsigned int xcb_pad = 0;
6841     unsigned int xcb_align_to = 0;
6842     unsigned int xcb_padding_offset = 0;
6843 
6844 
6845     if(value_mask & XCB_GC_FUNCTION) {
6846         /* xcb_create_gc_value_list_t.function */
6847         _aux->function = *(uint32_t *)xcb_tmp;
6848         xcb_block_len += sizeof(uint32_t);
6849         xcb_tmp += sizeof(uint32_t);
6850         xcb_align_to = ALIGNOF(uint32_t);
6851     }
6852     if(value_mask & XCB_GC_PLANE_MASK) {
6853         /* xcb_create_gc_value_list_t.plane_mask */
6854         _aux->plane_mask = *(uint32_t *)xcb_tmp;
6855         xcb_block_len += sizeof(uint32_t);
6856         xcb_tmp += sizeof(uint32_t);
6857         xcb_align_to = ALIGNOF(uint32_t);
6858     }
6859     if(value_mask & XCB_GC_FOREGROUND) {
6860         /* xcb_create_gc_value_list_t.foreground */
6861         _aux->foreground = *(uint32_t *)xcb_tmp;
6862         xcb_block_len += sizeof(uint32_t);
6863         xcb_tmp += sizeof(uint32_t);
6864         xcb_align_to = ALIGNOF(uint32_t);
6865     }
6866     if(value_mask & XCB_GC_BACKGROUND) {
6867         /* xcb_create_gc_value_list_t.background */
6868         _aux->background = *(uint32_t *)xcb_tmp;
6869         xcb_block_len += sizeof(uint32_t);
6870         xcb_tmp += sizeof(uint32_t);
6871         xcb_align_to = ALIGNOF(uint32_t);
6872     }
6873     if(value_mask & XCB_GC_LINE_WIDTH) {
6874         /* xcb_create_gc_value_list_t.line_width */
6875         _aux->line_width = *(uint32_t *)xcb_tmp;
6876         xcb_block_len += sizeof(uint32_t);
6877         xcb_tmp += sizeof(uint32_t);
6878         xcb_align_to = ALIGNOF(uint32_t);
6879     }
6880     if(value_mask & XCB_GC_LINE_STYLE) {
6881         /* xcb_create_gc_value_list_t.line_style */
6882         _aux->line_style = *(uint32_t *)xcb_tmp;
6883         xcb_block_len += sizeof(uint32_t);
6884         xcb_tmp += sizeof(uint32_t);
6885         xcb_align_to = ALIGNOF(uint32_t);
6886     }
6887     if(value_mask & XCB_GC_CAP_STYLE) {
6888         /* xcb_create_gc_value_list_t.cap_style */
6889         _aux->cap_style = *(uint32_t *)xcb_tmp;
6890         xcb_block_len += sizeof(uint32_t);
6891         xcb_tmp += sizeof(uint32_t);
6892         xcb_align_to = ALIGNOF(uint32_t);
6893     }
6894     if(value_mask & XCB_GC_JOIN_STYLE) {
6895         /* xcb_create_gc_value_list_t.join_style */
6896         _aux->join_style = *(uint32_t *)xcb_tmp;
6897         xcb_block_len += sizeof(uint32_t);
6898         xcb_tmp += sizeof(uint32_t);
6899         xcb_align_to = ALIGNOF(uint32_t);
6900     }
6901     if(value_mask & XCB_GC_FILL_STYLE) {
6902         /* xcb_create_gc_value_list_t.fill_style */
6903         _aux->fill_style = *(uint32_t *)xcb_tmp;
6904         xcb_block_len += sizeof(uint32_t);
6905         xcb_tmp += sizeof(uint32_t);
6906         xcb_align_to = ALIGNOF(uint32_t);
6907     }
6908     if(value_mask & XCB_GC_FILL_RULE) {
6909         /* xcb_create_gc_value_list_t.fill_rule */
6910         _aux->fill_rule = *(uint32_t *)xcb_tmp;
6911         xcb_block_len += sizeof(uint32_t);
6912         xcb_tmp += sizeof(uint32_t);
6913         xcb_align_to = ALIGNOF(uint32_t);
6914     }
6915     if(value_mask & XCB_GC_TILE) {
6916         /* xcb_create_gc_value_list_t.tile */
6917         _aux->tile = *(xcb_pixmap_t *)xcb_tmp;
6918         xcb_block_len += sizeof(xcb_pixmap_t);
6919         xcb_tmp += sizeof(xcb_pixmap_t);
6920         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6921     }
6922     if(value_mask & XCB_GC_STIPPLE) {
6923         /* xcb_create_gc_value_list_t.stipple */
6924         _aux->stipple = *(xcb_pixmap_t *)xcb_tmp;
6925         xcb_block_len += sizeof(xcb_pixmap_t);
6926         xcb_tmp += sizeof(xcb_pixmap_t);
6927         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6928     }
6929     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
6930         /* xcb_create_gc_value_list_t.tile_stipple_x_origin */
6931         _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp;
6932         xcb_block_len += sizeof(int32_t);
6933         xcb_tmp += sizeof(int32_t);
6934         xcb_align_to = ALIGNOF(int32_t);
6935     }
6936     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
6937         /* xcb_create_gc_value_list_t.tile_stipple_y_origin */
6938         _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp;
6939         xcb_block_len += sizeof(int32_t);
6940         xcb_tmp += sizeof(int32_t);
6941         xcb_align_to = ALIGNOF(int32_t);
6942     }
6943     if(value_mask & XCB_GC_FONT) {
6944         /* xcb_create_gc_value_list_t.font */
6945         _aux->font = *(xcb_font_t *)xcb_tmp;
6946         xcb_block_len += sizeof(xcb_font_t);
6947         xcb_tmp += sizeof(xcb_font_t);
6948         xcb_align_to = ALIGNOF(xcb_font_t);
6949     }
6950     if(value_mask & XCB_GC_SUBWINDOW_MODE) {
6951         /* xcb_create_gc_value_list_t.subwindow_mode */
6952         _aux->subwindow_mode = *(uint32_t *)xcb_tmp;
6953         xcb_block_len += sizeof(uint32_t);
6954         xcb_tmp += sizeof(uint32_t);
6955         xcb_align_to = ALIGNOF(uint32_t);
6956     }
6957     if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
6958         /* xcb_create_gc_value_list_t.graphics_exposures */
6959         _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp;
6960         xcb_block_len += sizeof(xcb_bool32_t);
6961         xcb_tmp += sizeof(xcb_bool32_t);
6962         xcb_align_to = ALIGNOF(xcb_bool32_t);
6963     }
6964     if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
6965         /* xcb_create_gc_value_list_t.clip_x_origin */
6966         _aux->clip_x_origin = *(int32_t *)xcb_tmp;
6967         xcb_block_len += sizeof(int32_t);
6968         xcb_tmp += sizeof(int32_t);
6969         xcb_align_to = ALIGNOF(int32_t);
6970     }
6971     if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
6972         /* xcb_create_gc_value_list_t.clip_y_origin */
6973         _aux->clip_y_origin = *(int32_t *)xcb_tmp;
6974         xcb_block_len += sizeof(int32_t);
6975         xcb_tmp += sizeof(int32_t);
6976         xcb_align_to = ALIGNOF(int32_t);
6977     }
6978     if(value_mask & XCB_GC_CLIP_MASK) {
6979         /* xcb_create_gc_value_list_t.clip_mask */
6980         _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp;
6981         xcb_block_len += sizeof(xcb_pixmap_t);
6982         xcb_tmp += sizeof(xcb_pixmap_t);
6983         xcb_align_to = ALIGNOF(xcb_pixmap_t);
6984     }
6985     if(value_mask & XCB_GC_DASH_OFFSET) {
6986         /* xcb_create_gc_value_list_t.dash_offset */
6987         _aux->dash_offset = *(uint32_t *)xcb_tmp;
6988         xcb_block_len += sizeof(uint32_t);
6989         xcb_tmp += sizeof(uint32_t);
6990         xcb_align_to = ALIGNOF(uint32_t);
6991     }
6992     if(value_mask & XCB_GC_DASH_LIST) {
6993         /* xcb_create_gc_value_list_t.dashes */
6994         _aux->dashes = *(uint32_t *)xcb_tmp;
6995         xcb_block_len += sizeof(uint32_t);
6996         xcb_tmp += sizeof(uint32_t);
6997         xcb_align_to = ALIGNOF(uint32_t);
6998     }
6999     if(value_mask & XCB_GC_ARC_MODE) {
7000         /* xcb_create_gc_value_list_t.arc_mode */
7001         _aux->arc_mode = *(uint32_t *)xcb_tmp;
7002         xcb_block_len += sizeof(uint32_t);
7003         xcb_tmp += sizeof(uint32_t);
7004         xcb_align_to = ALIGNOF(uint32_t);
7005     }
7006     /* insert padding */
7007     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7008     xcb_buffer_len += xcb_block_len + xcb_pad;
7009     if (0 != xcb_pad) {
7010         xcb_tmp += xcb_pad;
7011         xcb_pad = 0;
7012     }
7013     xcb_block_len = 0;
7014     xcb_padding_offset = 0;
7015 
7016     return xcb_buffer_len;
7017 }
7018 
7019 int
xcb_create_gc_value_list_sizeof(const void * _buffer,uint32_t value_mask)7020 xcb_create_gc_value_list_sizeof (const void  *_buffer,
7021                                  uint32_t     value_mask)
7022 {
7023     xcb_create_gc_value_list_t _aux;
7024     return xcb_create_gc_value_list_unpack(_buffer, value_mask, &_aux);
7025 }
7026 
7027 int
xcb_create_gc_sizeof(const void * _buffer)7028 xcb_create_gc_sizeof (const void  *_buffer)
7029 {
7030     char *xcb_tmp = (char *)_buffer;
7031     const xcb_create_gc_request_t *_aux = (xcb_create_gc_request_t *)_buffer;
7032     unsigned int xcb_buffer_len = 0;
7033     unsigned int xcb_block_len = 0;
7034     unsigned int xcb_pad = 0;
7035     unsigned int xcb_align_to = 0;
7036 
7037 
7038     xcb_block_len += sizeof(xcb_create_gc_request_t);
7039     xcb_tmp += xcb_block_len;
7040     xcb_buffer_len += xcb_block_len;
7041     xcb_block_len = 0;
7042     /* value_list */
7043     xcb_block_len += xcb_create_gc_value_list_sizeof(xcb_tmp, _aux->value_mask);
7044     xcb_tmp += xcb_block_len;
7045     xcb_align_to = ALIGNOF(char);
7046     /* insert padding */
7047     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7048     xcb_buffer_len += xcb_block_len + xcb_pad;
7049     if (0 != xcb_pad) {
7050         xcb_tmp += xcb_pad;
7051         xcb_pad = 0;
7052     }
7053     xcb_block_len = 0;
7054 
7055     return xcb_buffer_len;
7056 }
7057 
7058 xcb_void_cookie_t
xcb_create_gc_checked(xcb_connection_t * c,xcb_gcontext_t cid,xcb_drawable_t drawable,uint32_t value_mask,const void * value_list)7059 xcb_create_gc_checked (xcb_connection_t *c,
7060                        xcb_gcontext_t    cid,
7061                        xcb_drawable_t    drawable,
7062                        uint32_t          value_mask,
7063                        const void       *value_list)
7064 {
7065     static const xcb_protocol_request_t xcb_req = {
7066         .count = 3,
7067         .ext = 0,
7068         .opcode = XCB_CREATE_GC,
7069         .isvoid = 1
7070     };
7071 
7072     struct iovec xcb_parts[5];
7073     xcb_void_cookie_t xcb_ret;
7074     xcb_create_gc_request_t xcb_out;
7075 
7076     xcb_out.pad0 = 0;
7077     xcb_out.cid = cid;
7078     xcb_out.drawable = drawable;
7079     xcb_out.value_mask = value_mask;
7080 
7081     xcb_parts[2].iov_base = (char *) &xcb_out;
7082     xcb_parts[2].iov_len = sizeof(xcb_out);
7083     xcb_parts[3].iov_base = 0;
7084     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7085     /* xcb_create_gc_value_list_t value_list */
7086     xcb_parts[4].iov_base = (char *) value_list;
7087     xcb_parts[4].iov_len =
7088       xcb_create_gc_value_list_sizeof (value_list, value_mask);
7089 
7090     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7091     return xcb_ret;
7092 }
7093 
7094 xcb_void_cookie_t
xcb_create_gc(xcb_connection_t * c,xcb_gcontext_t cid,xcb_drawable_t drawable,uint32_t value_mask,const void * value_list)7095 xcb_create_gc (xcb_connection_t *c,
7096                xcb_gcontext_t    cid,
7097                xcb_drawable_t    drawable,
7098                uint32_t          value_mask,
7099                const void       *value_list)
7100 {
7101     static const xcb_protocol_request_t xcb_req = {
7102         .count = 3,
7103         .ext = 0,
7104         .opcode = XCB_CREATE_GC,
7105         .isvoid = 1
7106     };
7107 
7108     struct iovec xcb_parts[5];
7109     xcb_void_cookie_t xcb_ret;
7110     xcb_create_gc_request_t xcb_out;
7111 
7112     xcb_out.pad0 = 0;
7113     xcb_out.cid = cid;
7114     xcb_out.drawable = drawable;
7115     xcb_out.value_mask = value_mask;
7116 
7117     xcb_parts[2].iov_base = (char *) &xcb_out;
7118     xcb_parts[2].iov_len = sizeof(xcb_out);
7119     xcb_parts[3].iov_base = 0;
7120     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7121     /* xcb_create_gc_value_list_t value_list */
7122     xcb_parts[4].iov_base = (char *) value_list;
7123     xcb_parts[4].iov_len =
7124       xcb_create_gc_value_list_sizeof (value_list, value_mask);
7125 
7126     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7127     return xcb_ret;
7128 }
7129 
7130 xcb_void_cookie_t
xcb_create_gc_aux_checked(xcb_connection_t * c,xcb_gcontext_t cid,xcb_drawable_t drawable,uint32_t value_mask,const xcb_create_gc_value_list_t * value_list)7131 xcb_create_gc_aux_checked (xcb_connection_t                 *c,
7132                            xcb_gcontext_t                    cid,
7133                            xcb_drawable_t                    drawable,
7134                            uint32_t                          value_mask,
7135                            const xcb_create_gc_value_list_t *value_list)
7136 {
7137     static const xcb_protocol_request_t xcb_req = {
7138         .count = 3,
7139         .ext = 0,
7140         .opcode = XCB_CREATE_GC,
7141         .isvoid = 1
7142     };
7143 
7144     struct iovec xcb_parts[5];
7145     xcb_void_cookie_t xcb_ret;
7146     xcb_create_gc_request_t xcb_out;
7147     void *xcb_aux0 = 0;
7148 
7149     xcb_out.pad0 = 0;
7150     xcb_out.cid = cid;
7151     xcb_out.drawable = drawable;
7152     xcb_out.value_mask = value_mask;
7153 
7154     xcb_parts[2].iov_base = (char *) &xcb_out;
7155     xcb_parts[2].iov_len = sizeof(xcb_out);
7156     xcb_parts[3].iov_base = 0;
7157     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7158     /* xcb_create_gc_value_list_t value_list */
7159     xcb_parts[4].iov_len =
7160       xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
7161     xcb_parts[4].iov_base = xcb_aux0;
7162 
7163     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7164     free(xcb_aux0);
7165     return xcb_ret;
7166 }
7167 
7168 xcb_void_cookie_t
xcb_create_gc_aux(xcb_connection_t * c,xcb_gcontext_t cid,xcb_drawable_t drawable,uint32_t value_mask,const xcb_create_gc_value_list_t * value_list)7169 xcb_create_gc_aux (xcb_connection_t                 *c,
7170                    xcb_gcontext_t                    cid,
7171                    xcb_drawable_t                    drawable,
7172                    uint32_t                          value_mask,
7173                    const xcb_create_gc_value_list_t *value_list)
7174 {
7175     static const xcb_protocol_request_t xcb_req = {
7176         .count = 3,
7177         .ext = 0,
7178         .opcode = XCB_CREATE_GC,
7179         .isvoid = 1
7180     };
7181 
7182     struct iovec xcb_parts[5];
7183     xcb_void_cookie_t xcb_ret;
7184     xcb_create_gc_request_t xcb_out;
7185     void *xcb_aux0 = 0;
7186 
7187     xcb_out.pad0 = 0;
7188     xcb_out.cid = cid;
7189     xcb_out.drawable = drawable;
7190     xcb_out.value_mask = value_mask;
7191 
7192     xcb_parts[2].iov_base = (char *) &xcb_out;
7193     xcb_parts[2].iov_len = sizeof(xcb_out);
7194     xcb_parts[3].iov_base = 0;
7195     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7196     /* xcb_create_gc_value_list_t value_list */
7197     xcb_parts[4].iov_len =
7198       xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
7199     xcb_parts[4].iov_base = xcb_aux0;
7200 
7201     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7202     free(xcb_aux0);
7203     return xcb_ret;
7204 }
7205 
7206 void *
xcb_create_gc_value_list(const xcb_create_gc_request_t * R)7207 xcb_create_gc_value_list (const xcb_create_gc_request_t *R)
7208 {
7209     return (void *) (R + 1);
7210 }
7211 
7212 int
xcb_change_gc_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_change_gc_value_list_t * _aux)7213 xcb_change_gc_value_list_serialize (void                             **_buffer,
7214                                     uint32_t                           value_mask,
7215                                     const xcb_change_gc_value_list_t  *_aux)
7216 {
7217     char *xcb_out = *_buffer;
7218     unsigned int xcb_buffer_len = 0;
7219     unsigned int xcb_align_to = 0;
7220     unsigned int xcb_padding_offset = 0;
7221 
7222     unsigned int xcb_pad = 0;
7223     char xcb_pad0[3] = {0, 0, 0};
7224     struct iovec xcb_parts[24];
7225     unsigned int xcb_parts_idx = 0;
7226     unsigned int xcb_block_len = 0;
7227     unsigned int i;
7228     char *xcb_tmp;
7229 
7230     if(value_mask & XCB_GC_FUNCTION) {
7231         /* xcb_change_gc_value_list_t.function */
7232         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function;
7233         xcb_block_len += sizeof(uint32_t);
7234         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7235         xcb_parts_idx++;
7236         xcb_align_to = ALIGNOF(uint32_t);
7237     }
7238     if(value_mask & XCB_GC_PLANE_MASK) {
7239         /* xcb_change_gc_value_list_t.plane_mask */
7240         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask;
7241         xcb_block_len += sizeof(uint32_t);
7242         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7243         xcb_parts_idx++;
7244         xcb_align_to = ALIGNOF(uint32_t);
7245     }
7246     if(value_mask & XCB_GC_FOREGROUND) {
7247         /* xcb_change_gc_value_list_t.foreground */
7248         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground;
7249         xcb_block_len += sizeof(uint32_t);
7250         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7251         xcb_parts_idx++;
7252         xcb_align_to = ALIGNOF(uint32_t);
7253     }
7254     if(value_mask & XCB_GC_BACKGROUND) {
7255         /* xcb_change_gc_value_list_t.background */
7256         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background;
7257         xcb_block_len += sizeof(uint32_t);
7258         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7259         xcb_parts_idx++;
7260         xcb_align_to = ALIGNOF(uint32_t);
7261     }
7262     if(value_mask & XCB_GC_LINE_WIDTH) {
7263         /* xcb_change_gc_value_list_t.line_width */
7264         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width;
7265         xcb_block_len += sizeof(uint32_t);
7266         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7267         xcb_parts_idx++;
7268         xcb_align_to = ALIGNOF(uint32_t);
7269     }
7270     if(value_mask & XCB_GC_LINE_STYLE) {
7271         /* xcb_change_gc_value_list_t.line_style */
7272         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style;
7273         xcb_block_len += sizeof(uint32_t);
7274         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7275         xcb_parts_idx++;
7276         xcb_align_to = ALIGNOF(uint32_t);
7277     }
7278     if(value_mask & XCB_GC_CAP_STYLE) {
7279         /* xcb_change_gc_value_list_t.cap_style */
7280         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style;
7281         xcb_block_len += sizeof(uint32_t);
7282         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7283         xcb_parts_idx++;
7284         xcb_align_to = ALIGNOF(uint32_t);
7285     }
7286     if(value_mask & XCB_GC_JOIN_STYLE) {
7287         /* xcb_change_gc_value_list_t.join_style */
7288         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style;
7289         xcb_block_len += sizeof(uint32_t);
7290         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7291         xcb_parts_idx++;
7292         xcb_align_to = ALIGNOF(uint32_t);
7293     }
7294     if(value_mask & XCB_GC_FILL_STYLE) {
7295         /* xcb_change_gc_value_list_t.fill_style */
7296         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style;
7297         xcb_block_len += sizeof(uint32_t);
7298         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7299         xcb_parts_idx++;
7300         xcb_align_to = ALIGNOF(uint32_t);
7301     }
7302     if(value_mask & XCB_GC_FILL_RULE) {
7303         /* xcb_change_gc_value_list_t.fill_rule */
7304         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule;
7305         xcb_block_len += sizeof(uint32_t);
7306         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7307         xcb_parts_idx++;
7308         xcb_align_to = ALIGNOF(uint32_t);
7309     }
7310     if(value_mask & XCB_GC_TILE) {
7311         /* xcb_change_gc_value_list_t.tile */
7312         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile;
7313         xcb_block_len += sizeof(xcb_pixmap_t);
7314         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
7315         xcb_parts_idx++;
7316         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7317     }
7318     if(value_mask & XCB_GC_STIPPLE) {
7319         /* xcb_change_gc_value_list_t.stipple */
7320         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple;
7321         xcb_block_len += sizeof(xcb_pixmap_t);
7322         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
7323         xcb_parts_idx++;
7324         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7325     }
7326     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
7327         /* xcb_change_gc_value_list_t.tile_stipple_x_origin */
7328         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin;
7329         xcb_block_len += sizeof(int32_t);
7330         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7331         xcb_parts_idx++;
7332         xcb_align_to = ALIGNOF(int32_t);
7333     }
7334     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
7335         /* xcb_change_gc_value_list_t.tile_stipple_y_origin */
7336         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin;
7337         xcb_block_len += sizeof(int32_t);
7338         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7339         xcb_parts_idx++;
7340         xcb_align_to = ALIGNOF(int32_t);
7341     }
7342     if(value_mask & XCB_GC_FONT) {
7343         /* xcb_change_gc_value_list_t.font */
7344         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font;
7345         xcb_block_len += sizeof(xcb_font_t);
7346         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t);
7347         xcb_parts_idx++;
7348         xcb_align_to = ALIGNOF(xcb_font_t);
7349     }
7350     if(value_mask & XCB_GC_SUBWINDOW_MODE) {
7351         /* xcb_change_gc_value_list_t.subwindow_mode */
7352         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode;
7353         xcb_block_len += sizeof(uint32_t);
7354         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7355         xcb_parts_idx++;
7356         xcb_align_to = ALIGNOF(uint32_t);
7357     }
7358     if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
7359         /* xcb_change_gc_value_list_t.graphics_exposures */
7360         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures;
7361         xcb_block_len += sizeof(xcb_bool32_t);
7362         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
7363         xcb_parts_idx++;
7364         xcb_align_to = ALIGNOF(xcb_bool32_t);
7365     }
7366     if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
7367         /* xcb_change_gc_value_list_t.clip_x_origin */
7368         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin;
7369         xcb_block_len += sizeof(int32_t);
7370         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7371         xcb_parts_idx++;
7372         xcb_align_to = ALIGNOF(int32_t);
7373     }
7374     if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
7375         /* xcb_change_gc_value_list_t.clip_y_origin */
7376         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin;
7377         xcb_block_len += sizeof(int32_t);
7378         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7379         xcb_parts_idx++;
7380         xcb_align_to = ALIGNOF(int32_t);
7381     }
7382     if(value_mask & XCB_GC_CLIP_MASK) {
7383         /* xcb_change_gc_value_list_t.clip_mask */
7384         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask;
7385         xcb_block_len += sizeof(xcb_pixmap_t);
7386         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
7387         xcb_parts_idx++;
7388         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7389     }
7390     if(value_mask & XCB_GC_DASH_OFFSET) {
7391         /* xcb_change_gc_value_list_t.dash_offset */
7392         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset;
7393         xcb_block_len += sizeof(uint32_t);
7394         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7395         xcb_parts_idx++;
7396         xcb_align_to = ALIGNOF(uint32_t);
7397     }
7398     if(value_mask & XCB_GC_DASH_LIST) {
7399         /* xcb_change_gc_value_list_t.dashes */
7400         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes;
7401         xcb_block_len += sizeof(uint32_t);
7402         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7403         xcb_parts_idx++;
7404         xcb_align_to = ALIGNOF(uint32_t);
7405     }
7406     if(value_mask & XCB_GC_ARC_MODE) {
7407         /* xcb_change_gc_value_list_t.arc_mode */
7408         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode;
7409         xcb_block_len += sizeof(uint32_t);
7410         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7411         xcb_parts_idx++;
7412         xcb_align_to = ALIGNOF(uint32_t);
7413     }
7414     /* insert padding */
7415     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7416     xcb_buffer_len += xcb_block_len + xcb_pad;
7417     if (0 != xcb_pad) {
7418         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7419         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7420         xcb_parts_idx++;
7421         xcb_pad = 0;
7422     }
7423     xcb_block_len = 0;
7424     xcb_padding_offset = 0;
7425 
7426     if (NULL == xcb_out) {
7427         /* allocate memory */
7428         xcb_out = malloc(xcb_buffer_len);
7429         *_buffer = xcb_out;
7430     }
7431 
7432     xcb_tmp = xcb_out;
7433     for(i=0; i<xcb_parts_idx; i++) {
7434         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
7435             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
7436         if (0 != xcb_parts[i].iov_len)
7437             xcb_tmp += xcb_parts[i].iov_len;
7438     }
7439 
7440     return xcb_buffer_len;
7441 }
7442 
7443 int
xcb_change_gc_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_change_gc_value_list_t * _aux)7444 xcb_change_gc_value_list_unpack (const void                  *_buffer,
7445                                  uint32_t                     value_mask,
7446                                  xcb_change_gc_value_list_t  *_aux)
7447 {
7448     char *xcb_tmp = (char *)_buffer;
7449     unsigned int xcb_buffer_len = 0;
7450     unsigned int xcb_block_len = 0;
7451     unsigned int xcb_pad = 0;
7452     unsigned int xcb_align_to = 0;
7453     unsigned int xcb_padding_offset = 0;
7454 
7455 
7456     if(value_mask & XCB_GC_FUNCTION) {
7457         /* xcb_change_gc_value_list_t.function */
7458         _aux->function = *(uint32_t *)xcb_tmp;
7459         xcb_block_len += sizeof(uint32_t);
7460         xcb_tmp += sizeof(uint32_t);
7461         xcb_align_to = ALIGNOF(uint32_t);
7462     }
7463     if(value_mask & XCB_GC_PLANE_MASK) {
7464         /* xcb_change_gc_value_list_t.plane_mask */
7465         _aux->plane_mask = *(uint32_t *)xcb_tmp;
7466         xcb_block_len += sizeof(uint32_t);
7467         xcb_tmp += sizeof(uint32_t);
7468         xcb_align_to = ALIGNOF(uint32_t);
7469     }
7470     if(value_mask & XCB_GC_FOREGROUND) {
7471         /* xcb_change_gc_value_list_t.foreground */
7472         _aux->foreground = *(uint32_t *)xcb_tmp;
7473         xcb_block_len += sizeof(uint32_t);
7474         xcb_tmp += sizeof(uint32_t);
7475         xcb_align_to = ALIGNOF(uint32_t);
7476     }
7477     if(value_mask & XCB_GC_BACKGROUND) {
7478         /* xcb_change_gc_value_list_t.background */
7479         _aux->background = *(uint32_t *)xcb_tmp;
7480         xcb_block_len += sizeof(uint32_t);
7481         xcb_tmp += sizeof(uint32_t);
7482         xcb_align_to = ALIGNOF(uint32_t);
7483     }
7484     if(value_mask & XCB_GC_LINE_WIDTH) {
7485         /* xcb_change_gc_value_list_t.line_width */
7486         _aux->line_width = *(uint32_t *)xcb_tmp;
7487         xcb_block_len += sizeof(uint32_t);
7488         xcb_tmp += sizeof(uint32_t);
7489         xcb_align_to = ALIGNOF(uint32_t);
7490     }
7491     if(value_mask & XCB_GC_LINE_STYLE) {
7492         /* xcb_change_gc_value_list_t.line_style */
7493         _aux->line_style = *(uint32_t *)xcb_tmp;
7494         xcb_block_len += sizeof(uint32_t);
7495         xcb_tmp += sizeof(uint32_t);
7496         xcb_align_to = ALIGNOF(uint32_t);
7497     }
7498     if(value_mask & XCB_GC_CAP_STYLE) {
7499         /* xcb_change_gc_value_list_t.cap_style */
7500         _aux->cap_style = *(uint32_t *)xcb_tmp;
7501         xcb_block_len += sizeof(uint32_t);
7502         xcb_tmp += sizeof(uint32_t);
7503         xcb_align_to = ALIGNOF(uint32_t);
7504     }
7505     if(value_mask & XCB_GC_JOIN_STYLE) {
7506         /* xcb_change_gc_value_list_t.join_style */
7507         _aux->join_style = *(uint32_t *)xcb_tmp;
7508         xcb_block_len += sizeof(uint32_t);
7509         xcb_tmp += sizeof(uint32_t);
7510         xcb_align_to = ALIGNOF(uint32_t);
7511     }
7512     if(value_mask & XCB_GC_FILL_STYLE) {
7513         /* xcb_change_gc_value_list_t.fill_style */
7514         _aux->fill_style = *(uint32_t *)xcb_tmp;
7515         xcb_block_len += sizeof(uint32_t);
7516         xcb_tmp += sizeof(uint32_t);
7517         xcb_align_to = ALIGNOF(uint32_t);
7518     }
7519     if(value_mask & XCB_GC_FILL_RULE) {
7520         /* xcb_change_gc_value_list_t.fill_rule */
7521         _aux->fill_rule = *(uint32_t *)xcb_tmp;
7522         xcb_block_len += sizeof(uint32_t);
7523         xcb_tmp += sizeof(uint32_t);
7524         xcb_align_to = ALIGNOF(uint32_t);
7525     }
7526     if(value_mask & XCB_GC_TILE) {
7527         /* xcb_change_gc_value_list_t.tile */
7528         _aux->tile = *(xcb_pixmap_t *)xcb_tmp;
7529         xcb_block_len += sizeof(xcb_pixmap_t);
7530         xcb_tmp += sizeof(xcb_pixmap_t);
7531         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7532     }
7533     if(value_mask & XCB_GC_STIPPLE) {
7534         /* xcb_change_gc_value_list_t.stipple */
7535         _aux->stipple = *(xcb_pixmap_t *)xcb_tmp;
7536         xcb_block_len += sizeof(xcb_pixmap_t);
7537         xcb_tmp += sizeof(xcb_pixmap_t);
7538         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7539     }
7540     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
7541         /* xcb_change_gc_value_list_t.tile_stipple_x_origin */
7542         _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp;
7543         xcb_block_len += sizeof(int32_t);
7544         xcb_tmp += sizeof(int32_t);
7545         xcb_align_to = ALIGNOF(int32_t);
7546     }
7547     if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
7548         /* xcb_change_gc_value_list_t.tile_stipple_y_origin */
7549         _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp;
7550         xcb_block_len += sizeof(int32_t);
7551         xcb_tmp += sizeof(int32_t);
7552         xcb_align_to = ALIGNOF(int32_t);
7553     }
7554     if(value_mask & XCB_GC_FONT) {
7555         /* xcb_change_gc_value_list_t.font */
7556         _aux->font = *(xcb_font_t *)xcb_tmp;
7557         xcb_block_len += sizeof(xcb_font_t);
7558         xcb_tmp += sizeof(xcb_font_t);
7559         xcb_align_to = ALIGNOF(xcb_font_t);
7560     }
7561     if(value_mask & XCB_GC_SUBWINDOW_MODE) {
7562         /* xcb_change_gc_value_list_t.subwindow_mode */
7563         _aux->subwindow_mode = *(uint32_t *)xcb_tmp;
7564         xcb_block_len += sizeof(uint32_t);
7565         xcb_tmp += sizeof(uint32_t);
7566         xcb_align_to = ALIGNOF(uint32_t);
7567     }
7568     if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
7569         /* xcb_change_gc_value_list_t.graphics_exposures */
7570         _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp;
7571         xcb_block_len += sizeof(xcb_bool32_t);
7572         xcb_tmp += sizeof(xcb_bool32_t);
7573         xcb_align_to = ALIGNOF(xcb_bool32_t);
7574     }
7575     if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
7576         /* xcb_change_gc_value_list_t.clip_x_origin */
7577         _aux->clip_x_origin = *(int32_t *)xcb_tmp;
7578         xcb_block_len += sizeof(int32_t);
7579         xcb_tmp += sizeof(int32_t);
7580         xcb_align_to = ALIGNOF(int32_t);
7581     }
7582     if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
7583         /* xcb_change_gc_value_list_t.clip_y_origin */
7584         _aux->clip_y_origin = *(int32_t *)xcb_tmp;
7585         xcb_block_len += sizeof(int32_t);
7586         xcb_tmp += sizeof(int32_t);
7587         xcb_align_to = ALIGNOF(int32_t);
7588     }
7589     if(value_mask & XCB_GC_CLIP_MASK) {
7590         /* xcb_change_gc_value_list_t.clip_mask */
7591         _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp;
7592         xcb_block_len += sizeof(xcb_pixmap_t);
7593         xcb_tmp += sizeof(xcb_pixmap_t);
7594         xcb_align_to = ALIGNOF(xcb_pixmap_t);
7595     }
7596     if(value_mask & XCB_GC_DASH_OFFSET) {
7597         /* xcb_change_gc_value_list_t.dash_offset */
7598         _aux->dash_offset = *(uint32_t *)xcb_tmp;
7599         xcb_block_len += sizeof(uint32_t);
7600         xcb_tmp += sizeof(uint32_t);
7601         xcb_align_to = ALIGNOF(uint32_t);
7602     }
7603     if(value_mask & XCB_GC_DASH_LIST) {
7604         /* xcb_change_gc_value_list_t.dashes */
7605         _aux->dashes = *(uint32_t *)xcb_tmp;
7606         xcb_block_len += sizeof(uint32_t);
7607         xcb_tmp += sizeof(uint32_t);
7608         xcb_align_to = ALIGNOF(uint32_t);
7609     }
7610     if(value_mask & XCB_GC_ARC_MODE) {
7611         /* xcb_change_gc_value_list_t.arc_mode */
7612         _aux->arc_mode = *(uint32_t *)xcb_tmp;
7613         xcb_block_len += sizeof(uint32_t);
7614         xcb_tmp += sizeof(uint32_t);
7615         xcb_align_to = ALIGNOF(uint32_t);
7616     }
7617     /* insert padding */
7618     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7619     xcb_buffer_len += xcb_block_len + xcb_pad;
7620     if (0 != xcb_pad) {
7621         xcb_tmp += xcb_pad;
7622         xcb_pad = 0;
7623     }
7624     xcb_block_len = 0;
7625     xcb_padding_offset = 0;
7626 
7627     return xcb_buffer_len;
7628 }
7629 
7630 int
xcb_change_gc_value_list_sizeof(const void * _buffer,uint32_t value_mask)7631 xcb_change_gc_value_list_sizeof (const void  *_buffer,
7632                                  uint32_t     value_mask)
7633 {
7634     xcb_change_gc_value_list_t _aux;
7635     return xcb_change_gc_value_list_unpack(_buffer, value_mask, &_aux);
7636 }
7637 
7638 int
xcb_change_gc_sizeof(const void * _buffer)7639 xcb_change_gc_sizeof (const void  *_buffer)
7640 {
7641     char *xcb_tmp = (char *)_buffer;
7642     const xcb_change_gc_request_t *_aux = (xcb_change_gc_request_t *)_buffer;
7643     unsigned int xcb_buffer_len = 0;
7644     unsigned int xcb_block_len = 0;
7645     unsigned int xcb_pad = 0;
7646     unsigned int xcb_align_to = 0;
7647 
7648 
7649     xcb_block_len += sizeof(xcb_change_gc_request_t);
7650     xcb_tmp += xcb_block_len;
7651     xcb_buffer_len += xcb_block_len;
7652     xcb_block_len = 0;
7653     /* value_list */
7654     xcb_block_len += xcb_change_gc_value_list_sizeof(xcb_tmp, _aux->value_mask);
7655     xcb_tmp += xcb_block_len;
7656     xcb_align_to = ALIGNOF(char);
7657     /* insert padding */
7658     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7659     xcb_buffer_len += xcb_block_len + xcb_pad;
7660     if (0 != xcb_pad) {
7661         xcb_tmp += xcb_pad;
7662         xcb_pad = 0;
7663     }
7664     xcb_block_len = 0;
7665 
7666     return xcb_buffer_len;
7667 }
7668 
7669 xcb_void_cookie_t
xcb_change_gc_checked(xcb_connection_t * c,xcb_gcontext_t gc,uint32_t value_mask,const void * value_list)7670 xcb_change_gc_checked (xcb_connection_t *c,
7671                        xcb_gcontext_t    gc,
7672                        uint32_t          value_mask,
7673                        const void       *value_list)
7674 {
7675     static const xcb_protocol_request_t xcb_req = {
7676         .count = 3,
7677         .ext = 0,
7678         .opcode = XCB_CHANGE_GC,
7679         .isvoid = 1
7680     };
7681 
7682     struct iovec xcb_parts[5];
7683     xcb_void_cookie_t xcb_ret;
7684     xcb_change_gc_request_t xcb_out;
7685 
7686     xcb_out.pad0 = 0;
7687     xcb_out.gc = gc;
7688     xcb_out.value_mask = value_mask;
7689 
7690     xcb_parts[2].iov_base = (char *) &xcb_out;
7691     xcb_parts[2].iov_len = sizeof(xcb_out);
7692     xcb_parts[3].iov_base = 0;
7693     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7694     /* xcb_change_gc_value_list_t value_list */
7695     xcb_parts[4].iov_base = (char *) value_list;
7696     xcb_parts[4].iov_len =
7697       xcb_change_gc_value_list_sizeof (value_list, value_mask);
7698 
7699     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7700     return xcb_ret;
7701 }
7702 
7703 xcb_void_cookie_t
xcb_change_gc(xcb_connection_t * c,xcb_gcontext_t gc,uint32_t value_mask,const void * value_list)7704 xcb_change_gc (xcb_connection_t *c,
7705                xcb_gcontext_t    gc,
7706                uint32_t          value_mask,
7707                const void       *value_list)
7708 {
7709     static const xcb_protocol_request_t xcb_req = {
7710         .count = 3,
7711         .ext = 0,
7712         .opcode = XCB_CHANGE_GC,
7713         .isvoid = 1
7714     };
7715 
7716     struct iovec xcb_parts[5];
7717     xcb_void_cookie_t xcb_ret;
7718     xcb_change_gc_request_t xcb_out;
7719 
7720     xcb_out.pad0 = 0;
7721     xcb_out.gc = gc;
7722     xcb_out.value_mask = value_mask;
7723 
7724     xcb_parts[2].iov_base = (char *) &xcb_out;
7725     xcb_parts[2].iov_len = sizeof(xcb_out);
7726     xcb_parts[3].iov_base = 0;
7727     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7728     /* xcb_change_gc_value_list_t value_list */
7729     xcb_parts[4].iov_base = (char *) value_list;
7730     xcb_parts[4].iov_len =
7731       xcb_change_gc_value_list_sizeof (value_list, value_mask);
7732 
7733     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7734     return xcb_ret;
7735 }
7736 
7737 xcb_void_cookie_t
xcb_change_gc_aux_checked(xcb_connection_t * c,xcb_gcontext_t gc,uint32_t value_mask,const xcb_change_gc_value_list_t * value_list)7738 xcb_change_gc_aux_checked (xcb_connection_t                 *c,
7739                            xcb_gcontext_t                    gc,
7740                            uint32_t                          value_mask,
7741                            const xcb_change_gc_value_list_t *value_list)
7742 {
7743     static const xcb_protocol_request_t xcb_req = {
7744         .count = 3,
7745         .ext = 0,
7746         .opcode = XCB_CHANGE_GC,
7747         .isvoid = 1
7748     };
7749 
7750     struct iovec xcb_parts[5];
7751     xcb_void_cookie_t xcb_ret;
7752     xcb_change_gc_request_t xcb_out;
7753     void *xcb_aux0 = 0;
7754 
7755     xcb_out.pad0 = 0;
7756     xcb_out.gc = gc;
7757     xcb_out.value_mask = value_mask;
7758 
7759     xcb_parts[2].iov_base = (char *) &xcb_out;
7760     xcb_parts[2].iov_len = sizeof(xcb_out);
7761     xcb_parts[3].iov_base = 0;
7762     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7763     /* xcb_change_gc_value_list_t value_list */
7764     xcb_parts[4].iov_len =
7765       xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
7766     xcb_parts[4].iov_base = xcb_aux0;
7767 
7768     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7769     free(xcb_aux0);
7770     return xcb_ret;
7771 }
7772 
7773 xcb_void_cookie_t
xcb_change_gc_aux(xcb_connection_t * c,xcb_gcontext_t gc,uint32_t value_mask,const xcb_change_gc_value_list_t * value_list)7774 xcb_change_gc_aux (xcb_connection_t                 *c,
7775                    xcb_gcontext_t                    gc,
7776                    uint32_t                          value_mask,
7777                    const xcb_change_gc_value_list_t *value_list)
7778 {
7779     static const xcb_protocol_request_t xcb_req = {
7780         .count = 3,
7781         .ext = 0,
7782         .opcode = XCB_CHANGE_GC,
7783         .isvoid = 1
7784     };
7785 
7786     struct iovec xcb_parts[5];
7787     xcb_void_cookie_t xcb_ret;
7788     xcb_change_gc_request_t xcb_out;
7789     void *xcb_aux0 = 0;
7790 
7791     xcb_out.pad0 = 0;
7792     xcb_out.gc = gc;
7793     xcb_out.value_mask = value_mask;
7794 
7795     xcb_parts[2].iov_base = (char *) &xcb_out;
7796     xcb_parts[2].iov_len = sizeof(xcb_out);
7797     xcb_parts[3].iov_base = 0;
7798     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7799     /* xcb_change_gc_value_list_t value_list */
7800     xcb_parts[4].iov_len =
7801       xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
7802     xcb_parts[4].iov_base = xcb_aux0;
7803 
7804     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7805     free(xcb_aux0);
7806     return xcb_ret;
7807 }
7808 
7809 void *
xcb_change_gc_value_list(const xcb_change_gc_request_t * R)7810 xcb_change_gc_value_list (const xcb_change_gc_request_t *R)
7811 {
7812     return (void *) (R + 1);
7813 }
7814 
7815 xcb_void_cookie_t
xcb_copy_gc_checked(xcb_connection_t * c,xcb_gcontext_t src_gc,xcb_gcontext_t dst_gc,uint32_t value_mask)7816 xcb_copy_gc_checked (xcb_connection_t *c,
7817                      xcb_gcontext_t    src_gc,
7818                      xcb_gcontext_t    dst_gc,
7819                      uint32_t          value_mask)
7820 {
7821     static const xcb_protocol_request_t xcb_req = {
7822         .count = 2,
7823         .ext = 0,
7824         .opcode = XCB_COPY_GC,
7825         .isvoid = 1
7826     };
7827 
7828     struct iovec xcb_parts[4];
7829     xcb_void_cookie_t xcb_ret;
7830     xcb_copy_gc_request_t xcb_out;
7831 
7832     xcb_out.pad0 = 0;
7833     xcb_out.src_gc = src_gc;
7834     xcb_out.dst_gc = dst_gc;
7835     xcb_out.value_mask = value_mask;
7836 
7837     xcb_parts[2].iov_base = (char *) &xcb_out;
7838     xcb_parts[2].iov_len = sizeof(xcb_out);
7839     xcb_parts[3].iov_base = 0;
7840     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7841 
7842     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7843     return xcb_ret;
7844 }
7845 
7846 xcb_void_cookie_t
xcb_copy_gc(xcb_connection_t * c,xcb_gcontext_t src_gc,xcb_gcontext_t dst_gc,uint32_t value_mask)7847 xcb_copy_gc (xcb_connection_t *c,
7848              xcb_gcontext_t    src_gc,
7849              xcb_gcontext_t    dst_gc,
7850              uint32_t          value_mask)
7851 {
7852     static const xcb_protocol_request_t xcb_req = {
7853         .count = 2,
7854         .ext = 0,
7855         .opcode = XCB_COPY_GC,
7856         .isvoid = 1
7857     };
7858 
7859     struct iovec xcb_parts[4];
7860     xcb_void_cookie_t xcb_ret;
7861     xcb_copy_gc_request_t xcb_out;
7862 
7863     xcb_out.pad0 = 0;
7864     xcb_out.src_gc = src_gc;
7865     xcb_out.dst_gc = dst_gc;
7866     xcb_out.value_mask = value_mask;
7867 
7868     xcb_parts[2].iov_base = (char *) &xcb_out;
7869     xcb_parts[2].iov_len = sizeof(xcb_out);
7870     xcb_parts[3].iov_base = 0;
7871     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7872 
7873     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7874     return xcb_ret;
7875 }
7876 
7877 int
xcb_set_dashes_sizeof(const void * _buffer)7878 xcb_set_dashes_sizeof (const void  *_buffer)
7879 {
7880     char *xcb_tmp = (char *)_buffer;
7881     const xcb_set_dashes_request_t *_aux = (xcb_set_dashes_request_t *)_buffer;
7882     unsigned int xcb_buffer_len = 0;
7883     unsigned int xcb_block_len = 0;
7884     unsigned int xcb_pad = 0;
7885     unsigned int xcb_align_to = 0;
7886 
7887 
7888     xcb_block_len += sizeof(xcb_set_dashes_request_t);
7889     xcb_tmp += xcb_block_len;
7890     xcb_buffer_len += xcb_block_len;
7891     xcb_block_len = 0;
7892     /* dashes */
7893     xcb_block_len += _aux->dashes_len * sizeof(uint8_t);
7894     xcb_tmp += xcb_block_len;
7895     xcb_align_to = ALIGNOF(uint8_t);
7896     /* insert padding */
7897     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7898     xcb_buffer_len += xcb_block_len + xcb_pad;
7899     if (0 != xcb_pad) {
7900         xcb_tmp += xcb_pad;
7901         xcb_pad = 0;
7902     }
7903     xcb_block_len = 0;
7904 
7905     return xcb_buffer_len;
7906 }
7907 
7908 xcb_void_cookie_t
xcb_set_dashes_checked(xcb_connection_t * c,xcb_gcontext_t gc,uint16_t dash_offset,uint16_t dashes_len,const uint8_t * dashes)7909 xcb_set_dashes_checked (xcb_connection_t *c,
7910                         xcb_gcontext_t    gc,
7911                         uint16_t          dash_offset,
7912                         uint16_t          dashes_len,
7913                         const uint8_t    *dashes)
7914 {
7915     static const xcb_protocol_request_t xcb_req = {
7916         .count = 4,
7917         .ext = 0,
7918         .opcode = XCB_SET_DASHES,
7919         .isvoid = 1
7920     };
7921 
7922     struct iovec xcb_parts[6];
7923     xcb_void_cookie_t xcb_ret;
7924     xcb_set_dashes_request_t xcb_out;
7925 
7926     xcb_out.pad0 = 0;
7927     xcb_out.gc = gc;
7928     xcb_out.dash_offset = dash_offset;
7929     xcb_out.dashes_len = dashes_len;
7930 
7931     xcb_parts[2].iov_base = (char *) &xcb_out;
7932     xcb_parts[2].iov_len = sizeof(xcb_out);
7933     xcb_parts[3].iov_base = 0;
7934     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7935     /* uint8_t dashes */
7936     xcb_parts[4].iov_base = (char *) dashes;
7937     xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t);
7938     xcb_parts[5].iov_base = 0;
7939     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
7940 
7941     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7942     return xcb_ret;
7943 }
7944 
7945 xcb_void_cookie_t
xcb_set_dashes(xcb_connection_t * c,xcb_gcontext_t gc,uint16_t dash_offset,uint16_t dashes_len,const uint8_t * dashes)7946 xcb_set_dashes (xcb_connection_t *c,
7947                 xcb_gcontext_t    gc,
7948                 uint16_t          dash_offset,
7949                 uint16_t          dashes_len,
7950                 const uint8_t    *dashes)
7951 {
7952     static const xcb_protocol_request_t xcb_req = {
7953         .count = 4,
7954         .ext = 0,
7955         .opcode = XCB_SET_DASHES,
7956         .isvoid = 1
7957     };
7958 
7959     struct iovec xcb_parts[6];
7960     xcb_void_cookie_t xcb_ret;
7961     xcb_set_dashes_request_t xcb_out;
7962 
7963     xcb_out.pad0 = 0;
7964     xcb_out.gc = gc;
7965     xcb_out.dash_offset = dash_offset;
7966     xcb_out.dashes_len = dashes_len;
7967 
7968     xcb_parts[2].iov_base = (char *) &xcb_out;
7969     xcb_parts[2].iov_len = sizeof(xcb_out);
7970     xcb_parts[3].iov_base = 0;
7971     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7972     /* uint8_t dashes */
7973     xcb_parts[4].iov_base = (char *) dashes;
7974     xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t);
7975     xcb_parts[5].iov_base = 0;
7976     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
7977 
7978     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7979     return xcb_ret;
7980 }
7981 
7982 uint8_t *
xcb_set_dashes_dashes(const xcb_set_dashes_request_t * R)7983 xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R)
7984 {
7985     return (uint8_t *) (R + 1);
7986 }
7987 
7988 int
xcb_set_dashes_dashes_length(const xcb_set_dashes_request_t * R)7989 xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R)
7990 {
7991     return R->dashes_len;
7992 }
7993 
7994 xcb_generic_iterator_t
xcb_set_dashes_dashes_end(const xcb_set_dashes_request_t * R)7995 xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R)
7996 {
7997     xcb_generic_iterator_t i;
7998     i.data = ((uint8_t *) (R + 1)) + (R->dashes_len);
7999     i.rem = 0;
8000     i.index = (char *) i.data - (char *) R;
8001     return i;
8002 }
8003 
8004 int
xcb_set_clip_rectangles_sizeof(const void * _buffer,uint32_t rectangles_len)8005 xcb_set_clip_rectangles_sizeof (const void  *_buffer,
8006                                 uint32_t     rectangles_len)
8007 {
8008     char *xcb_tmp = (char *)_buffer;
8009     unsigned int xcb_buffer_len = 0;
8010     unsigned int xcb_block_len = 0;
8011     unsigned int xcb_pad = 0;
8012     unsigned int xcb_align_to = 0;
8013 
8014 
8015     xcb_block_len += sizeof(xcb_set_clip_rectangles_request_t);
8016     xcb_tmp += xcb_block_len;
8017     xcb_buffer_len += xcb_block_len;
8018     xcb_block_len = 0;
8019     /* rectangles */
8020     xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
8021     xcb_tmp += xcb_block_len;
8022     xcb_align_to = ALIGNOF(xcb_rectangle_t);
8023     /* insert padding */
8024     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8025     xcb_buffer_len += xcb_block_len + xcb_pad;
8026     if (0 != xcb_pad) {
8027         xcb_tmp += xcb_pad;
8028         xcb_pad = 0;
8029     }
8030     xcb_block_len = 0;
8031 
8032     return xcb_buffer_len;
8033 }
8034 
8035 xcb_void_cookie_t
xcb_set_clip_rectangles_checked(xcb_connection_t * c,uint8_t ordering,xcb_gcontext_t gc,int16_t clip_x_origin,int16_t clip_y_origin,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)8036 xcb_set_clip_rectangles_checked (xcb_connection_t      *c,
8037                                  uint8_t                ordering,
8038                                  xcb_gcontext_t         gc,
8039                                  int16_t                clip_x_origin,
8040                                  int16_t                clip_y_origin,
8041                                  uint32_t               rectangles_len,
8042                                  const xcb_rectangle_t *rectangles)
8043 {
8044     static const xcb_protocol_request_t xcb_req = {
8045         .count = 4,
8046         .ext = 0,
8047         .opcode = XCB_SET_CLIP_RECTANGLES,
8048         .isvoid = 1
8049     };
8050 
8051     struct iovec xcb_parts[6];
8052     xcb_void_cookie_t xcb_ret;
8053     xcb_set_clip_rectangles_request_t xcb_out;
8054 
8055     xcb_out.ordering = ordering;
8056     xcb_out.gc = gc;
8057     xcb_out.clip_x_origin = clip_x_origin;
8058     xcb_out.clip_y_origin = clip_y_origin;
8059 
8060     xcb_parts[2].iov_base = (char *) &xcb_out;
8061     xcb_parts[2].iov_len = sizeof(xcb_out);
8062     xcb_parts[3].iov_base = 0;
8063     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8064     /* xcb_rectangle_t rectangles */
8065     xcb_parts[4].iov_base = (char *) rectangles;
8066     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
8067     xcb_parts[5].iov_base = 0;
8068     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8069 
8070     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8071     return xcb_ret;
8072 }
8073 
8074 xcb_void_cookie_t
xcb_set_clip_rectangles(xcb_connection_t * c,uint8_t ordering,xcb_gcontext_t gc,int16_t clip_x_origin,int16_t clip_y_origin,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)8075 xcb_set_clip_rectangles (xcb_connection_t      *c,
8076                          uint8_t                ordering,
8077                          xcb_gcontext_t         gc,
8078                          int16_t                clip_x_origin,
8079                          int16_t                clip_y_origin,
8080                          uint32_t               rectangles_len,
8081                          const xcb_rectangle_t *rectangles)
8082 {
8083     static const xcb_protocol_request_t xcb_req = {
8084         .count = 4,
8085         .ext = 0,
8086         .opcode = XCB_SET_CLIP_RECTANGLES,
8087         .isvoid = 1
8088     };
8089 
8090     struct iovec xcb_parts[6];
8091     xcb_void_cookie_t xcb_ret;
8092     xcb_set_clip_rectangles_request_t xcb_out;
8093 
8094     xcb_out.ordering = ordering;
8095     xcb_out.gc = gc;
8096     xcb_out.clip_x_origin = clip_x_origin;
8097     xcb_out.clip_y_origin = clip_y_origin;
8098 
8099     xcb_parts[2].iov_base = (char *) &xcb_out;
8100     xcb_parts[2].iov_len = sizeof(xcb_out);
8101     xcb_parts[3].iov_base = 0;
8102     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8103     /* xcb_rectangle_t rectangles */
8104     xcb_parts[4].iov_base = (char *) rectangles;
8105     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
8106     xcb_parts[5].iov_base = 0;
8107     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8108 
8109     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8110     return xcb_ret;
8111 }
8112 
8113 xcb_rectangle_t *
xcb_set_clip_rectangles_rectangles(const xcb_set_clip_rectangles_request_t * R)8114 xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R)
8115 {
8116     return (xcb_rectangle_t *) (R + 1);
8117 }
8118 
8119 int
xcb_set_clip_rectangles_rectangles_length(const xcb_set_clip_rectangles_request_t * R)8120 xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R)
8121 {
8122     return (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
8123 }
8124 
8125 xcb_rectangle_iterator_t
xcb_set_clip_rectangles_rectangles_iterator(const xcb_set_clip_rectangles_request_t * R)8126 xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R)
8127 {
8128     xcb_rectangle_iterator_t i;
8129     i.data = (xcb_rectangle_t *) (R + 1);
8130     i.rem = (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
8131     i.index = (char *) i.data - (char *) R;
8132     return i;
8133 }
8134 
8135 xcb_void_cookie_t
xcb_free_gc_checked(xcb_connection_t * c,xcb_gcontext_t gc)8136 xcb_free_gc_checked (xcb_connection_t *c,
8137                      xcb_gcontext_t    gc)
8138 {
8139     static const xcb_protocol_request_t xcb_req = {
8140         .count = 2,
8141         .ext = 0,
8142         .opcode = XCB_FREE_GC,
8143         .isvoid = 1
8144     };
8145 
8146     struct iovec xcb_parts[4];
8147     xcb_void_cookie_t xcb_ret;
8148     xcb_free_gc_request_t xcb_out;
8149 
8150     xcb_out.pad0 = 0;
8151     xcb_out.gc = gc;
8152 
8153     xcb_parts[2].iov_base = (char *) &xcb_out;
8154     xcb_parts[2].iov_len = sizeof(xcb_out);
8155     xcb_parts[3].iov_base = 0;
8156     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8157 
8158     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8159     return xcb_ret;
8160 }
8161 
8162 xcb_void_cookie_t
xcb_free_gc(xcb_connection_t * c,xcb_gcontext_t gc)8163 xcb_free_gc (xcb_connection_t *c,
8164              xcb_gcontext_t    gc)
8165 {
8166     static const xcb_protocol_request_t xcb_req = {
8167         .count = 2,
8168         .ext = 0,
8169         .opcode = XCB_FREE_GC,
8170         .isvoid = 1
8171     };
8172 
8173     struct iovec xcb_parts[4];
8174     xcb_void_cookie_t xcb_ret;
8175     xcb_free_gc_request_t xcb_out;
8176 
8177     xcb_out.pad0 = 0;
8178     xcb_out.gc = gc;
8179 
8180     xcb_parts[2].iov_base = (char *) &xcb_out;
8181     xcb_parts[2].iov_len = sizeof(xcb_out);
8182     xcb_parts[3].iov_base = 0;
8183     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8184 
8185     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8186     return xcb_ret;
8187 }
8188 
8189 xcb_void_cookie_t
xcb_clear_area_checked(xcb_connection_t * c,uint8_t exposures,xcb_window_t window,int16_t x,int16_t y,uint16_t width,uint16_t height)8190 xcb_clear_area_checked (xcb_connection_t *c,
8191                         uint8_t           exposures,
8192                         xcb_window_t      window,
8193                         int16_t           x,
8194                         int16_t           y,
8195                         uint16_t          width,
8196                         uint16_t          height)
8197 {
8198     static const xcb_protocol_request_t xcb_req = {
8199         .count = 2,
8200         .ext = 0,
8201         .opcode = XCB_CLEAR_AREA,
8202         .isvoid = 1
8203     };
8204 
8205     struct iovec xcb_parts[4];
8206     xcb_void_cookie_t xcb_ret;
8207     xcb_clear_area_request_t xcb_out;
8208 
8209     xcb_out.exposures = exposures;
8210     xcb_out.window = window;
8211     xcb_out.x = x;
8212     xcb_out.y = y;
8213     xcb_out.width = width;
8214     xcb_out.height = height;
8215 
8216     xcb_parts[2].iov_base = (char *) &xcb_out;
8217     xcb_parts[2].iov_len = sizeof(xcb_out);
8218     xcb_parts[3].iov_base = 0;
8219     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8220 
8221     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8222     return xcb_ret;
8223 }
8224 
8225 xcb_void_cookie_t
xcb_clear_area(xcb_connection_t * c,uint8_t exposures,xcb_window_t window,int16_t x,int16_t y,uint16_t width,uint16_t height)8226 xcb_clear_area (xcb_connection_t *c,
8227                 uint8_t           exposures,
8228                 xcb_window_t      window,
8229                 int16_t           x,
8230                 int16_t           y,
8231                 uint16_t          width,
8232                 uint16_t          height)
8233 {
8234     static const xcb_protocol_request_t xcb_req = {
8235         .count = 2,
8236         .ext = 0,
8237         .opcode = XCB_CLEAR_AREA,
8238         .isvoid = 1
8239     };
8240 
8241     struct iovec xcb_parts[4];
8242     xcb_void_cookie_t xcb_ret;
8243     xcb_clear_area_request_t xcb_out;
8244 
8245     xcb_out.exposures = exposures;
8246     xcb_out.window = window;
8247     xcb_out.x = x;
8248     xcb_out.y = y;
8249     xcb_out.width = width;
8250     xcb_out.height = height;
8251 
8252     xcb_parts[2].iov_base = (char *) &xcb_out;
8253     xcb_parts[2].iov_len = sizeof(xcb_out);
8254     xcb_parts[3].iov_base = 0;
8255     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8256 
8257     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8258     return xcb_ret;
8259 }
8260 
8261 xcb_void_cookie_t
xcb_copy_area_checked(xcb_connection_t * c,xcb_drawable_t src_drawable,xcb_drawable_t dst_drawable,xcb_gcontext_t gc,int16_t src_x,int16_t src_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height)8262 xcb_copy_area_checked (xcb_connection_t *c,
8263                        xcb_drawable_t    src_drawable,
8264                        xcb_drawable_t    dst_drawable,
8265                        xcb_gcontext_t    gc,
8266                        int16_t           src_x,
8267                        int16_t           src_y,
8268                        int16_t           dst_x,
8269                        int16_t           dst_y,
8270                        uint16_t          width,
8271                        uint16_t          height)
8272 {
8273     static const xcb_protocol_request_t xcb_req = {
8274         .count = 2,
8275         .ext = 0,
8276         .opcode = XCB_COPY_AREA,
8277         .isvoid = 1
8278     };
8279 
8280     struct iovec xcb_parts[4];
8281     xcb_void_cookie_t xcb_ret;
8282     xcb_copy_area_request_t xcb_out;
8283 
8284     xcb_out.pad0 = 0;
8285     xcb_out.src_drawable = src_drawable;
8286     xcb_out.dst_drawable = dst_drawable;
8287     xcb_out.gc = gc;
8288     xcb_out.src_x = src_x;
8289     xcb_out.src_y = src_y;
8290     xcb_out.dst_x = dst_x;
8291     xcb_out.dst_y = dst_y;
8292     xcb_out.width = width;
8293     xcb_out.height = height;
8294 
8295     xcb_parts[2].iov_base = (char *) &xcb_out;
8296     xcb_parts[2].iov_len = sizeof(xcb_out);
8297     xcb_parts[3].iov_base = 0;
8298     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8299 
8300     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8301     return xcb_ret;
8302 }
8303 
8304 xcb_void_cookie_t
xcb_copy_area(xcb_connection_t * c,xcb_drawable_t src_drawable,xcb_drawable_t dst_drawable,xcb_gcontext_t gc,int16_t src_x,int16_t src_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height)8305 xcb_copy_area (xcb_connection_t *c,
8306                xcb_drawable_t    src_drawable,
8307                xcb_drawable_t    dst_drawable,
8308                xcb_gcontext_t    gc,
8309                int16_t           src_x,
8310                int16_t           src_y,
8311                int16_t           dst_x,
8312                int16_t           dst_y,
8313                uint16_t          width,
8314                uint16_t          height)
8315 {
8316     static const xcb_protocol_request_t xcb_req = {
8317         .count = 2,
8318         .ext = 0,
8319         .opcode = XCB_COPY_AREA,
8320         .isvoid = 1
8321     };
8322 
8323     struct iovec xcb_parts[4];
8324     xcb_void_cookie_t xcb_ret;
8325     xcb_copy_area_request_t xcb_out;
8326 
8327     xcb_out.pad0 = 0;
8328     xcb_out.src_drawable = src_drawable;
8329     xcb_out.dst_drawable = dst_drawable;
8330     xcb_out.gc = gc;
8331     xcb_out.src_x = src_x;
8332     xcb_out.src_y = src_y;
8333     xcb_out.dst_x = dst_x;
8334     xcb_out.dst_y = dst_y;
8335     xcb_out.width = width;
8336     xcb_out.height = height;
8337 
8338     xcb_parts[2].iov_base = (char *) &xcb_out;
8339     xcb_parts[2].iov_len = sizeof(xcb_out);
8340     xcb_parts[3].iov_base = 0;
8341     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8342 
8343     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8344     return xcb_ret;
8345 }
8346 
8347 xcb_void_cookie_t
xcb_copy_plane_checked(xcb_connection_t * c,xcb_drawable_t src_drawable,xcb_drawable_t dst_drawable,xcb_gcontext_t gc,int16_t src_x,int16_t src_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height,uint32_t bit_plane)8348 xcb_copy_plane_checked (xcb_connection_t *c,
8349                         xcb_drawable_t    src_drawable,
8350                         xcb_drawable_t    dst_drawable,
8351                         xcb_gcontext_t    gc,
8352                         int16_t           src_x,
8353                         int16_t           src_y,
8354                         int16_t           dst_x,
8355                         int16_t           dst_y,
8356                         uint16_t          width,
8357                         uint16_t          height,
8358                         uint32_t          bit_plane)
8359 {
8360     static const xcb_protocol_request_t xcb_req = {
8361         .count = 2,
8362         .ext = 0,
8363         .opcode = XCB_COPY_PLANE,
8364         .isvoid = 1
8365     };
8366 
8367     struct iovec xcb_parts[4];
8368     xcb_void_cookie_t xcb_ret;
8369     xcb_copy_plane_request_t xcb_out;
8370 
8371     xcb_out.pad0 = 0;
8372     xcb_out.src_drawable = src_drawable;
8373     xcb_out.dst_drawable = dst_drawable;
8374     xcb_out.gc = gc;
8375     xcb_out.src_x = src_x;
8376     xcb_out.src_y = src_y;
8377     xcb_out.dst_x = dst_x;
8378     xcb_out.dst_y = dst_y;
8379     xcb_out.width = width;
8380     xcb_out.height = height;
8381     xcb_out.bit_plane = bit_plane;
8382 
8383     xcb_parts[2].iov_base = (char *) &xcb_out;
8384     xcb_parts[2].iov_len = sizeof(xcb_out);
8385     xcb_parts[3].iov_base = 0;
8386     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8387 
8388     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8389     return xcb_ret;
8390 }
8391 
8392 xcb_void_cookie_t
xcb_copy_plane(xcb_connection_t * c,xcb_drawable_t src_drawable,xcb_drawable_t dst_drawable,xcb_gcontext_t gc,int16_t src_x,int16_t src_y,int16_t dst_x,int16_t dst_y,uint16_t width,uint16_t height,uint32_t bit_plane)8393 xcb_copy_plane (xcb_connection_t *c,
8394                 xcb_drawable_t    src_drawable,
8395                 xcb_drawable_t    dst_drawable,
8396                 xcb_gcontext_t    gc,
8397                 int16_t           src_x,
8398                 int16_t           src_y,
8399                 int16_t           dst_x,
8400                 int16_t           dst_y,
8401                 uint16_t          width,
8402                 uint16_t          height,
8403                 uint32_t          bit_plane)
8404 {
8405     static const xcb_protocol_request_t xcb_req = {
8406         .count = 2,
8407         .ext = 0,
8408         .opcode = XCB_COPY_PLANE,
8409         .isvoid = 1
8410     };
8411 
8412     struct iovec xcb_parts[4];
8413     xcb_void_cookie_t xcb_ret;
8414     xcb_copy_plane_request_t xcb_out;
8415 
8416     xcb_out.pad0 = 0;
8417     xcb_out.src_drawable = src_drawable;
8418     xcb_out.dst_drawable = dst_drawable;
8419     xcb_out.gc = gc;
8420     xcb_out.src_x = src_x;
8421     xcb_out.src_y = src_y;
8422     xcb_out.dst_x = dst_x;
8423     xcb_out.dst_y = dst_y;
8424     xcb_out.width = width;
8425     xcb_out.height = height;
8426     xcb_out.bit_plane = bit_plane;
8427 
8428     xcb_parts[2].iov_base = (char *) &xcb_out;
8429     xcb_parts[2].iov_len = sizeof(xcb_out);
8430     xcb_parts[3].iov_base = 0;
8431     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8432 
8433     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8434     return xcb_ret;
8435 }
8436 
8437 int
xcb_poly_point_sizeof(const void * _buffer,uint32_t points_len)8438 xcb_poly_point_sizeof (const void  *_buffer,
8439                        uint32_t     points_len)
8440 {
8441     char *xcb_tmp = (char *)_buffer;
8442     unsigned int xcb_buffer_len = 0;
8443     unsigned int xcb_block_len = 0;
8444     unsigned int xcb_pad = 0;
8445     unsigned int xcb_align_to = 0;
8446 
8447 
8448     xcb_block_len += sizeof(xcb_poly_point_request_t);
8449     xcb_tmp += xcb_block_len;
8450     xcb_buffer_len += xcb_block_len;
8451     xcb_block_len = 0;
8452     /* points */
8453     xcb_block_len += points_len * sizeof(xcb_point_t);
8454     xcb_tmp += xcb_block_len;
8455     xcb_align_to = ALIGNOF(xcb_point_t);
8456     /* insert padding */
8457     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8458     xcb_buffer_len += xcb_block_len + xcb_pad;
8459     if (0 != xcb_pad) {
8460         xcb_tmp += xcb_pad;
8461         xcb_pad = 0;
8462     }
8463     xcb_block_len = 0;
8464 
8465     return xcb_buffer_len;
8466 }
8467 
8468 xcb_void_cookie_t
xcb_poly_point_checked(xcb_connection_t * c,uint8_t coordinate_mode,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t points_len,const xcb_point_t * points)8469 xcb_poly_point_checked (xcb_connection_t  *c,
8470                         uint8_t            coordinate_mode,
8471                         xcb_drawable_t     drawable,
8472                         xcb_gcontext_t     gc,
8473                         uint32_t           points_len,
8474                         const xcb_point_t *points)
8475 {
8476     static const xcb_protocol_request_t xcb_req = {
8477         .count = 4,
8478         .ext = 0,
8479         .opcode = XCB_POLY_POINT,
8480         .isvoid = 1
8481     };
8482 
8483     struct iovec xcb_parts[6];
8484     xcb_void_cookie_t xcb_ret;
8485     xcb_poly_point_request_t xcb_out;
8486 
8487     xcb_out.coordinate_mode = coordinate_mode;
8488     xcb_out.drawable = drawable;
8489     xcb_out.gc = gc;
8490 
8491     xcb_parts[2].iov_base = (char *) &xcb_out;
8492     xcb_parts[2].iov_len = sizeof(xcb_out);
8493     xcb_parts[3].iov_base = 0;
8494     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8495     /* xcb_point_t points */
8496     xcb_parts[4].iov_base = (char *) points;
8497     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
8498     xcb_parts[5].iov_base = 0;
8499     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8500 
8501     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8502     return xcb_ret;
8503 }
8504 
8505 xcb_void_cookie_t
xcb_poly_point(xcb_connection_t * c,uint8_t coordinate_mode,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t points_len,const xcb_point_t * points)8506 xcb_poly_point (xcb_connection_t  *c,
8507                 uint8_t            coordinate_mode,
8508                 xcb_drawable_t     drawable,
8509                 xcb_gcontext_t     gc,
8510                 uint32_t           points_len,
8511                 const xcb_point_t *points)
8512 {
8513     static const xcb_protocol_request_t xcb_req = {
8514         .count = 4,
8515         .ext = 0,
8516         .opcode = XCB_POLY_POINT,
8517         .isvoid = 1
8518     };
8519 
8520     struct iovec xcb_parts[6];
8521     xcb_void_cookie_t xcb_ret;
8522     xcb_poly_point_request_t xcb_out;
8523 
8524     xcb_out.coordinate_mode = coordinate_mode;
8525     xcb_out.drawable = drawable;
8526     xcb_out.gc = gc;
8527 
8528     xcb_parts[2].iov_base = (char *) &xcb_out;
8529     xcb_parts[2].iov_len = sizeof(xcb_out);
8530     xcb_parts[3].iov_base = 0;
8531     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8532     /* xcb_point_t points */
8533     xcb_parts[4].iov_base = (char *) points;
8534     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
8535     xcb_parts[5].iov_base = 0;
8536     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8537 
8538     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8539     return xcb_ret;
8540 }
8541 
8542 xcb_point_t *
xcb_poly_point_points(const xcb_poly_point_request_t * R)8543 xcb_poly_point_points (const xcb_poly_point_request_t *R)
8544 {
8545     return (xcb_point_t *) (R + 1);
8546 }
8547 
8548 int
xcb_poly_point_points_length(const xcb_poly_point_request_t * R)8549 xcb_poly_point_points_length (const xcb_poly_point_request_t *R)
8550 {
8551     return (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t));
8552 }
8553 
8554 xcb_point_iterator_t
xcb_poly_point_points_iterator(const xcb_poly_point_request_t * R)8555 xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R)
8556 {
8557     xcb_point_iterator_t i;
8558     i.data = (xcb_point_t *) (R + 1);
8559     i.rem = (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t));
8560     i.index = (char *) i.data - (char *) R;
8561     return i;
8562 }
8563 
8564 int
xcb_poly_line_sizeof(const void * _buffer,uint32_t points_len)8565 xcb_poly_line_sizeof (const void  *_buffer,
8566                       uint32_t     points_len)
8567 {
8568     char *xcb_tmp = (char *)_buffer;
8569     unsigned int xcb_buffer_len = 0;
8570     unsigned int xcb_block_len = 0;
8571     unsigned int xcb_pad = 0;
8572     unsigned int xcb_align_to = 0;
8573 
8574 
8575     xcb_block_len += sizeof(xcb_poly_line_request_t);
8576     xcb_tmp += xcb_block_len;
8577     xcb_buffer_len += xcb_block_len;
8578     xcb_block_len = 0;
8579     /* points */
8580     xcb_block_len += points_len * sizeof(xcb_point_t);
8581     xcb_tmp += xcb_block_len;
8582     xcb_align_to = ALIGNOF(xcb_point_t);
8583     /* insert padding */
8584     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8585     xcb_buffer_len += xcb_block_len + xcb_pad;
8586     if (0 != xcb_pad) {
8587         xcb_tmp += xcb_pad;
8588         xcb_pad = 0;
8589     }
8590     xcb_block_len = 0;
8591 
8592     return xcb_buffer_len;
8593 }
8594 
8595 xcb_void_cookie_t
xcb_poly_line_checked(xcb_connection_t * c,uint8_t coordinate_mode,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t points_len,const xcb_point_t * points)8596 xcb_poly_line_checked (xcb_connection_t  *c,
8597                        uint8_t            coordinate_mode,
8598                        xcb_drawable_t     drawable,
8599                        xcb_gcontext_t     gc,
8600                        uint32_t           points_len,
8601                        const xcb_point_t *points)
8602 {
8603     static const xcb_protocol_request_t xcb_req = {
8604         .count = 4,
8605         .ext = 0,
8606         .opcode = XCB_POLY_LINE,
8607         .isvoid = 1
8608     };
8609 
8610     struct iovec xcb_parts[6];
8611     xcb_void_cookie_t xcb_ret;
8612     xcb_poly_line_request_t xcb_out;
8613 
8614     xcb_out.coordinate_mode = coordinate_mode;
8615     xcb_out.drawable = drawable;
8616     xcb_out.gc = gc;
8617 
8618     xcb_parts[2].iov_base = (char *) &xcb_out;
8619     xcb_parts[2].iov_len = sizeof(xcb_out);
8620     xcb_parts[3].iov_base = 0;
8621     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8622     /* xcb_point_t points */
8623     xcb_parts[4].iov_base = (char *) points;
8624     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
8625     xcb_parts[5].iov_base = 0;
8626     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8627 
8628     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8629     return xcb_ret;
8630 }
8631 
8632 xcb_void_cookie_t
xcb_poly_line(xcb_connection_t * c,uint8_t coordinate_mode,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t points_len,const xcb_point_t * points)8633 xcb_poly_line (xcb_connection_t  *c,
8634                uint8_t            coordinate_mode,
8635                xcb_drawable_t     drawable,
8636                xcb_gcontext_t     gc,
8637                uint32_t           points_len,
8638                const xcb_point_t *points)
8639 {
8640     static const xcb_protocol_request_t xcb_req = {
8641         .count = 4,
8642         .ext = 0,
8643         .opcode = XCB_POLY_LINE,
8644         .isvoid = 1
8645     };
8646 
8647     struct iovec xcb_parts[6];
8648     xcb_void_cookie_t xcb_ret;
8649     xcb_poly_line_request_t xcb_out;
8650 
8651     xcb_out.coordinate_mode = coordinate_mode;
8652     xcb_out.drawable = drawable;
8653     xcb_out.gc = gc;
8654 
8655     xcb_parts[2].iov_base = (char *) &xcb_out;
8656     xcb_parts[2].iov_len = sizeof(xcb_out);
8657     xcb_parts[3].iov_base = 0;
8658     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8659     /* xcb_point_t points */
8660     xcb_parts[4].iov_base = (char *) points;
8661     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
8662     xcb_parts[5].iov_base = 0;
8663     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8664 
8665     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8666     return xcb_ret;
8667 }
8668 
8669 xcb_point_t *
xcb_poly_line_points(const xcb_poly_line_request_t * R)8670 xcb_poly_line_points (const xcb_poly_line_request_t *R)
8671 {
8672     return (xcb_point_t *) (R + 1);
8673 }
8674 
8675 int
xcb_poly_line_points_length(const xcb_poly_line_request_t * R)8676 xcb_poly_line_points_length (const xcb_poly_line_request_t *R)
8677 {
8678     return (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t));
8679 }
8680 
8681 xcb_point_iterator_t
xcb_poly_line_points_iterator(const xcb_poly_line_request_t * R)8682 xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R)
8683 {
8684     xcb_point_iterator_t i;
8685     i.data = (xcb_point_t *) (R + 1);
8686     i.rem = (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t));
8687     i.index = (char *) i.data - (char *) R;
8688     return i;
8689 }
8690 
8691 void
xcb_segment_next(xcb_segment_iterator_t * i)8692 xcb_segment_next (xcb_segment_iterator_t *i)
8693 {
8694     --i->rem;
8695     ++i->data;
8696     i->index += sizeof(xcb_segment_t);
8697 }
8698 
8699 xcb_generic_iterator_t
xcb_segment_end(xcb_segment_iterator_t i)8700 xcb_segment_end (xcb_segment_iterator_t i)
8701 {
8702     xcb_generic_iterator_t ret;
8703     ret.data = i.data + i.rem;
8704     ret.index = i.index + ((char *) ret.data - (char *) i.data);
8705     ret.rem = 0;
8706     return ret;
8707 }
8708 
8709 int
xcb_poly_segment_sizeof(const void * _buffer,uint32_t segments_len)8710 xcb_poly_segment_sizeof (const void  *_buffer,
8711                          uint32_t     segments_len)
8712 {
8713     char *xcb_tmp = (char *)_buffer;
8714     unsigned int xcb_buffer_len = 0;
8715     unsigned int xcb_block_len = 0;
8716     unsigned int xcb_pad = 0;
8717     unsigned int xcb_align_to = 0;
8718 
8719 
8720     xcb_block_len += sizeof(xcb_poly_segment_request_t);
8721     xcb_tmp += xcb_block_len;
8722     xcb_buffer_len += xcb_block_len;
8723     xcb_block_len = 0;
8724     /* segments */
8725     xcb_block_len += segments_len * sizeof(xcb_segment_t);
8726     xcb_tmp += xcb_block_len;
8727     xcb_align_to = ALIGNOF(xcb_segment_t);
8728     /* insert padding */
8729     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8730     xcb_buffer_len += xcb_block_len + xcb_pad;
8731     if (0 != xcb_pad) {
8732         xcb_tmp += xcb_pad;
8733         xcb_pad = 0;
8734     }
8735     xcb_block_len = 0;
8736 
8737     return xcb_buffer_len;
8738 }
8739 
8740 xcb_void_cookie_t
xcb_poly_segment_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t segments_len,const xcb_segment_t * segments)8741 xcb_poly_segment_checked (xcb_connection_t    *c,
8742                           xcb_drawable_t       drawable,
8743                           xcb_gcontext_t       gc,
8744                           uint32_t             segments_len,
8745                           const xcb_segment_t *segments)
8746 {
8747     static const xcb_protocol_request_t xcb_req = {
8748         .count = 4,
8749         .ext = 0,
8750         .opcode = XCB_POLY_SEGMENT,
8751         .isvoid = 1
8752     };
8753 
8754     struct iovec xcb_parts[6];
8755     xcb_void_cookie_t xcb_ret;
8756     xcb_poly_segment_request_t xcb_out;
8757 
8758     xcb_out.pad0 = 0;
8759     xcb_out.drawable = drawable;
8760     xcb_out.gc = gc;
8761 
8762     xcb_parts[2].iov_base = (char *) &xcb_out;
8763     xcb_parts[2].iov_len = sizeof(xcb_out);
8764     xcb_parts[3].iov_base = 0;
8765     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8766     /* xcb_segment_t segments */
8767     xcb_parts[4].iov_base = (char *) segments;
8768     xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t);
8769     xcb_parts[5].iov_base = 0;
8770     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8771 
8772     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8773     return xcb_ret;
8774 }
8775 
8776 xcb_void_cookie_t
xcb_poly_segment(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t segments_len,const xcb_segment_t * segments)8777 xcb_poly_segment (xcb_connection_t    *c,
8778                   xcb_drawable_t       drawable,
8779                   xcb_gcontext_t       gc,
8780                   uint32_t             segments_len,
8781                   const xcb_segment_t *segments)
8782 {
8783     static const xcb_protocol_request_t xcb_req = {
8784         .count = 4,
8785         .ext = 0,
8786         .opcode = XCB_POLY_SEGMENT,
8787         .isvoid = 1
8788     };
8789 
8790     struct iovec xcb_parts[6];
8791     xcb_void_cookie_t xcb_ret;
8792     xcb_poly_segment_request_t xcb_out;
8793 
8794     xcb_out.pad0 = 0;
8795     xcb_out.drawable = drawable;
8796     xcb_out.gc = gc;
8797 
8798     xcb_parts[2].iov_base = (char *) &xcb_out;
8799     xcb_parts[2].iov_len = sizeof(xcb_out);
8800     xcb_parts[3].iov_base = 0;
8801     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8802     /* xcb_segment_t segments */
8803     xcb_parts[4].iov_base = (char *) segments;
8804     xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t);
8805     xcb_parts[5].iov_base = 0;
8806     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8807 
8808     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8809     return xcb_ret;
8810 }
8811 
8812 xcb_segment_t *
xcb_poly_segment_segments(const xcb_poly_segment_request_t * R)8813 xcb_poly_segment_segments (const xcb_poly_segment_request_t *R)
8814 {
8815     return (xcb_segment_t *) (R + 1);
8816 }
8817 
8818 int
xcb_poly_segment_segments_length(const xcb_poly_segment_request_t * R)8819 xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R)
8820 {
8821     return (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t));
8822 }
8823 
8824 xcb_segment_iterator_t
xcb_poly_segment_segments_iterator(const xcb_poly_segment_request_t * R)8825 xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R)
8826 {
8827     xcb_segment_iterator_t i;
8828     i.data = (xcb_segment_t *) (R + 1);
8829     i.rem = (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t));
8830     i.index = (char *) i.data - (char *) R;
8831     return i;
8832 }
8833 
8834 int
xcb_poly_rectangle_sizeof(const void * _buffer,uint32_t rectangles_len)8835 xcb_poly_rectangle_sizeof (const void  *_buffer,
8836                            uint32_t     rectangles_len)
8837 {
8838     char *xcb_tmp = (char *)_buffer;
8839     unsigned int xcb_buffer_len = 0;
8840     unsigned int xcb_block_len = 0;
8841     unsigned int xcb_pad = 0;
8842     unsigned int xcb_align_to = 0;
8843 
8844 
8845     xcb_block_len += sizeof(xcb_poly_rectangle_request_t);
8846     xcb_tmp += xcb_block_len;
8847     xcb_buffer_len += xcb_block_len;
8848     xcb_block_len = 0;
8849     /* rectangles */
8850     xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
8851     xcb_tmp += xcb_block_len;
8852     xcb_align_to = ALIGNOF(xcb_rectangle_t);
8853     /* insert padding */
8854     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8855     xcb_buffer_len += xcb_block_len + xcb_pad;
8856     if (0 != xcb_pad) {
8857         xcb_tmp += xcb_pad;
8858         xcb_pad = 0;
8859     }
8860     xcb_block_len = 0;
8861 
8862     return xcb_buffer_len;
8863 }
8864 
8865 xcb_void_cookie_t
xcb_poly_rectangle_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)8866 xcb_poly_rectangle_checked (xcb_connection_t      *c,
8867                             xcb_drawable_t         drawable,
8868                             xcb_gcontext_t         gc,
8869                             uint32_t               rectangles_len,
8870                             const xcb_rectangle_t *rectangles)
8871 {
8872     static const xcb_protocol_request_t xcb_req = {
8873         .count = 4,
8874         .ext = 0,
8875         .opcode = XCB_POLY_RECTANGLE,
8876         .isvoid = 1
8877     };
8878 
8879     struct iovec xcb_parts[6];
8880     xcb_void_cookie_t xcb_ret;
8881     xcb_poly_rectangle_request_t xcb_out;
8882 
8883     xcb_out.pad0 = 0;
8884     xcb_out.drawable = drawable;
8885     xcb_out.gc = gc;
8886 
8887     xcb_parts[2].iov_base = (char *) &xcb_out;
8888     xcb_parts[2].iov_len = sizeof(xcb_out);
8889     xcb_parts[3].iov_base = 0;
8890     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8891     /* xcb_rectangle_t rectangles */
8892     xcb_parts[4].iov_base = (char *) rectangles;
8893     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
8894     xcb_parts[5].iov_base = 0;
8895     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8896 
8897     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8898     return xcb_ret;
8899 }
8900 
8901 xcb_void_cookie_t
xcb_poly_rectangle(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)8902 xcb_poly_rectangle (xcb_connection_t      *c,
8903                     xcb_drawable_t         drawable,
8904                     xcb_gcontext_t         gc,
8905                     uint32_t               rectangles_len,
8906                     const xcb_rectangle_t *rectangles)
8907 {
8908     static const xcb_protocol_request_t xcb_req = {
8909         .count = 4,
8910         .ext = 0,
8911         .opcode = XCB_POLY_RECTANGLE,
8912         .isvoid = 1
8913     };
8914 
8915     struct iovec xcb_parts[6];
8916     xcb_void_cookie_t xcb_ret;
8917     xcb_poly_rectangle_request_t xcb_out;
8918 
8919     xcb_out.pad0 = 0;
8920     xcb_out.drawable = drawable;
8921     xcb_out.gc = gc;
8922 
8923     xcb_parts[2].iov_base = (char *) &xcb_out;
8924     xcb_parts[2].iov_len = sizeof(xcb_out);
8925     xcb_parts[3].iov_base = 0;
8926     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8927     /* xcb_rectangle_t rectangles */
8928     xcb_parts[4].iov_base = (char *) rectangles;
8929     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
8930     xcb_parts[5].iov_base = 0;
8931     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
8932 
8933     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8934     return xcb_ret;
8935 }
8936 
8937 xcb_rectangle_t *
xcb_poly_rectangle_rectangles(const xcb_poly_rectangle_request_t * R)8938 xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R)
8939 {
8940     return (xcb_rectangle_t *) (R + 1);
8941 }
8942 
8943 int
xcb_poly_rectangle_rectangles_length(const xcb_poly_rectangle_request_t * R)8944 xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R)
8945 {
8946     return (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t));
8947 }
8948 
8949 xcb_rectangle_iterator_t
xcb_poly_rectangle_rectangles_iterator(const xcb_poly_rectangle_request_t * R)8950 xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R)
8951 {
8952     xcb_rectangle_iterator_t i;
8953     i.data = (xcb_rectangle_t *) (R + 1);
8954     i.rem = (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t));
8955     i.index = (char *) i.data - (char *) R;
8956     return i;
8957 }
8958 
8959 int
xcb_poly_arc_sizeof(const void * _buffer,uint32_t arcs_len)8960 xcb_poly_arc_sizeof (const void  *_buffer,
8961                      uint32_t     arcs_len)
8962 {
8963     char *xcb_tmp = (char *)_buffer;
8964     unsigned int xcb_buffer_len = 0;
8965     unsigned int xcb_block_len = 0;
8966     unsigned int xcb_pad = 0;
8967     unsigned int xcb_align_to = 0;
8968 
8969 
8970     xcb_block_len += sizeof(xcb_poly_arc_request_t);
8971     xcb_tmp += xcb_block_len;
8972     xcb_buffer_len += xcb_block_len;
8973     xcb_block_len = 0;
8974     /* arcs */
8975     xcb_block_len += arcs_len * sizeof(xcb_arc_t);
8976     xcb_tmp += xcb_block_len;
8977     xcb_align_to = ALIGNOF(xcb_arc_t);
8978     /* insert padding */
8979     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8980     xcb_buffer_len += xcb_block_len + xcb_pad;
8981     if (0 != xcb_pad) {
8982         xcb_tmp += xcb_pad;
8983         xcb_pad = 0;
8984     }
8985     xcb_block_len = 0;
8986 
8987     return xcb_buffer_len;
8988 }
8989 
8990 xcb_void_cookie_t
xcb_poly_arc_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t arcs_len,const xcb_arc_t * arcs)8991 xcb_poly_arc_checked (xcb_connection_t *c,
8992                       xcb_drawable_t    drawable,
8993                       xcb_gcontext_t    gc,
8994                       uint32_t          arcs_len,
8995                       const xcb_arc_t  *arcs)
8996 {
8997     static const xcb_protocol_request_t xcb_req = {
8998         .count = 4,
8999         .ext = 0,
9000         .opcode = XCB_POLY_ARC,
9001         .isvoid = 1
9002     };
9003 
9004     struct iovec xcb_parts[6];
9005     xcb_void_cookie_t xcb_ret;
9006     xcb_poly_arc_request_t xcb_out;
9007 
9008     xcb_out.pad0 = 0;
9009     xcb_out.drawable = drawable;
9010     xcb_out.gc = gc;
9011 
9012     xcb_parts[2].iov_base = (char *) &xcb_out;
9013     xcb_parts[2].iov_len = sizeof(xcb_out);
9014     xcb_parts[3].iov_base = 0;
9015     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9016     /* xcb_arc_t arcs */
9017     xcb_parts[4].iov_base = (char *) arcs;
9018     xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
9019     xcb_parts[5].iov_base = 0;
9020     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9021 
9022     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9023     return xcb_ret;
9024 }
9025 
9026 xcb_void_cookie_t
xcb_poly_arc(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t arcs_len,const xcb_arc_t * arcs)9027 xcb_poly_arc (xcb_connection_t *c,
9028               xcb_drawable_t    drawable,
9029               xcb_gcontext_t    gc,
9030               uint32_t          arcs_len,
9031               const xcb_arc_t  *arcs)
9032 {
9033     static const xcb_protocol_request_t xcb_req = {
9034         .count = 4,
9035         .ext = 0,
9036         .opcode = XCB_POLY_ARC,
9037         .isvoid = 1
9038     };
9039 
9040     struct iovec xcb_parts[6];
9041     xcb_void_cookie_t xcb_ret;
9042     xcb_poly_arc_request_t xcb_out;
9043 
9044     xcb_out.pad0 = 0;
9045     xcb_out.drawable = drawable;
9046     xcb_out.gc = gc;
9047 
9048     xcb_parts[2].iov_base = (char *) &xcb_out;
9049     xcb_parts[2].iov_len = sizeof(xcb_out);
9050     xcb_parts[3].iov_base = 0;
9051     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9052     /* xcb_arc_t arcs */
9053     xcb_parts[4].iov_base = (char *) arcs;
9054     xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
9055     xcb_parts[5].iov_base = 0;
9056     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9057 
9058     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9059     return xcb_ret;
9060 }
9061 
9062 xcb_arc_t *
xcb_poly_arc_arcs(const xcb_poly_arc_request_t * R)9063 xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R)
9064 {
9065     return (xcb_arc_t *) (R + 1);
9066 }
9067 
9068 int
xcb_poly_arc_arcs_length(const xcb_poly_arc_request_t * R)9069 xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R)
9070 {
9071     return (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t));
9072 }
9073 
9074 xcb_arc_iterator_t
xcb_poly_arc_arcs_iterator(const xcb_poly_arc_request_t * R)9075 xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R)
9076 {
9077     xcb_arc_iterator_t i;
9078     i.data = (xcb_arc_t *) (R + 1);
9079     i.rem = (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t));
9080     i.index = (char *) i.data - (char *) R;
9081     return i;
9082 }
9083 
9084 int
xcb_fill_poly_sizeof(const void * _buffer,uint32_t points_len)9085 xcb_fill_poly_sizeof (const void  *_buffer,
9086                       uint32_t     points_len)
9087 {
9088     char *xcb_tmp = (char *)_buffer;
9089     unsigned int xcb_buffer_len = 0;
9090     unsigned int xcb_block_len = 0;
9091     unsigned int xcb_pad = 0;
9092     unsigned int xcb_align_to = 0;
9093 
9094 
9095     xcb_block_len += sizeof(xcb_fill_poly_request_t);
9096     xcb_tmp += xcb_block_len;
9097     xcb_buffer_len += xcb_block_len;
9098     xcb_block_len = 0;
9099     /* points */
9100     xcb_block_len += points_len * sizeof(xcb_point_t);
9101     xcb_tmp += xcb_block_len;
9102     xcb_align_to = ALIGNOF(xcb_point_t);
9103     /* insert padding */
9104     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9105     xcb_buffer_len += xcb_block_len + xcb_pad;
9106     if (0 != xcb_pad) {
9107         xcb_tmp += xcb_pad;
9108         xcb_pad = 0;
9109     }
9110     xcb_block_len = 0;
9111 
9112     return xcb_buffer_len;
9113 }
9114 
9115 xcb_void_cookie_t
xcb_fill_poly_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint8_t shape,uint8_t coordinate_mode,uint32_t points_len,const xcb_point_t * points)9116 xcb_fill_poly_checked (xcb_connection_t  *c,
9117                        xcb_drawable_t     drawable,
9118                        xcb_gcontext_t     gc,
9119                        uint8_t            shape,
9120                        uint8_t            coordinate_mode,
9121                        uint32_t           points_len,
9122                        const xcb_point_t *points)
9123 {
9124     static const xcb_protocol_request_t xcb_req = {
9125         .count = 4,
9126         .ext = 0,
9127         .opcode = XCB_FILL_POLY,
9128         .isvoid = 1
9129     };
9130 
9131     struct iovec xcb_parts[6];
9132     xcb_void_cookie_t xcb_ret;
9133     xcb_fill_poly_request_t xcb_out;
9134 
9135     xcb_out.pad0 = 0;
9136     xcb_out.drawable = drawable;
9137     xcb_out.gc = gc;
9138     xcb_out.shape = shape;
9139     xcb_out.coordinate_mode = coordinate_mode;
9140     memset(xcb_out.pad1, 0, 2);
9141 
9142     xcb_parts[2].iov_base = (char *) &xcb_out;
9143     xcb_parts[2].iov_len = sizeof(xcb_out);
9144     xcb_parts[3].iov_base = 0;
9145     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9146     /* xcb_point_t points */
9147     xcb_parts[4].iov_base = (char *) points;
9148     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
9149     xcb_parts[5].iov_base = 0;
9150     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9151 
9152     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9153     return xcb_ret;
9154 }
9155 
9156 xcb_void_cookie_t
xcb_fill_poly(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint8_t shape,uint8_t coordinate_mode,uint32_t points_len,const xcb_point_t * points)9157 xcb_fill_poly (xcb_connection_t  *c,
9158                xcb_drawable_t     drawable,
9159                xcb_gcontext_t     gc,
9160                uint8_t            shape,
9161                uint8_t            coordinate_mode,
9162                uint32_t           points_len,
9163                const xcb_point_t *points)
9164 {
9165     static const xcb_protocol_request_t xcb_req = {
9166         .count = 4,
9167         .ext = 0,
9168         .opcode = XCB_FILL_POLY,
9169         .isvoid = 1
9170     };
9171 
9172     struct iovec xcb_parts[6];
9173     xcb_void_cookie_t xcb_ret;
9174     xcb_fill_poly_request_t xcb_out;
9175 
9176     xcb_out.pad0 = 0;
9177     xcb_out.drawable = drawable;
9178     xcb_out.gc = gc;
9179     xcb_out.shape = shape;
9180     xcb_out.coordinate_mode = coordinate_mode;
9181     memset(xcb_out.pad1, 0, 2);
9182 
9183     xcb_parts[2].iov_base = (char *) &xcb_out;
9184     xcb_parts[2].iov_len = sizeof(xcb_out);
9185     xcb_parts[3].iov_base = 0;
9186     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9187     /* xcb_point_t points */
9188     xcb_parts[4].iov_base = (char *) points;
9189     xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
9190     xcb_parts[5].iov_base = 0;
9191     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9192 
9193     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9194     return xcb_ret;
9195 }
9196 
9197 xcb_point_t *
xcb_fill_poly_points(const xcb_fill_poly_request_t * R)9198 xcb_fill_poly_points (const xcb_fill_poly_request_t *R)
9199 {
9200     return (xcb_point_t *) (R + 1);
9201 }
9202 
9203 int
xcb_fill_poly_points_length(const xcb_fill_poly_request_t * R)9204 xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R)
9205 {
9206     return (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t));
9207 }
9208 
9209 xcb_point_iterator_t
xcb_fill_poly_points_iterator(const xcb_fill_poly_request_t * R)9210 xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R)
9211 {
9212     xcb_point_iterator_t i;
9213     i.data = (xcb_point_t *) (R + 1);
9214     i.rem = (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t));
9215     i.index = (char *) i.data - (char *) R;
9216     return i;
9217 }
9218 
9219 int
xcb_poly_fill_rectangle_sizeof(const void * _buffer,uint32_t rectangles_len)9220 xcb_poly_fill_rectangle_sizeof (const void  *_buffer,
9221                                 uint32_t     rectangles_len)
9222 {
9223     char *xcb_tmp = (char *)_buffer;
9224     unsigned int xcb_buffer_len = 0;
9225     unsigned int xcb_block_len = 0;
9226     unsigned int xcb_pad = 0;
9227     unsigned int xcb_align_to = 0;
9228 
9229 
9230     xcb_block_len += sizeof(xcb_poly_fill_rectangle_request_t);
9231     xcb_tmp += xcb_block_len;
9232     xcb_buffer_len += xcb_block_len;
9233     xcb_block_len = 0;
9234     /* rectangles */
9235     xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
9236     xcb_tmp += xcb_block_len;
9237     xcb_align_to = ALIGNOF(xcb_rectangle_t);
9238     /* insert padding */
9239     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9240     xcb_buffer_len += xcb_block_len + xcb_pad;
9241     if (0 != xcb_pad) {
9242         xcb_tmp += xcb_pad;
9243         xcb_pad = 0;
9244     }
9245     xcb_block_len = 0;
9246 
9247     return xcb_buffer_len;
9248 }
9249 
9250 xcb_void_cookie_t
xcb_poly_fill_rectangle_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)9251 xcb_poly_fill_rectangle_checked (xcb_connection_t      *c,
9252                                  xcb_drawable_t         drawable,
9253                                  xcb_gcontext_t         gc,
9254                                  uint32_t               rectangles_len,
9255                                  const xcb_rectangle_t *rectangles)
9256 {
9257     static const xcb_protocol_request_t xcb_req = {
9258         .count = 4,
9259         .ext = 0,
9260         .opcode = XCB_POLY_FILL_RECTANGLE,
9261         .isvoid = 1
9262     };
9263 
9264     struct iovec xcb_parts[6];
9265     xcb_void_cookie_t xcb_ret;
9266     xcb_poly_fill_rectangle_request_t xcb_out;
9267 
9268     xcb_out.pad0 = 0;
9269     xcb_out.drawable = drawable;
9270     xcb_out.gc = gc;
9271 
9272     xcb_parts[2].iov_base = (char *) &xcb_out;
9273     xcb_parts[2].iov_len = sizeof(xcb_out);
9274     xcb_parts[3].iov_base = 0;
9275     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9276     /* xcb_rectangle_t rectangles */
9277     xcb_parts[4].iov_base = (char *) rectangles;
9278     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
9279     xcb_parts[5].iov_base = 0;
9280     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9281 
9282     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9283     return xcb_ret;
9284 }
9285 
9286 xcb_void_cookie_t
xcb_poly_fill_rectangle(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t rectangles_len,const xcb_rectangle_t * rectangles)9287 xcb_poly_fill_rectangle (xcb_connection_t      *c,
9288                          xcb_drawable_t         drawable,
9289                          xcb_gcontext_t         gc,
9290                          uint32_t               rectangles_len,
9291                          const xcb_rectangle_t *rectangles)
9292 {
9293     static const xcb_protocol_request_t xcb_req = {
9294         .count = 4,
9295         .ext = 0,
9296         .opcode = XCB_POLY_FILL_RECTANGLE,
9297         .isvoid = 1
9298     };
9299 
9300     struct iovec xcb_parts[6];
9301     xcb_void_cookie_t xcb_ret;
9302     xcb_poly_fill_rectangle_request_t xcb_out;
9303 
9304     xcb_out.pad0 = 0;
9305     xcb_out.drawable = drawable;
9306     xcb_out.gc = gc;
9307 
9308     xcb_parts[2].iov_base = (char *) &xcb_out;
9309     xcb_parts[2].iov_len = sizeof(xcb_out);
9310     xcb_parts[3].iov_base = 0;
9311     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9312     /* xcb_rectangle_t rectangles */
9313     xcb_parts[4].iov_base = (char *) rectangles;
9314     xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
9315     xcb_parts[5].iov_base = 0;
9316     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9317 
9318     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9319     return xcb_ret;
9320 }
9321 
9322 xcb_rectangle_t *
xcb_poly_fill_rectangle_rectangles(const xcb_poly_fill_rectangle_request_t * R)9323 xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R)
9324 {
9325     return (xcb_rectangle_t *) (R + 1);
9326 }
9327 
9328 int
xcb_poly_fill_rectangle_rectangles_length(const xcb_poly_fill_rectangle_request_t * R)9329 xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R)
9330 {
9331     return (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t));
9332 }
9333 
9334 xcb_rectangle_iterator_t
xcb_poly_fill_rectangle_rectangles_iterator(const xcb_poly_fill_rectangle_request_t * R)9335 xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R)
9336 {
9337     xcb_rectangle_iterator_t i;
9338     i.data = (xcb_rectangle_t *) (R + 1);
9339     i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t));
9340     i.index = (char *) i.data - (char *) R;
9341     return i;
9342 }
9343 
9344 int
xcb_poly_fill_arc_sizeof(const void * _buffer,uint32_t arcs_len)9345 xcb_poly_fill_arc_sizeof (const void  *_buffer,
9346                           uint32_t     arcs_len)
9347 {
9348     char *xcb_tmp = (char *)_buffer;
9349     unsigned int xcb_buffer_len = 0;
9350     unsigned int xcb_block_len = 0;
9351     unsigned int xcb_pad = 0;
9352     unsigned int xcb_align_to = 0;
9353 
9354 
9355     xcb_block_len += sizeof(xcb_poly_fill_arc_request_t);
9356     xcb_tmp += xcb_block_len;
9357     xcb_buffer_len += xcb_block_len;
9358     xcb_block_len = 0;
9359     /* arcs */
9360     xcb_block_len += arcs_len * sizeof(xcb_arc_t);
9361     xcb_tmp += xcb_block_len;
9362     xcb_align_to = ALIGNOF(xcb_arc_t);
9363     /* insert padding */
9364     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9365     xcb_buffer_len += xcb_block_len + xcb_pad;
9366     if (0 != xcb_pad) {
9367         xcb_tmp += xcb_pad;
9368         xcb_pad = 0;
9369     }
9370     xcb_block_len = 0;
9371 
9372     return xcb_buffer_len;
9373 }
9374 
9375 xcb_void_cookie_t
xcb_poly_fill_arc_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t arcs_len,const xcb_arc_t * arcs)9376 xcb_poly_fill_arc_checked (xcb_connection_t *c,
9377                            xcb_drawable_t    drawable,
9378                            xcb_gcontext_t    gc,
9379                            uint32_t          arcs_len,
9380                            const xcb_arc_t  *arcs)
9381 {
9382     static const xcb_protocol_request_t xcb_req = {
9383         .count = 4,
9384         .ext = 0,
9385         .opcode = XCB_POLY_FILL_ARC,
9386         .isvoid = 1
9387     };
9388 
9389     struct iovec xcb_parts[6];
9390     xcb_void_cookie_t xcb_ret;
9391     xcb_poly_fill_arc_request_t xcb_out;
9392 
9393     xcb_out.pad0 = 0;
9394     xcb_out.drawable = drawable;
9395     xcb_out.gc = gc;
9396 
9397     xcb_parts[2].iov_base = (char *) &xcb_out;
9398     xcb_parts[2].iov_len = sizeof(xcb_out);
9399     xcb_parts[3].iov_base = 0;
9400     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9401     /* xcb_arc_t arcs */
9402     xcb_parts[4].iov_base = (char *) arcs;
9403     xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
9404     xcb_parts[5].iov_base = 0;
9405     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9406 
9407     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9408     return xcb_ret;
9409 }
9410 
9411 xcb_void_cookie_t
xcb_poly_fill_arc(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t arcs_len,const xcb_arc_t * arcs)9412 xcb_poly_fill_arc (xcb_connection_t *c,
9413                    xcb_drawable_t    drawable,
9414                    xcb_gcontext_t    gc,
9415                    uint32_t          arcs_len,
9416                    const xcb_arc_t  *arcs)
9417 {
9418     static const xcb_protocol_request_t xcb_req = {
9419         .count = 4,
9420         .ext = 0,
9421         .opcode = XCB_POLY_FILL_ARC,
9422         .isvoid = 1
9423     };
9424 
9425     struct iovec xcb_parts[6];
9426     xcb_void_cookie_t xcb_ret;
9427     xcb_poly_fill_arc_request_t xcb_out;
9428 
9429     xcb_out.pad0 = 0;
9430     xcb_out.drawable = drawable;
9431     xcb_out.gc = gc;
9432 
9433     xcb_parts[2].iov_base = (char *) &xcb_out;
9434     xcb_parts[2].iov_len = sizeof(xcb_out);
9435     xcb_parts[3].iov_base = 0;
9436     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9437     /* xcb_arc_t arcs */
9438     xcb_parts[4].iov_base = (char *) arcs;
9439     xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
9440     xcb_parts[5].iov_base = 0;
9441     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9442 
9443     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9444     return xcb_ret;
9445 }
9446 
9447 xcb_arc_t *
xcb_poly_fill_arc_arcs(const xcb_poly_fill_arc_request_t * R)9448 xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R)
9449 {
9450     return (xcb_arc_t *) (R + 1);
9451 }
9452 
9453 int
xcb_poly_fill_arc_arcs_length(const xcb_poly_fill_arc_request_t * R)9454 xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R)
9455 {
9456     return (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t));
9457 }
9458 
9459 xcb_arc_iterator_t
xcb_poly_fill_arc_arcs_iterator(const xcb_poly_fill_arc_request_t * R)9460 xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R)
9461 {
9462     xcb_arc_iterator_t i;
9463     i.data = (xcb_arc_t *) (R + 1);
9464     i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t));
9465     i.index = (char *) i.data - (char *) R;
9466     return i;
9467 }
9468 
9469 int
xcb_put_image_sizeof(const void * _buffer,uint32_t data_len)9470 xcb_put_image_sizeof (const void  *_buffer,
9471                       uint32_t     data_len)
9472 {
9473     char *xcb_tmp = (char *)_buffer;
9474     unsigned int xcb_buffer_len = 0;
9475     unsigned int xcb_block_len = 0;
9476     unsigned int xcb_pad = 0;
9477     unsigned int xcb_align_to = 0;
9478 
9479 
9480     xcb_block_len += sizeof(xcb_put_image_request_t);
9481     xcb_tmp += xcb_block_len;
9482     xcb_buffer_len += xcb_block_len;
9483     xcb_block_len = 0;
9484     /* data */
9485     xcb_block_len += data_len * sizeof(uint8_t);
9486     xcb_tmp += xcb_block_len;
9487     xcb_align_to = ALIGNOF(uint8_t);
9488     /* insert padding */
9489     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9490     xcb_buffer_len += xcb_block_len + xcb_pad;
9491     if (0 != xcb_pad) {
9492         xcb_tmp += xcb_pad;
9493         xcb_pad = 0;
9494     }
9495     xcb_block_len = 0;
9496 
9497     return xcb_buffer_len;
9498 }
9499 
9500 xcb_void_cookie_t
xcb_put_image_checked(xcb_connection_t * c,uint8_t format,xcb_drawable_t drawable,xcb_gcontext_t gc,uint16_t width,uint16_t height,int16_t dst_x,int16_t dst_y,uint8_t left_pad,uint8_t depth,uint32_t data_len,const uint8_t * data)9501 xcb_put_image_checked (xcb_connection_t *c,
9502                        uint8_t           format,
9503                        xcb_drawable_t    drawable,
9504                        xcb_gcontext_t    gc,
9505                        uint16_t          width,
9506                        uint16_t          height,
9507                        int16_t           dst_x,
9508                        int16_t           dst_y,
9509                        uint8_t           left_pad,
9510                        uint8_t           depth,
9511                        uint32_t          data_len,
9512                        const uint8_t    *data)
9513 {
9514     static const xcb_protocol_request_t xcb_req = {
9515         .count = 4,
9516         .ext = 0,
9517         .opcode = XCB_PUT_IMAGE,
9518         .isvoid = 1
9519     };
9520 
9521     struct iovec xcb_parts[6];
9522     xcb_void_cookie_t xcb_ret;
9523     xcb_put_image_request_t xcb_out;
9524 
9525     xcb_out.format = format;
9526     xcb_out.drawable = drawable;
9527     xcb_out.gc = gc;
9528     xcb_out.width = width;
9529     xcb_out.height = height;
9530     xcb_out.dst_x = dst_x;
9531     xcb_out.dst_y = dst_y;
9532     xcb_out.left_pad = left_pad;
9533     xcb_out.depth = depth;
9534     memset(xcb_out.pad0, 0, 2);
9535 
9536     xcb_parts[2].iov_base = (char *) &xcb_out;
9537     xcb_parts[2].iov_len = sizeof(xcb_out);
9538     xcb_parts[3].iov_base = 0;
9539     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9540     /* uint8_t data */
9541     xcb_parts[4].iov_base = (char *) data;
9542     xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
9543     xcb_parts[5].iov_base = 0;
9544     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9545 
9546     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9547     return xcb_ret;
9548 }
9549 
9550 xcb_void_cookie_t
xcb_put_image(xcb_connection_t * c,uint8_t format,xcb_drawable_t drawable,xcb_gcontext_t gc,uint16_t width,uint16_t height,int16_t dst_x,int16_t dst_y,uint8_t left_pad,uint8_t depth,uint32_t data_len,const uint8_t * data)9551 xcb_put_image (xcb_connection_t *c,
9552                uint8_t           format,
9553                xcb_drawable_t    drawable,
9554                xcb_gcontext_t    gc,
9555                uint16_t          width,
9556                uint16_t          height,
9557                int16_t           dst_x,
9558                int16_t           dst_y,
9559                uint8_t           left_pad,
9560                uint8_t           depth,
9561                uint32_t          data_len,
9562                const uint8_t    *data)
9563 {
9564     static const xcb_protocol_request_t xcb_req = {
9565         .count = 4,
9566         .ext = 0,
9567         .opcode = XCB_PUT_IMAGE,
9568         .isvoid = 1
9569     };
9570 
9571     struct iovec xcb_parts[6];
9572     xcb_void_cookie_t xcb_ret;
9573     xcb_put_image_request_t xcb_out;
9574 
9575     xcb_out.format = format;
9576     xcb_out.drawable = drawable;
9577     xcb_out.gc = gc;
9578     xcb_out.width = width;
9579     xcb_out.height = height;
9580     xcb_out.dst_x = dst_x;
9581     xcb_out.dst_y = dst_y;
9582     xcb_out.left_pad = left_pad;
9583     xcb_out.depth = depth;
9584     memset(xcb_out.pad0, 0, 2);
9585 
9586     xcb_parts[2].iov_base = (char *) &xcb_out;
9587     xcb_parts[2].iov_len = sizeof(xcb_out);
9588     xcb_parts[3].iov_base = 0;
9589     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9590     /* uint8_t data */
9591     xcb_parts[4].iov_base = (char *) data;
9592     xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
9593     xcb_parts[5].iov_base = 0;
9594     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9595 
9596     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9597     return xcb_ret;
9598 }
9599 
9600 uint8_t *
xcb_put_image_data(const xcb_put_image_request_t * R)9601 xcb_put_image_data (const xcb_put_image_request_t *R)
9602 {
9603     return (uint8_t *) (R + 1);
9604 }
9605 
9606 int
xcb_put_image_data_length(const xcb_put_image_request_t * R)9607 xcb_put_image_data_length (const xcb_put_image_request_t *R)
9608 {
9609     return (((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t));
9610 }
9611 
9612 xcb_generic_iterator_t
xcb_put_image_data_end(const xcb_put_image_request_t * R)9613 xcb_put_image_data_end (const xcb_put_image_request_t *R)
9614 {
9615     xcb_generic_iterator_t i;
9616     i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t)));
9617     i.rem = 0;
9618     i.index = (char *) i.data - (char *) R;
9619     return i;
9620 }
9621 
9622 int
xcb_get_image_sizeof(const void * _buffer)9623 xcb_get_image_sizeof (const void  *_buffer)
9624 {
9625     char *xcb_tmp = (char *)_buffer;
9626     const xcb_get_image_reply_t *_aux = (xcb_get_image_reply_t *)_buffer;
9627     unsigned int xcb_buffer_len = 0;
9628     unsigned int xcb_block_len = 0;
9629     unsigned int xcb_pad = 0;
9630     unsigned int xcb_align_to = 0;
9631 
9632 
9633     xcb_block_len += sizeof(xcb_get_image_reply_t);
9634     xcb_tmp += xcb_block_len;
9635     xcb_buffer_len += xcb_block_len;
9636     xcb_block_len = 0;
9637     /* data */
9638     xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
9639     xcb_tmp += xcb_block_len;
9640     xcb_align_to = ALIGNOF(uint8_t);
9641     /* insert padding */
9642     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9643     xcb_buffer_len += xcb_block_len + xcb_pad;
9644     if (0 != xcb_pad) {
9645         xcb_tmp += xcb_pad;
9646         xcb_pad = 0;
9647     }
9648     xcb_block_len = 0;
9649 
9650     return xcb_buffer_len;
9651 }
9652 
9653 xcb_get_image_cookie_t
xcb_get_image(xcb_connection_t * c,uint8_t format,xcb_drawable_t drawable,int16_t x,int16_t y,uint16_t width,uint16_t height,uint32_t plane_mask)9654 xcb_get_image (xcb_connection_t *c,
9655                uint8_t           format,
9656                xcb_drawable_t    drawable,
9657                int16_t           x,
9658                int16_t           y,
9659                uint16_t          width,
9660                uint16_t          height,
9661                uint32_t          plane_mask)
9662 {
9663     static const xcb_protocol_request_t xcb_req = {
9664         .count = 2,
9665         .ext = 0,
9666         .opcode = XCB_GET_IMAGE,
9667         .isvoid = 0
9668     };
9669 
9670     struct iovec xcb_parts[4];
9671     xcb_get_image_cookie_t xcb_ret;
9672     xcb_get_image_request_t xcb_out;
9673 
9674     xcb_out.format = format;
9675     xcb_out.drawable = drawable;
9676     xcb_out.x = x;
9677     xcb_out.y = y;
9678     xcb_out.width = width;
9679     xcb_out.height = height;
9680     xcb_out.plane_mask = plane_mask;
9681 
9682     xcb_parts[2].iov_base = (char *) &xcb_out;
9683     xcb_parts[2].iov_len = sizeof(xcb_out);
9684     xcb_parts[3].iov_base = 0;
9685     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9686 
9687     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9688     return xcb_ret;
9689 }
9690 
9691 xcb_get_image_cookie_t
xcb_get_image_unchecked(xcb_connection_t * c,uint8_t format,xcb_drawable_t drawable,int16_t x,int16_t y,uint16_t width,uint16_t height,uint32_t plane_mask)9692 xcb_get_image_unchecked (xcb_connection_t *c,
9693                          uint8_t           format,
9694                          xcb_drawable_t    drawable,
9695                          int16_t           x,
9696                          int16_t           y,
9697                          uint16_t          width,
9698                          uint16_t          height,
9699                          uint32_t          plane_mask)
9700 {
9701     static const xcb_protocol_request_t xcb_req = {
9702         .count = 2,
9703         .ext = 0,
9704         .opcode = XCB_GET_IMAGE,
9705         .isvoid = 0
9706     };
9707 
9708     struct iovec xcb_parts[4];
9709     xcb_get_image_cookie_t xcb_ret;
9710     xcb_get_image_request_t xcb_out;
9711 
9712     xcb_out.format = format;
9713     xcb_out.drawable = drawable;
9714     xcb_out.x = x;
9715     xcb_out.y = y;
9716     xcb_out.width = width;
9717     xcb_out.height = height;
9718     xcb_out.plane_mask = plane_mask;
9719 
9720     xcb_parts[2].iov_base = (char *) &xcb_out;
9721     xcb_parts[2].iov_len = sizeof(xcb_out);
9722     xcb_parts[3].iov_base = 0;
9723     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9724 
9725     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9726     return xcb_ret;
9727 }
9728 
9729 uint8_t *
xcb_get_image_data(const xcb_get_image_reply_t * R)9730 xcb_get_image_data (const xcb_get_image_reply_t *R)
9731 {
9732     return (uint8_t *) (R + 1);
9733 }
9734 
9735 int
xcb_get_image_data_length(const xcb_get_image_reply_t * R)9736 xcb_get_image_data_length (const xcb_get_image_reply_t *R)
9737 {
9738     return (R->length * 4);
9739 }
9740 
9741 xcb_generic_iterator_t
xcb_get_image_data_end(const xcb_get_image_reply_t * R)9742 xcb_get_image_data_end (const xcb_get_image_reply_t *R)
9743 {
9744     xcb_generic_iterator_t i;
9745     i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
9746     i.rem = 0;
9747     i.index = (char *) i.data - (char *) R;
9748     return i;
9749 }
9750 
9751 xcb_get_image_reply_t *
xcb_get_image_reply(xcb_connection_t * c,xcb_get_image_cookie_t cookie,xcb_generic_error_t ** e)9752 xcb_get_image_reply (xcb_connection_t        *c,
9753                      xcb_get_image_cookie_t   cookie  /**< */,
9754                      xcb_generic_error_t    **e)
9755 {
9756     return (xcb_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
9757 }
9758 
9759 int
xcb_poly_text_8_sizeof(const void * _buffer,uint32_t items_len)9760 xcb_poly_text_8_sizeof (const void  *_buffer,
9761                         uint32_t     items_len)
9762 {
9763     char *xcb_tmp = (char *)_buffer;
9764     unsigned int xcb_buffer_len = 0;
9765     unsigned int xcb_block_len = 0;
9766     unsigned int xcb_pad = 0;
9767     unsigned int xcb_align_to = 0;
9768 
9769 
9770     xcb_block_len += sizeof(xcb_poly_text_8_request_t);
9771     xcb_tmp += xcb_block_len;
9772     xcb_buffer_len += xcb_block_len;
9773     xcb_block_len = 0;
9774     /* items */
9775     xcb_block_len += items_len * sizeof(uint8_t);
9776     xcb_tmp += xcb_block_len;
9777     xcb_align_to = ALIGNOF(uint8_t);
9778     /* insert padding */
9779     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9780     xcb_buffer_len += xcb_block_len + xcb_pad;
9781     if (0 != xcb_pad) {
9782         xcb_tmp += xcb_pad;
9783         xcb_pad = 0;
9784     }
9785     xcb_block_len = 0;
9786 
9787     return xcb_buffer_len;
9788 }
9789 
9790 xcb_void_cookie_t
xcb_poly_text_8_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,uint32_t items_len,const uint8_t * items)9791 xcb_poly_text_8_checked (xcb_connection_t *c,
9792                          xcb_drawable_t    drawable,
9793                          xcb_gcontext_t    gc,
9794                          int16_t           x,
9795                          int16_t           y,
9796                          uint32_t          items_len,
9797                          const uint8_t    *items)
9798 {
9799     static const xcb_protocol_request_t xcb_req = {
9800         .count = 4,
9801         .ext = 0,
9802         .opcode = XCB_POLY_TEXT_8,
9803         .isvoid = 1
9804     };
9805 
9806     struct iovec xcb_parts[6];
9807     xcb_void_cookie_t xcb_ret;
9808     xcb_poly_text_8_request_t xcb_out;
9809 
9810     xcb_out.pad0 = 0;
9811     xcb_out.drawable = drawable;
9812     xcb_out.gc = gc;
9813     xcb_out.x = x;
9814     xcb_out.y = y;
9815 
9816     xcb_parts[2].iov_base = (char *) &xcb_out;
9817     xcb_parts[2].iov_len = sizeof(xcb_out);
9818     xcb_parts[3].iov_base = 0;
9819     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9820     /* uint8_t items */
9821     xcb_parts[4].iov_base = (char *) items;
9822     xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
9823     xcb_parts[5].iov_base = 0;
9824     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9825 
9826     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9827     return xcb_ret;
9828 }
9829 
9830 xcb_void_cookie_t
xcb_poly_text_8(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,uint32_t items_len,const uint8_t * items)9831 xcb_poly_text_8 (xcb_connection_t *c,
9832                  xcb_drawable_t    drawable,
9833                  xcb_gcontext_t    gc,
9834                  int16_t           x,
9835                  int16_t           y,
9836                  uint32_t          items_len,
9837                  const uint8_t    *items)
9838 {
9839     static const xcb_protocol_request_t xcb_req = {
9840         .count = 4,
9841         .ext = 0,
9842         .opcode = XCB_POLY_TEXT_8,
9843         .isvoid = 1
9844     };
9845 
9846     struct iovec xcb_parts[6];
9847     xcb_void_cookie_t xcb_ret;
9848     xcb_poly_text_8_request_t xcb_out;
9849 
9850     xcb_out.pad0 = 0;
9851     xcb_out.drawable = drawable;
9852     xcb_out.gc = gc;
9853     xcb_out.x = x;
9854     xcb_out.y = y;
9855 
9856     xcb_parts[2].iov_base = (char *) &xcb_out;
9857     xcb_parts[2].iov_len = sizeof(xcb_out);
9858     xcb_parts[3].iov_base = 0;
9859     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9860     /* uint8_t items */
9861     xcb_parts[4].iov_base = (char *) items;
9862     xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
9863     xcb_parts[5].iov_base = 0;
9864     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9865 
9866     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9867     return xcb_ret;
9868 }
9869 
9870 uint8_t *
xcb_poly_text_8_items(const xcb_poly_text_8_request_t * R)9871 xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R)
9872 {
9873     return (uint8_t *) (R + 1);
9874 }
9875 
9876 int
xcb_poly_text_8_items_length(const xcb_poly_text_8_request_t * R)9877 xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R)
9878 {
9879     return (((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t));
9880 }
9881 
9882 xcb_generic_iterator_t
xcb_poly_text_8_items_end(const xcb_poly_text_8_request_t * R)9883 xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R)
9884 {
9885     xcb_generic_iterator_t i;
9886     i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t)));
9887     i.rem = 0;
9888     i.index = (char *) i.data - (char *) R;
9889     return i;
9890 }
9891 
9892 int
xcb_poly_text_16_sizeof(const void * _buffer,uint32_t items_len)9893 xcb_poly_text_16_sizeof (const void  *_buffer,
9894                          uint32_t     items_len)
9895 {
9896     char *xcb_tmp = (char *)_buffer;
9897     unsigned int xcb_buffer_len = 0;
9898     unsigned int xcb_block_len = 0;
9899     unsigned int xcb_pad = 0;
9900     unsigned int xcb_align_to = 0;
9901 
9902 
9903     xcb_block_len += sizeof(xcb_poly_text_16_request_t);
9904     xcb_tmp += xcb_block_len;
9905     xcb_buffer_len += xcb_block_len;
9906     xcb_block_len = 0;
9907     /* items */
9908     xcb_block_len += items_len * sizeof(uint8_t);
9909     xcb_tmp += xcb_block_len;
9910     xcb_align_to = ALIGNOF(uint8_t);
9911     /* insert padding */
9912     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9913     xcb_buffer_len += xcb_block_len + xcb_pad;
9914     if (0 != xcb_pad) {
9915         xcb_tmp += xcb_pad;
9916         xcb_pad = 0;
9917     }
9918     xcb_block_len = 0;
9919 
9920     return xcb_buffer_len;
9921 }
9922 
9923 xcb_void_cookie_t
xcb_poly_text_16_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,uint32_t items_len,const uint8_t * items)9924 xcb_poly_text_16_checked (xcb_connection_t *c,
9925                           xcb_drawable_t    drawable,
9926                           xcb_gcontext_t    gc,
9927                           int16_t           x,
9928                           int16_t           y,
9929                           uint32_t          items_len,
9930                           const uint8_t    *items)
9931 {
9932     static const xcb_protocol_request_t xcb_req = {
9933         .count = 4,
9934         .ext = 0,
9935         .opcode = XCB_POLY_TEXT_16,
9936         .isvoid = 1
9937     };
9938 
9939     struct iovec xcb_parts[6];
9940     xcb_void_cookie_t xcb_ret;
9941     xcb_poly_text_16_request_t xcb_out;
9942 
9943     xcb_out.pad0 = 0;
9944     xcb_out.drawable = drawable;
9945     xcb_out.gc = gc;
9946     xcb_out.x = x;
9947     xcb_out.y = y;
9948 
9949     xcb_parts[2].iov_base = (char *) &xcb_out;
9950     xcb_parts[2].iov_len = sizeof(xcb_out);
9951     xcb_parts[3].iov_base = 0;
9952     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9953     /* uint8_t items */
9954     xcb_parts[4].iov_base = (char *) items;
9955     xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
9956     xcb_parts[5].iov_base = 0;
9957     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9958 
9959     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9960     return xcb_ret;
9961 }
9962 
9963 xcb_void_cookie_t
xcb_poly_text_16(xcb_connection_t * c,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,uint32_t items_len,const uint8_t * items)9964 xcb_poly_text_16 (xcb_connection_t *c,
9965                   xcb_drawable_t    drawable,
9966                   xcb_gcontext_t    gc,
9967                   int16_t           x,
9968                   int16_t           y,
9969                   uint32_t          items_len,
9970                   const uint8_t    *items)
9971 {
9972     static const xcb_protocol_request_t xcb_req = {
9973         .count = 4,
9974         .ext = 0,
9975         .opcode = XCB_POLY_TEXT_16,
9976         .isvoid = 1
9977     };
9978 
9979     struct iovec xcb_parts[6];
9980     xcb_void_cookie_t xcb_ret;
9981     xcb_poly_text_16_request_t xcb_out;
9982 
9983     xcb_out.pad0 = 0;
9984     xcb_out.drawable = drawable;
9985     xcb_out.gc = gc;
9986     xcb_out.x = x;
9987     xcb_out.y = y;
9988 
9989     xcb_parts[2].iov_base = (char *) &xcb_out;
9990     xcb_parts[2].iov_len = sizeof(xcb_out);
9991     xcb_parts[3].iov_base = 0;
9992     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9993     /* uint8_t items */
9994     xcb_parts[4].iov_base = (char *) items;
9995     xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
9996     xcb_parts[5].iov_base = 0;
9997     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9998 
9999     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10000     return xcb_ret;
10001 }
10002 
10003 uint8_t *
xcb_poly_text_16_items(const xcb_poly_text_16_request_t * R)10004 xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R)
10005 {
10006     return (uint8_t *) (R + 1);
10007 }
10008 
10009 int
xcb_poly_text_16_items_length(const xcb_poly_text_16_request_t * R)10010 xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R)
10011 {
10012     return (((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t));
10013 }
10014 
10015 xcb_generic_iterator_t
xcb_poly_text_16_items_end(const xcb_poly_text_16_request_t * R)10016 xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R)
10017 {
10018     xcb_generic_iterator_t i;
10019     i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t)));
10020     i.rem = 0;
10021     i.index = (char *) i.data - (char *) R;
10022     return i;
10023 }
10024 
10025 int
xcb_image_text_8_sizeof(const void * _buffer)10026 xcb_image_text_8_sizeof (const void  *_buffer)
10027 {
10028     char *xcb_tmp = (char *)_buffer;
10029     const xcb_image_text_8_request_t *_aux = (xcb_image_text_8_request_t *)_buffer;
10030     unsigned int xcb_buffer_len = 0;
10031     unsigned int xcb_block_len = 0;
10032     unsigned int xcb_pad = 0;
10033     unsigned int xcb_align_to = 0;
10034 
10035 
10036     xcb_block_len += sizeof(xcb_image_text_8_request_t);
10037     xcb_tmp += xcb_block_len;
10038     xcb_buffer_len += xcb_block_len;
10039     xcb_block_len = 0;
10040     /* string */
10041     xcb_block_len += _aux->string_len * sizeof(char);
10042     xcb_tmp += xcb_block_len;
10043     xcb_align_to = ALIGNOF(char);
10044     /* insert padding */
10045     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10046     xcb_buffer_len += xcb_block_len + xcb_pad;
10047     if (0 != xcb_pad) {
10048         xcb_tmp += xcb_pad;
10049         xcb_pad = 0;
10050     }
10051     xcb_block_len = 0;
10052 
10053     return xcb_buffer_len;
10054 }
10055 
10056 xcb_void_cookie_t
xcb_image_text_8_checked(xcb_connection_t * c,uint8_t string_len,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,const char * string)10057 xcb_image_text_8_checked (xcb_connection_t *c,
10058                           uint8_t           string_len,
10059                           xcb_drawable_t    drawable,
10060                           xcb_gcontext_t    gc,
10061                           int16_t           x,
10062                           int16_t           y,
10063                           const char       *string)
10064 {
10065     static const xcb_protocol_request_t xcb_req = {
10066         .count = 4,
10067         .ext = 0,
10068         .opcode = XCB_IMAGE_TEXT_8,
10069         .isvoid = 1
10070     };
10071 
10072     struct iovec xcb_parts[6];
10073     xcb_void_cookie_t xcb_ret;
10074     xcb_image_text_8_request_t xcb_out;
10075 
10076     xcb_out.string_len = string_len;
10077     xcb_out.drawable = drawable;
10078     xcb_out.gc = gc;
10079     xcb_out.x = x;
10080     xcb_out.y = y;
10081 
10082     xcb_parts[2].iov_base = (char *) &xcb_out;
10083     xcb_parts[2].iov_len = sizeof(xcb_out);
10084     xcb_parts[3].iov_base = 0;
10085     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10086     /* char string */
10087     xcb_parts[4].iov_base = (char *) string;
10088     xcb_parts[4].iov_len = string_len * sizeof(char);
10089     xcb_parts[5].iov_base = 0;
10090     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10091 
10092     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10093     return xcb_ret;
10094 }
10095 
10096 xcb_void_cookie_t
xcb_image_text_8(xcb_connection_t * c,uint8_t string_len,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,const char * string)10097 xcb_image_text_8 (xcb_connection_t *c,
10098                   uint8_t           string_len,
10099                   xcb_drawable_t    drawable,
10100                   xcb_gcontext_t    gc,
10101                   int16_t           x,
10102                   int16_t           y,
10103                   const char       *string)
10104 {
10105     static const xcb_protocol_request_t xcb_req = {
10106         .count = 4,
10107         .ext = 0,
10108         .opcode = XCB_IMAGE_TEXT_8,
10109         .isvoid = 1
10110     };
10111 
10112     struct iovec xcb_parts[6];
10113     xcb_void_cookie_t xcb_ret;
10114     xcb_image_text_8_request_t xcb_out;
10115 
10116     xcb_out.string_len = string_len;
10117     xcb_out.drawable = drawable;
10118     xcb_out.gc = gc;
10119     xcb_out.x = x;
10120     xcb_out.y = y;
10121 
10122     xcb_parts[2].iov_base = (char *) &xcb_out;
10123     xcb_parts[2].iov_len = sizeof(xcb_out);
10124     xcb_parts[3].iov_base = 0;
10125     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10126     /* char string */
10127     xcb_parts[4].iov_base = (char *) string;
10128     xcb_parts[4].iov_len = string_len * sizeof(char);
10129     xcb_parts[5].iov_base = 0;
10130     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10131 
10132     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10133     return xcb_ret;
10134 }
10135 
10136 char *
xcb_image_text_8_string(const xcb_image_text_8_request_t * R)10137 xcb_image_text_8_string (const xcb_image_text_8_request_t *R)
10138 {
10139     return (char *) (R + 1);
10140 }
10141 
10142 int
xcb_image_text_8_string_length(const xcb_image_text_8_request_t * R)10143 xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R)
10144 {
10145     return R->string_len;
10146 }
10147 
10148 xcb_generic_iterator_t
xcb_image_text_8_string_end(const xcb_image_text_8_request_t * R)10149 xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R)
10150 {
10151     xcb_generic_iterator_t i;
10152     i.data = ((char *) (R + 1)) + (R->string_len);
10153     i.rem = 0;
10154     i.index = (char *) i.data - (char *) R;
10155     return i;
10156 }
10157 
10158 int
xcb_image_text_16_sizeof(const void * _buffer)10159 xcb_image_text_16_sizeof (const void  *_buffer)
10160 {
10161     char *xcb_tmp = (char *)_buffer;
10162     const xcb_image_text_16_request_t *_aux = (xcb_image_text_16_request_t *)_buffer;
10163     unsigned int xcb_buffer_len = 0;
10164     unsigned int xcb_block_len = 0;
10165     unsigned int xcb_pad = 0;
10166     unsigned int xcb_align_to = 0;
10167 
10168 
10169     xcb_block_len += sizeof(xcb_image_text_16_request_t);
10170     xcb_tmp += xcb_block_len;
10171     xcb_buffer_len += xcb_block_len;
10172     xcb_block_len = 0;
10173     /* string */
10174     xcb_block_len += _aux->string_len * sizeof(xcb_char2b_t);
10175     xcb_tmp += xcb_block_len;
10176     xcb_align_to = ALIGNOF(xcb_char2b_t);
10177     /* insert padding */
10178     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10179     xcb_buffer_len += xcb_block_len + xcb_pad;
10180     if (0 != xcb_pad) {
10181         xcb_tmp += xcb_pad;
10182         xcb_pad = 0;
10183     }
10184     xcb_block_len = 0;
10185 
10186     return xcb_buffer_len;
10187 }
10188 
10189 xcb_void_cookie_t
xcb_image_text_16_checked(xcb_connection_t * c,uint8_t string_len,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,const xcb_char2b_t * string)10190 xcb_image_text_16_checked (xcb_connection_t   *c,
10191                            uint8_t             string_len,
10192                            xcb_drawable_t      drawable,
10193                            xcb_gcontext_t      gc,
10194                            int16_t             x,
10195                            int16_t             y,
10196                            const xcb_char2b_t *string)
10197 {
10198     static const xcb_protocol_request_t xcb_req = {
10199         .count = 4,
10200         .ext = 0,
10201         .opcode = XCB_IMAGE_TEXT_16,
10202         .isvoid = 1
10203     };
10204 
10205     struct iovec xcb_parts[6];
10206     xcb_void_cookie_t xcb_ret;
10207     xcb_image_text_16_request_t xcb_out;
10208 
10209     xcb_out.string_len = string_len;
10210     xcb_out.drawable = drawable;
10211     xcb_out.gc = gc;
10212     xcb_out.x = x;
10213     xcb_out.y = y;
10214 
10215     xcb_parts[2].iov_base = (char *) &xcb_out;
10216     xcb_parts[2].iov_len = sizeof(xcb_out);
10217     xcb_parts[3].iov_base = 0;
10218     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10219     /* xcb_char2b_t string */
10220     xcb_parts[4].iov_base = (char *) string;
10221     xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
10222     xcb_parts[5].iov_base = 0;
10223     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10224 
10225     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10226     return xcb_ret;
10227 }
10228 
10229 xcb_void_cookie_t
xcb_image_text_16(xcb_connection_t * c,uint8_t string_len,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t x,int16_t y,const xcb_char2b_t * string)10230 xcb_image_text_16 (xcb_connection_t   *c,
10231                    uint8_t             string_len,
10232                    xcb_drawable_t      drawable,
10233                    xcb_gcontext_t      gc,
10234                    int16_t             x,
10235                    int16_t             y,
10236                    const xcb_char2b_t *string)
10237 {
10238     static const xcb_protocol_request_t xcb_req = {
10239         .count = 4,
10240         .ext = 0,
10241         .opcode = XCB_IMAGE_TEXT_16,
10242         .isvoid = 1
10243     };
10244 
10245     struct iovec xcb_parts[6];
10246     xcb_void_cookie_t xcb_ret;
10247     xcb_image_text_16_request_t xcb_out;
10248 
10249     xcb_out.string_len = string_len;
10250     xcb_out.drawable = drawable;
10251     xcb_out.gc = gc;
10252     xcb_out.x = x;
10253     xcb_out.y = y;
10254 
10255     xcb_parts[2].iov_base = (char *) &xcb_out;
10256     xcb_parts[2].iov_len = sizeof(xcb_out);
10257     xcb_parts[3].iov_base = 0;
10258     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10259     /* xcb_char2b_t string */
10260     xcb_parts[4].iov_base = (char *) string;
10261     xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
10262     xcb_parts[5].iov_base = 0;
10263     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10264 
10265     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10266     return xcb_ret;
10267 }
10268 
10269 xcb_char2b_t *
xcb_image_text_16_string(const xcb_image_text_16_request_t * R)10270 xcb_image_text_16_string (const xcb_image_text_16_request_t *R)
10271 {
10272     return (xcb_char2b_t *) (R + 1);
10273 }
10274 
10275 int
xcb_image_text_16_string_length(const xcb_image_text_16_request_t * R)10276 xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R)
10277 {
10278     return R->string_len;
10279 }
10280 
10281 xcb_char2b_iterator_t
xcb_image_text_16_string_iterator(const xcb_image_text_16_request_t * R)10282 xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R)
10283 {
10284     xcb_char2b_iterator_t i;
10285     i.data = (xcb_char2b_t *) (R + 1);
10286     i.rem = R->string_len;
10287     i.index = (char *) i.data - (char *) R;
10288     return i;
10289 }
10290 
10291 xcb_void_cookie_t
xcb_create_colormap_checked(xcb_connection_t * c,uint8_t alloc,xcb_colormap_t mid,xcb_window_t window,xcb_visualid_t visual)10292 xcb_create_colormap_checked (xcb_connection_t *c,
10293                              uint8_t           alloc,
10294                              xcb_colormap_t    mid,
10295                              xcb_window_t      window,
10296                              xcb_visualid_t    visual)
10297 {
10298     static const xcb_protocol_request_t xcb_req = {
10299         .count = 2,
10300         .ext = 0,
10301         .opcode = XCB_CREATE_COLORMAP,
10302         .isvoid = 1
10303     };
10304 
10305     struct iovec xcb_parts[4];
10306     xcb_void_cookie_t xcb_ret;
10307     xcb_create_colormap_request_t xcb_out;
10308 
10309     xcb_out.alloc = alloc;
10310     xcb_out.mid = mid;
10311     xcb_out.window = window;
10312     xcb_out.visual = visual;
10313 
10314     xcb_parts[2].iov_base = (char *) &xcb_out;
10315     xcb_parts[2].iov_len = sizeof(xcb_out);
10316     xcb_parts[3].iov_base = 0;
10317     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10318 
10319     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10320     return xcb_ret;
10321 }
10322 
10323 xcb_void_cookie_t
xcb_create_colormap(xcb_connection_t * c,uint8_t alloc,xcb_colormap_t mid,xcb_window_t window,xcb_visualid_t visual)10324 xcb_create_colormap (xcb_connection_t *c,
10325                      uint8_t           alloc,
10326                      xcb_colormap_t    mid,
10327                      xcb_window_t      window,
10328                      xcb_visualid_t    visual)
10329 {
10330     static const xcb_protocol_request_t xcb_req = {
10331         .count = 2,
10332         .ext = 0,
10333         .opcode = XCB_CREATE_COLORMAP,
10334         .isvoid = 1
10335     };
10336 
10337     struct iovec xcb_parts[4];
10338     xcb_void_cookie_t xcb_ret;
10339     xcb_create_colormap_request_t xcb_out;
10340 
10341     xcb_out.alloc = alloc;
10342     xcb_out.mid = mid;
10343     xcb_out.window = window;
10344     xcb_out.visual = visual;
10345 
10346     xcb_parts[2].iov_base = (char *) &xcb_out;
10347     xcb_parts[2].iov_len = sizeof(xcb_out);
10348     xcb_parts[3].iov_base = 0;
10349     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10350 
10351     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10352     return xcb_ret;
10353 }
10354 
10355 xcb_void_cookie_t
xcb_free_colormap_checked(xcb_connection_t * c,xcb_colormap_t cmap)10356 xcb_free_colormap_checked (xcb_connection_t *c,
10357                            xcb_colormap_t    cmap)
10358 {
10359     static const xcb_protocol_request_t xcb_req = {
10360         .count = 2,
10361         .ext = 0,
10362         .opcode = XCB_FREE_COLORMAP,
10363         .isvoid = 1
10364     };
10365 
10366     struct iovec xcb_parts[4];
10367     xcb_void_cookie_t xcb_ret;
10368     xcb_free_colormap_request_t xcb_out;
10369 
10370     xcb_out.pad0 = 0;
10371     xcb_out.cmap = cmap;
10372 
10373     xcb_parts[2].iov_base = (char *) &xcb_out;
10374     xcb_parts[2].iov_len = sizeof(xcb_out);
10375     xcb_parts[3].iov_base = 0;
10376     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10377 
10378     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10379     return xcb_ret;
10380 }
10381 
10382 xcb_void_cookie_t
xcb_free_colormap(xcb_connection_t * c,xcb_colormap_t cmap)10383 xcb_free_colormap (xcb_connection_t *c,
10384                    xcb_colormap_t    cmap)
10385 {
10386     static const xcb_protocol_request_t xcb_req = {
10387         .count = 2,
10388         .ext = 0,
10389         .opcode = XCB_FREE_COLORMAP,
10390         .isvoid = 1
10391     };
10392 
10393     struct iovec xcb_parts[4];
10394     xcb_void_cookie_t xcb_ret;
10395     xcb_free_colormap_request_t xcb_out;
10396 
10397     xcb_out.pad0 = 0;
10398     xcb_out.cmap = cmap;
10399 
10400     xcb_parts[2].iov_base = (char *) &xcb_out;
10401     xcb_parts[2].iov_len = sizeof(xcb_out);
10402     xcb_parts[3].iov_base = 0;
10403     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10404 
10405     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10406     return xcb_ret;
10407 }
10408 
10409 xcb_void_cookie_t
xcb_copy_colormap_and_free_checked(xcb_connection_t * c,xcb_colormap_t mid,xcb_colormap_t src_cmap)10410 xcb_copy_colormap_and_free_checked (xcb_connection_t *c,
10411                                     xcb_colormap_t    mid,
10412                                     xcb_colormap_t    src_cmap)
10413 {
10414     static const xcb_protocol_request_t xcb_req = {
10415         .count = 2,
10416         .ext = 0,
10417         .opcode = XCB_COPY_COLORMAP_AND_FREE,
10418         .isvoid = 1
10419     };
10420 
10421     struct iovec xcb_parts[4];
10422     xcb_void_cookie_t xcb_ret;
10423     xcb_copy_colormap_and_free_request_t xcb_out;
10424 
10425     xcb_out.pad0 = 0;
10426     xcb_out.mid = mid;
10427     xcb_out.src_cmap = src_cmap;
10428 
10429     xcb_parts[2].iov_base = (char *) &xcb_out;
10430     xcb_parts[2].iov_len = sizeof(xcb_out);
10431     xcb_parts[3].iov_base = 0;
10432     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10433 
10434     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10435     return xcb_ret;
10436 }
10437 
10438 xcb_void_cookie_t
xcb_copy_colormap_and_free(xcb_connection_t * c,xcb_colormap_t mid,xcb_colormap_t src_cmap)10439 xcb_copy_colormap_and_free (xcb_connection_t *c,
10440                             xcb_colormap_t    mid,
10441                             xcb_colormap_t    src_cmap)
10442 {
10443     static const xcb_protocol_request_t xcb_req = {
10444         .count = 2,
10445         .ext = 0,
10446         .opcode = XCB_COPY_COLORMAP_AND_FREE,
10447         .isvoid = 1
10448     };
10449 
10450     struct iovec xcb_parts[4];
10451     xcb_void_cookie_t xcb_ret;
10452     xcb_copy_colormap_and_free_request_t xcb_out;
10453 
10454     xcb_out.pad0 = 0;
10455     xcb_out.mid = mid;
10456     xcb_out.src_cmap = src_cmap;
10457 
10458     xcb_parts[2].iov_base = (char *) &xcb_out;
10459     xcb_parts[2].iov_len = sizeof(xcb_out);
10460     xcb_parts[3].iov_base = 0;
10461     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10462 
10463     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10464     return xcb_ret;
10465 }
10466 
10467 xcb_void_cookie_t
xcb_install_colormap_checked(xcb_connection_t * c,xcb_colormap_t cmap)10468 xcb_install_colormap_checked (xcb_connection_t *c,
10469                               xcb_colormap_t    cmap)
10470 {
10471     static const xcb_protocol_request_t xcb_req = {
10472         .count = 2,
10473         .ext = 0,
10474         .opcode = XCB_INSTALL_COLORMAP,
10475         .isvoid = 1
10476     };
10477 
10478     struct iovec xcb_parts[4];
10479     xcb_void_cookie_t xcb_ret;
10480     xcb_install_colormap_request_t xcb_out;
10481 
10482     xcb_out.pad0 = 0;
10483     xcb_out.cmap = cmap;
10484 
10485     xcb_parts[2].iov_base = (char *) &xcb_out;
10486     xcb_parts[2].iov_len = sizeof(xcb_out);
10487     xcb_parts[3].iov_base = 0;
10488     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10489 
10490     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10491     return xcb_ret;
10492 }
10493 
10494 xcb_void_cookie_t
xcb_install_colormap(xcb_connection_t * c,xcb_colormap_t cmap)10495 xcb_install_colormap (xcb_connection_t *c,
10496                       xcb_colormap_t    cmap)
10497 {
10498     static const xcb_protocol_request_t xcb_req = {
10499         .count = 2,
10500         .ext = 0,
10501         .opcode = XCB_INSTALL_COLORMAP,
10502         .isvoid = 1
10503     };
10504 
10505     struct iovec xcb_parts[4];
10506     xcb_void_cookie_t xcb_ret;
10507     xcb_install_colormap_request_t xcb_out;
10508 
10509     xcb_out.pad0 = 0;
10510     xcb_out.cmap = cmap;
10511 
10512     xcb_parts[2].iov_base = (char *) &xcb_out;
10513     xcb_parts[2].iov_len = sizeof(xcb_out);
10514     xcb_parts[3].iov_base = 0;
10515     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10516 
10517     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10518     return xcb_ret;
10519 }
10520 
10521 xcb_void_cookie_t
xcb_uninstall_colormap_checked(xcb_connection_t * c,xcb_colormap_t cmap)10522 xcb_uninstall_colormap_checked (xcb_connection_t *c,
10523                                 xcb_colormap_t    cmap)
10524 {
10525     static const xcb_protocol_request_t xcb_req = {
10526         .count = 2,
10527         .ext = 0,
10528         .opcode = XCB_UNINSTALL_COLORMAP,
10529         .isvoid = 1
10530     };
10531 
10532     struct iovec xcb_parts[4];
10533     xcb_void_cookie_t xcb_ret;
10534     xcb_uninstall_colormap_request_t xcb_out;
10535 
10536     xcb_out.pad0 = 0;
10537     xcb_out.cmap = cmap;
10538 
10539     xcb_parts[2].iov_base = (char *) &xcb_out;
10540     xcb_parts[2].iov_len = sizeof(xcb_out);
10541     xcb_parts[3].iov_base = 0;
10542     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10543 
10544     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10545     return xcb_ret;
10546 }
10547 
10548 xcb_void_cookie_t
xcb_uninstall_colormap(xcb_connection_t * c,xcb_colormap_t cmap)10549 xcb_uninstall_colormap (xcb_connection_t *c,
10550                         xcb_colormap_t    cmap)
10551 {
10552     static const xcb_protocol_request_t xcb_req = {
10553         .count = 2,
10554         .ext = 0,
10555         .opcode = XCB_UNINSTALL_COLORMAP,
10556         .isvoid = 1
10557     };
10558 
10559     struct iovec xcb_parts[4];
10560     xcb_void_cookie_t xcb_ret;
10561     xcb_uninstall_colormap_request_t xcb_out;
10562 
10563     xcb_out.pad0 = 0;
10564     xcb_out.cmap = cmap;
10565 
10566     xcb_parts[2].iov_base = (char *) &xcb_out;
10567     xcb_parts[2].iov_len = sizeof(xcb_out);
10568     xcb_parts[3].iov_base = 0;
10569     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10570 
10571     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10572     return xcb_ret;
10573 }
10574 
10575 int
xcb_list_installed_colormaps_sizeof(const void * _buffer)10576 xcb_list_installed_colormaps_sizeof (const void  *_buffer)
10577 {
10578     char *xcb_tmp = (char *)_buffer;
10579     const xcb_list_installed_colormaps_reply_t *_aux = (xcb_list_installed_colormaps_reply_t *)_buffer;
10580     unsigned int xcb_buffer_len = 0;
10581     unsigned int xcb_block_len = 0;
10582     unsigned int xcb_pad = 0;
10583     unsigned int xcb_align_to = 0;
10584 
10585 
10586     xcb_block_len += sizeof(xcb_list_installed_colormaps_reply_t);
10587     xcb_tmp += xcb_block_len;
10588     xcb_buffer_len += xcb_block_len;
10589     xcb_block_len = 0;
10590     /* cmaps */
10591     xcb_block_len += _aux->cmaps_len * sizeof(xcb_colormap_t);
10592     xcb_tmp += xcb_block_len;
10593     xcb_align_to = ALIGNOF(xcb_colormap_t);
10594     /* insert padding */
10595     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10596     xcb_buffer_len += xcb_block_len + xcb_pad;
10597     if (0 != xcb_pad) {
10598         xcb_tmp += xcb_pad;
10599         xcb_pad = 0;
10600     }
10601     xcb_block_len = 0;
10602 
10603     return xcb_buffer_len;
10604 }
10605 
10606 xcb_list_installed_colormaps_cookie_t
xcb_list_installed_colormaps(xcb_connection_t * c,xcb_window_t window)10607 xcb_list_installed_colormaps (xcb_connection_t *c,
10608                               xcb_window_t      window)
10609 {
10610     static const xcb_protocol_request_t xcb_req = {
10611         .count = 2,
10612         .ext = 0,
10613         .opcode = XCB_LIST_INSTALLED_COLORMAPS,
10614         .isvoid = 0
10615     };
10616 
10617     struct iovec xcb_parts[4];
10618     xcb_list_installed_colormaps_cookie_t xcb_ret;
10619     xcb_list_installed_colormaps_request_t xcb_out;
10620 
10621     xcb_out.pad0 = 0;
10622     xcb_out.window = window;
10623 
10624     xcb_parts[2].iov_base = (char *) &xcb_out;
10625     xcb_parts[2].iov_len = sizeof(xcb_out);
10626     xcb_parts[3].iov_base = 0;
10627     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10628 
10629     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10630     return xcb_ret;
10631 }
10632 
10633 xcb_list_installed_colormaps_cookie_t
xcb_list_installed_colormaps_unchecked(xcb_connection_t * c,xcb_window_t window)10634 xcb_list_installed_colormaps_unchecked (xcb_connection_t *c,
10635                                         xcb_window_t      window)
10636 {
10637     static const xcb_protocol_request_t xcb_req = {
10638         .count = 2,
10639         .ext = 0,
10640         .opcode = XCB_LIST_INSTALLED_COLORMAPS,
10641         .isvoid = 0
10642     };
10643 
10644     struct iovec xcb_parts[4];
10645     xcb_list_installed_colormaps_cookie_t xcb_ret;
10646     xcb_list_installed_colormaps_request_t xcb_out;
10647 
10648     xcb_out.pad0 = 0;
10649     xcb_out.window = window;
10650 
10651     xcb_parts[2].iov_base = (char *) &xcb_out;
10652     xcb_parts[2].iov_len = sizeof(xcb_out);
10653     xcb_parts[3].iov_base = 0;
10654     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10655 
10656     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10657     return xcb_ret;
10658 }
10659 
10660 xcb_colormap_t *
xcb_list_installed_colormaps_cmaps(const xcb_list_installed_colormaps_reply_t * R)10661 xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R)
10662 {
10663     return (xcb_colormap_t *) (R + 1);
10664 }
10665 
10666 int
xcb_list_installed_colormaps_cmaps_length(const xcb_list_installed_colormaps_reply_t * R)10667 xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R)
10668 {
10669     return R->cmaps_len;
10670 }
10671 
10672 xcb_generic_iterator_t
xcb_list_installed_colormaps_cmaps_end(const xcb_list_installed_colormaps_reply_t * R)10673 xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R)
10674 {
10675     xcb_generic_iterator_t i;
10676     i.data = ((xcb_colormap_t *) (R + 1)) + (R->cmaps_len);
10677     i.rem = 0;
10678     i.index = (char *) i.data - (char *) R;
10679     return i;
10680 }
10681 
10682 xcb_list_installed_colormaps_reply_t *
xcb_list_installed_colormaps_reply(xcb_connection_t * c,xcb_list_installed_colormaps_cookie_t cookie,xcb_generic_error_t ** e)10683 xcb_list_installed_colormaps_reply (xcb_connection_t                       *c,
10684                                     xcb_list_installed_colormaps_cookie_t   cookie  /**< */,
10685                                     xcb_generic_error_t                   **e)
10686 {
10687     return (xcb_list_installed_colormaps_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
10688 }
10689 
10690 xcb_alloc_color_cookie_t
xcb_alloc_color(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t red,uint16_t green,uint16_t blue)10691 xcb_alloc_color (xcb_connection_t *c,
10692                  xcb_colormap_t    cmap,
10693                  uint16_t          red,
10694                  uint16_t          green,
10695                  uint16_t          blue)
10696 {
10697     static const xcb_protocol_request_t xcb_req = {
10698         .count = 2,
10699         .ext = 0,
10700         .opcode = XCB_ALLOC_COLOR,
10701         .isvoid = 0
10702     };
10703 
10704     struct iovec xcb_parts[4];
10705     xcb_alloc_color_cookie_t xcb_ret;
10706     xcb_alloc_color_request_t xcb_out;
10707 
10708     xcb_out.pad0 = 0;
10709     xcb_out.cmap = cmap;
10710     xcb_out.red = red;
10711     xcb_out.green = green;
10712     xcb_out.blue = blue;
10713     memset(xcb_out.pad1, 0, 2);
10714 
10715     xcb_parts[2].iov_base = (char *) &xcb_out;
10716     xcb_parts[2].iov_len = sizeof(xcb_out);
10717     xcb_parts[3].iov_base = 0;
10718     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10719 
10720     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10721     return xcb_ret;
10722 }
10723 
10724 xcb_alloc_color_cookie_t
xcb_alloc_color_unchecked(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t red,uint16_t green,uint16_t blue)10725 xcb_alloc_color_unchecked (xcb_connection_t *c,
10726                            xcb_colormap_t    cmap,
10727                            uint16_t          red,
10728                            uint16_t          green,
10729                            uint16_t          blue)
10730 {
10731     static const xcb_protocol_request_t xcb_req = {
10732         .count = 2,
10733         .ext = 0,
10734         .opcode = XCB_ALLOC_COLOR,
10735         .isvoid = 0
10736     };
10737 
10738     struct iovec xcb_parts[4];
10739     xcb_alloc_color_cookie_t xcb_ret;
10740     xcb_alloc_color_request_t xcb_out;
10741 
10742     xcb_out.pad0 = 0;
10743     xcb_out.cmap = cmap;
10744     xcb_out.red = red;
10745     xcb_out.green = green;
10746     xcb_out.blue = blue;
10747     memset(xcb_out.pad1, 0, 2);
10748 
10749     xcb_parts[2].iov_base = (char *) &xcb_out;
10750     xcb_parts[2].iov_len = sizeof(xcb_out);
10751     xcb_parts[3].iov_base = 0;
10752     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10753 
10754     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10755     return xcb_ret;
10756 }
10757 
10758 xcb_alloc_color_reply_t *
xcb_alloc_color_reply(xcb_connection_t * c,xcb_alloc_color_cookie_t cookie,xcb_generic_error_t ** e)10759 xcb_alloc_color_reply (xcb_connection_t          *c,
10760                        xcb_alloc_color_cookie_t   cookie  /**< */,
10761                        xcb_generic_error_t      **e)
10762 {
10763     return (xcb_alloc_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
10764 }
10765 
10766 int
xcb_alloc_named_color_sizeof(const void * _buffer)10767 xcb_alloc_named_color_sizeof (const void  *_buffer)
10768 {
10769     char *xcb_tmp = (char *)_buffer;
10770     const xcb_alloc_named_color_request_t *_aux = (xcb_alloc_named_color_request_t *)_buffer;
10771     unsigned int xcb_buffer_len = 0;
10772     unsigned int xcb_block_len = 0;
10773     unsigned int xcb_pad = 0;
10774     unsigned int xcb_align_to = 0;
10775 
10776 
10777     xcb_block_len += sizeof(xcb_alloc_named_color_request_t);
10778     xcb_tmp += xcb_block_len;
10779     xcb_buffer_len += xcb_block_len;
10780     xcb_block_len = 0;
10781     /* name */
10782     xcb_block_len += _aux->name_len * sizeof(char);
10783     xcb_tmp += xcb_block_len;
10784     xcb_align_to = ALIGNOF(char);
10785     /* insert padding */
10786     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10787     xcb_buffer_len += xcb_block_len + xcb_pad;
10788     if (0 != xcb_pad) {
10789         xcb_tmp += xcb_pad;
10790         xcb_pad = 0;
10791     }
10792     xcb_block_len = 0;
10793 
10794     return xcb_buffer_len;
10795 }
10796 
10797 xcb_alloc_named_color_cookie_t
xcb_alloc_named_color(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t name_len,const char * name)10798 xcb_alloc_named_color (xcb_connection_t *c,
10799                        xcb_colormap_t    cmap,
10800                        uint16_t          name_len,
10801                        const char       *name)
10802 {
10803     static const xcb_protocol_request_t xcb_req = {
10804         .count = 4,
10805         .ext = 0,
10806         .opcode = XCB_ALLOC_NAMED_COLOR,
10807         .isvoid = 0
10808     };
10809 
10810     struct iovec xcb_parts[6];
10811     xcb_alloc_named_color_cookie_t xcb_ret;
10812     xcb_alloc_named_color_request_t xcb_out;
10813 
10814     xcb_out.pad0 = 0;
10815     xcb_out.cmap = cmap;
10816     xcb_out.name_len = name_len;
10817     memset(xcb_out.pad1, 0, 2);
10818 
10819     xcb_parts[2].iov_base = (char *) &xcb_out;
10820     xcb_parts[2].iov_len = sizeof(xcb_out);
10821     xcb_parts[3].iov_base = 0;
10822     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10823     /* char name */
10824     xcb_parts[4].iov_base = (char *) name;
10825     xcb_parts[4].iov_len = name_len * sizeof(char);
10826     xcb_parts[5].iov_base = 0;
10827     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10828 
10829     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10830     return xcb_ret;
10831 }
10832 
10833 xcb_alloc_named_color_cookie_t
xcb_alloc_named_color_unchecked(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t name_len,const char * name)10834 xcb_alloc_named_color_unchecked (xcb_connection_t *c,
10835                                  xcb_colormap_t    cmap,
10836                                  uint16_t          name_len,
10837                                  const char       *name)
10838 {
10839     static const xcb_protocol_request_t xcb_req = {
10840         .count = 4,
10841         .ext = 0,
10842         .opcode = XCB_ALLOC_NAMED_COLOR,
10843         .isvoid = 0
10844     };
10845 
10846     struct iovec xcb_parts[6];
10847     xcb_alloc_named_color_cookie_t xcb_ret;
10848     xcb_alloc_named_color_request_t xcb_out;
10849 
10850     xcb_out.pad0 = 0;
10851     xcb_out.cmap = cmap;
10852     xcb_out.name_len = name_len;
10853     memset(xcb_out.pad1, 0, 2);
10854 
10855     xcb_parts[2].iov_base = (char *) &xcb_out;
10856     xcb_parts[2].iov_len = sizeof(xcb_out);
10857     xcb_parts[3].iov_base = 0;
10858     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10859     /* char name */
10860     xcb_parts[4].iov_base = (char *) name;
10861     xcb_parts[4].iov_len = name_len * sizeof(char);
10862     xcb_parts[5].iov_base = 0;
10863     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
10864 
10865     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10866     return xcb_ret;
10867 }
10868 
10869 xcb_alloc_named_color_reply_t *
xcb_alloc_named_color_reply(xcb_connection_t * c,xcb_alloc_named_color_cookie_t cookie,xcb_generic_error_t ** e)10870 xcb_alloc_named_color_reply (xcb_connection_t                *c,
10871                              xcb_alloc_named_color_cookie_t   cookie  /**< */,
10872                              xcb_generic_error_t            **e)
10873 {
10874     return (xcb_alloc_named_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
10875 }
10876 
10877 int
xcb_alloc_color_cells_sizeof(const void * _buffer)10878 xcb_alloc_color_cells_sizeof (const void  *_buffer)
10879 {
10880     char *xcb_tmp = (char *)_buffer;
10881     const xcb_alloc_color_cells_reply_t *_aux = (xcb_alloc_color_cells_reply_t *)_buffer;
10882     unsigned int xcb_buffer_len = 0;
10883     unsigned int xcb_block_len = 0;
10884     unsigned int xcb_pad = 0;
10885     unsigned int xcb_align_to = 0;
10886 
10887 
10888     xcb_block_len += sizeof(xcb_alloc_color_cells_reply_t);
10889     xcb_tmp += xcb_block_len;
10890     xcb_buffer_len += xcb_block_len;
10891     xcb_block_len = 0;
10892     /* pixels */
10893     xcb_block_len += _aux->pixels_len * sizeof(uint32_t);
10894     xcb_tmp += xcb_block_len;
10895     xcb_align_to = ALIGNOF(uint32_t);
10896     /* insert padding */
10897     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10898     xcb_buffer_len += xcb_block_len + xcb_pad;
10899     if (0 != xcb_pad) {
10900         xcb_tmp += xcb_pad;
10901         xcb_pad = 0;
10902     }
10903     xcb_block_len = 0;
10904     /* masks */
10905     xcb_block_len += _aux->masks_len * sizeof(uint32_t);
10906     xcb_tmp += xcb_block_len;
10907     xcb_align_to = ALIGNOF(uint32_t);
10908     /* insert padding */
10909     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10910     xcb_buffer_len += xcb_block_len + xcb_pad;
10911     if (0 != xcb_pad) {
10912         xcb_tmp += xcb_pad;
10913         xcb_pad = 0;
10914     }
10915     xcb_block_len = 0;
10916 
10917     return xcb_buffer_len;
10918 }
10919 
10920 xcb_alloc_color_cells_cookie_t
xcb_alloc_color_cells(xcb_connection_t * c,uint8_t contiguous,xcb_colormap_t cmap,uint16_t colors,uint16_t planes)10921 xcb_alloc_color_cells (xcb_connection_t *c,
10922                        uint8_t           contiguous,
10923                        xcb_colormap_t    cmap,
10924                        uint16_t          colors,
10925                        uint16_t          planes)
10926 {
10927     static const xcb_protocol_request_t xcb_req = {
10928         .count = 2,
10929         .ext = 0,
10930         .opcode = XCB_ALLOC_COLOR_CELLS,
10931         .isvoid = 0
10932     };
10933 
10934     struct iovec xcb_parts[4];
10935     xcb_alloc_color_cells_cookie_t xcb_ret;
10936     xcb_alloc_color_cells_request_t xcb_out;
10937 
10938     xcb_out.contiguous = contiguous;
10939     xcb_out.cmap = cmap;
10940     xcb_out.colors = colors;
10941     xcb_out.planes = planes;
10942 
10943     xcb_parts[2].iov_base = (char *) &xcb_out;
10944     xcb_parts[2].iov_len = sizeof(xcb_out);
10945     xcb_parts[3].iov_base = 0;
10946     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10947 
10948     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10949     return xcb_ret;
10950 }
10951 
10952 xcb_alloc_color_cells_cookie_t
xcb_alloc_color_cells_unchecked(xcb_connection_t * c,uint8_t contiguous,xcb_colormap_t cmap,uint16_t colors,uint16_t planes)10953 xcb_alloc_color_cells_unchecked (xcb_connection_t *c,
10954                                  uint8_t           contiguous,
10955                                  xcb_colormap_t    cmap,
10956                                  uint16_t          colors,
10957                                  uint16_t          planes)
10958 {
10959     static const xcb_protocol_request_t xcb_req = {
10960         .count = 2,
10961         .ext = 0,
10962         .opcode = XCB_ALLOC_COLOR_CELLS,
10963         .isvoid = 0
10964     };
10965 
10966     struct iovec xcb_parts[4];
10967     xcb_alloc_color_cells_cookie_t xcb_ret;
10968     xcb_alloc_color_cells_request_t xcb_out;
10969 
10970     xcb_out.contiguous = contiguous;
10971     xcb_out.cmap = cmap;
10972     xcb_out.colors = colors;
10973     xcb_out.planes = planes;
10974 
10975     xcb_parts[2].iov_base = (char *) &xcb_out;
10976     xcb_parts[2].iov_len = sizeof(xcb_out);
10977     xcb_parts[3].iov_base = 0;
10978     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10979 
10980     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10981     return xcb_ret;
10982 }
10983 
10984 uint32_t *
xcb_alloc_color_cells_pixels(const xcb_alloc_color_cells_reply_t * R)10985 xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R)
10986 {
10987     return (uint32_t *) (R + 1);
10988 }
10989 
10990 int
xcb_alloc_color_cells_pixels_length(const xcb_alloc_color_cells_reply_t * R)10991 xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R)
10992 {
10993     return R->pixels_len;
10994 }
10995 
10996 xcb_generic_iterator_t
xcb_alloc_color_cells_pixels_end(const xcb_alloc_color_cells_reply_t * R)10997 xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R)
10998 {
10999     xcb_generic_iterator_t i;
11000     i.data = ((uint32_t *) (R + 1)) + (R->pixels_len);
11001     i.rem = 0;
11002     i.index = (char *) i.data - (char *) R;
11003     return i;
11004 }
11005 
11006 uint32_t *
xcb_alloc_color_cells_masks(const xcb_alloc_color_cells_reply_t * R)11007 xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R)
11008 {
11009     xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R);
11010     return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
11011 }
11012 
11013 int
xcb_alloc_color_cells_masks_length(const xcb_alloc_color_cells_reply_t * R)11014 xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R)
11015 {
11016     return R->masks_len;
11017 }
11018 
11019 xcb_generic_iterator_t
xcb_alloc_color_cells_masks_end(const xcb_alloc_color_cells_reply_t * R)11020 xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R)
11021 {
11022     xcb_generic_iterator_t i;
11023     xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R);
11024     i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->masks_len);
11025     i.rem = 0;
11026     i.index = (char *) i.data - (char *) R;
11027     return i;
11028 }
11029 
11030 xcb_alloc_color_cells_reply_t *
xcb_alloc_color_cells_reply(xcb_connection_t * c,xcb_alloc_color_cells_cookie_t cookie,xcb_generic_error_t ** e)11031 xcb_alloc_color_cells_reply (xcb_connection_t                *c,
11032                              xcb_alloc_color_cells_cookie_t   cookie  /**< */,
11033                              xcb_generic_error_t            **e)
11034 {
11035     return (xcb_alloc_color_cells_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11036 }
11037 
11038 int
xcb_alloc_color_planes_sizeof(const void * _buffer)11039 xcb_alloc_color_planes_sizeof (const void  *_buffer)
11040 {
11041     char *xcb_tmp = (char *)_buffer;
11042     const xcb_alloc_color_planes_reply_t *_aux = (xcb_alloc_color_planes_reply_t *)_buffer;
11043     unsigned int xcb_buffer_len = 0;
11044     unsigned int xcb_block_len = 0;
11045     unsigned int xcb_pad = 0;
11046     unsigned int xcb_align_to = 0;
11047 
11048 
11049     xcb_block_len += sizeof(xcb_alloc_color_planes_reply_t);
11050     xcb_tmp += xcb_block_len;
11051     xcb_buffer_len += xcb_block_len;
11052     xcb_block_len = 0;
11053     /* pixels */
11054     xcb_block_len += _aux->pixels_len * sizeof(uint32_t);
11055     xcb_tmp += xcb_block_len;
11056     xcb_align_to = ALIGNOF(uint32_t);
11057     /* insert padding */
11058     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11059     xcb_buffer_len += xcb_block_len + xcb_pad;
11060     if (0 != xcb_pad) {
11061         xcb_tmp += xcb_pad;
11062         xcb_pad = 0;
11063     }
11064     xcb_block_len = 0;
11065 
11066     return xcb_buffer_len;
11067 }
11068 
11069 xcb_alloc_color_planes_cookie_t
xcb_alloc_color_planes(xcb_connection_t * c,uint8_t contiguous,xcb_colormap_t cmap,uint16_t colors,uint16_t reds,uint16_t greens,uint16_t blues)11070 xcb_alloc_color_planes (xcb_connection_t *c,
11071                         uint8_t           contiguous,
11072                         xcb_colormap_t    cmap,
11073                         uint16_t          colors,
11074                         uint16_t          reds,
11075                         uint16_t          greens,
11076                         uint16_t          blues)
11077 {
11078     static const xcb_protocol_request_t xcb_req = {
11079         .count = 2,
11080         .ext = 0,
11081         .opcode = XCB_ALLOC_COLOR_PLANES,
11082         .isvoid = 0
11083     };
11084 
11085     struct iovec xcb_parts[4];
11086     xcb_alloc_color_planes_cookie_t xcb_ret;
11087     xcb_alloc_color_planes_request_t xcb_out;
11088 
11089     xcb_out.contiguous = contiguous;
11090     xcb_out.cmap = cmap;
11091     xcb_out.colors = colors;
11092     xcb_out.reds = reds;
11093     xcb_out.greens = greens;
11094     xcb_out.blues = blues;
11095 
11096     xcb_parts[2].iov_base = (char *) &xcb_out;
11097     xcb_parts[2].iov_len = sizeof(xcb_out);
11098     xcb_parts[3].iov_base = 0;
11099     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11100 
11101     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11102     return xcb_ret;
11103 }
11104 
11105 xcb_alloc_color_planes_cookie_t
xcb_alloc_color_planes_unchecked(xcb_connection_t * c,uint8_t contiguous,xcb_colormap_t cmap,uint16_t colors,uint16_t reds,uint16_t greens,uint16_t blues)11106 xcb_alloc_color_planes_unchecked (xcb_connection_t *c,
11107                                   uint8_t           contiguous,
11108                                   xcb_colormap_t    cmap,
11109                                   uint16_t          colors,
11110                                   uint16_t          reds,
11111                                   uint16_t          greens,
11112                                   uint16_t          blues)
11113 {
11114     static const xcb_protocol_request_t xcb_req = {
11115         .count = 2,
11116         .ext = 0,
11117         .opcode = XCB_ALLOC_COLOR_PLANES,
11118         .isvoid = 0
11119     };
11120 
11121     struct iovec xcb_parts[4];
11122     xcb_alloc_color_planes_cookie_t xcb_ret;
11123     xcb_alloc_color_planes_request_t xcb_out;
11124 
11125     xcb_out.contiguous = contiguous;
11126     xcb_out.cmap = cmap;
11127     xcb_out.colors = colors;
11128     xcb_out.reds = reds;
11129     xcb_out.greens = greens;
11130     xcb_out.blues = blues;
11131 
11132     xcb_parts[2].iov_base = (char *) &xcb_out;
11133     xcb_parts[2].iov_len = sizeof(xcb_out);
11134     xcb_parts[3].iov_base = 0;
11135     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11136 
11137     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11138     return xcb_ret;
11139 }
11140 
11141 uint32_t *
xcb_alloc_color_planes_pixels(const xcb_alloc_color_planes_reply_t * R)11142 xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R)
11143 {
11144     return (uint32_t *) (R + 1);
11145 }
11146 
11147 int
xcb_alloc_color_planes_pixels_length(const xcb_alloc_color_planes_reply_t * R)11148 xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R)
11149 {
11150     return R->pixels_len;
11151 }
11152 
11153 xcb_generic_iterator_t
xcb_alloc_color_planes_pixels_end(const xcb_alloc_color_planes_reply_t * R)11154 xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R)
11155 {
11156     xcb_generic_iterator_t i;
11157     i.data = ((uint32_t *) (R + 1)) + (R->pixels_len);
11158     i.rem = 0;
11159     i.index = (char *) i.data - (char *) R;
11160     return i;
11161 }
11162 
11163 xcb_alloc_color_planes_reply_t *
xcb_alloc_color_planes_reply(xcb_connection_t * c,xcb_alloc_color_planes_cookie_t cookie,xcb_generic_error_t ** e)11164 xcb_alloc_color_planes_reply (xcb_connection_t                 *c,
11165                               xcb_alloc_color_planes_cookie_t   cookie  /**< */,
11166                               xcb_generic_error_t             **e)
11167 {
11168     return (xcb_alloc_color_planes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11169 }
11170 
11171 int
xcb_free_colors_sizeof(const void * _buffer,uint32_t pixels_len)11172 xcb_free_colors_sizeof (const void  *_buffer,
11173                         uint32_t     pixels_len)
11174 {
11175     char *xcb_tmp = (char *)_buffer;
11176     unsigned int xcb_buffer_len = 0;
11177     unsigned int xcb_block_len = 0;
11178     unsigned int xcb_pad = 0;
11179     unsigned int xcb_align_to = 0;
11180 
11181 
11182     xcb_block_len += sizeof(xcb_free_colors_request_t);
11183     xcb_tmp += xcb_block_len;
11184     xcb_buffer_len += xcb_block_len;
11185     xcb_block_len = 0;
11186     /* pixels */
11187     xcb_block_len += pixels_len * sizeof(uint32_t);
11188     xcb_tmp += xcb_block_len;
11189     xcb_align_to = ALIGNOF(uint32_t);
11190     /* insert padding */
11191     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11192     xcb_buffer_len += xcb_block_len + xcb_pad;
11193     if (0 != xcb_pad) {
11194         xcb_tmp += xcb_pad;
11195         xcb_pad = 0;
11196     }
11197     xcb_block_len = 0;
11198 
11199     return xcb_buffer_len;
11200 }
11201 
11202 xcb_void_cookie_t
xcb_free_colors_checked(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t plane_mask,uint32_t pixels_len,const uint32_t * pixels)11203 xcb_free_colors_checked (xcb_connection_t *c,
11204                          xcb_colormap_t    cmap,
11205                          uint32_t          plane_mask,
11206                          uint32_t          pixels_len,
11207                          const uint32_t   *pixels)
11208 {
11209     static const xcb_protocol_request_t xcb_req = {
11210         .count = 4,
11211         .ext = 0,
11212         .opcode = XCB_FREE_COLORS,
11213         .isvoid = 1
11214     };
11215 
11216     struct iovec xcb_parts[6];
11217     xcb_void_cookie_t xcb_ret;
11218     xcb_free_colors_request_t xcb_out;
11219 
11220     xcb_out.pad0 = 0;
11221     xcb_out.cmap = cmap;
11222     xcb_out.plane_mask = plane_mask;
11223 
11224     xcb_parts[2].iov_base = (char *) &xcb_out;
11225     xcb_parts[2].iov_len = sizeof(xcb_out);
11226     xcb_parts[3].iov_base = 0;
11227     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11228     /* uint32_t pixels */
11229     xcb_parts[4].iov_base = (char *) pixels;
11230     xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
11231     xcb_parts[5].iov_base = 0;
11232     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11233 
11234     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11235     return xcb_ret;
11236 }
11237 
11238 xcb_void_cookie_t
xcb_free_colors(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t plane_mask,uint32_t pixels_len,const uint32_t * pixels)11239 xcb_free_colors (xcb_connection_t *c,
11240                  xcb_colormap_t    cmap,
11241                  uint32_t          plane_mask,
11242                  uint32_t          pixels_len,
11243                  const uint32_t   *pixels)
11244 {
11245     static const xcb_protocol_request_t xcb_req = {
11246         .count = 4,
11247         .ext = 0,
11248         .opcode = XCB_FREE_COLORS,
11249         .isvoid = 1
11250     };
11251 
11252     struct iovec xcb_parts[6];
11253     xcb_void_cookie_t xcb_ret;
11254     xcb_free_colors_request_t xcb_out;
11255 
11256     xcb_out.pad0 = 0;
11257     xcb_out.cmap = cmap;
11258     xcb_out.plane_mask = plane_mask;
11259 
11260     xcb_parts[2].iov_base = (char *) &xcb_out;
11261     xcb_parts[2].iov_len = sizeof(xcb_out);
11262     xcb_parts[3].iov_base = 0;
11263     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11264     /* uint32_t pixels */
11265     xcb_parts[4].iov_base = (char *) pixels;
11266     xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
11267     xcb_parts[5].iov_base = 0;
11268     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11269 
11270     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11271     return xcb_ret;
11272 }
11273 
11274 uint32_t *
xcb_free_colors_pixels(const xcb_free_colors_request_t * R)11275 xcb_free_colors_pixels (const xcb_free_colors_request_t *R)
11276 {
11277     return (uint32_t *) (R + 1);
11278 }
11279 
11280 int
xcb_free_colors_pixels_length(const xcb_free_colors_request_t * R)11281 xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R)
11282 {
11283     return (((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t));
11284 }
11285 
11286 xcb_generic_iterator_t
xcb_free_colors_pixels_end(const xcb_free_colors_request_t * R)11287 xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R)
11288 {
11289     xcb_generic_iterator_t i;
11290     i.data = ((uint32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t)));
11291     i.rem = 0;
11292     i.index = (char *) i.data - (char *) R;
11293     return i;
11294 }
11295 
11296 void
xcb_coloritem_next(xcb_coloritem_iterator_t * i)11297 xcb_coloritem_next (xcb_coloritem_iterator_t *i)
11298 {
11299     --i->rem;
11300     ++i->data;
11301     i->index += sizeof(xcb_coloritem_t);
11302 }
11303 
11304 xcb_generic_iterator_t
xcb_coloritem_end(xcb_coloritem_iterator_t i)11305 xcb_coloritem_end (xcb_coloritem_iterator_t i)
11306 {
11307     xcb_generic_iterator_t ret;
11308     ret.data = i.data + i.rem;
11309     ret.index = i.index + ((char *) ret.data - (char *) i.data);
11310     ret.rem = 0;
11311     return ret;
11312 }
11313 
11314 int
xcb_store_colors_sizeof(const void * _buffer,uint32_t items_len)11315 xcb_store_colors_sizeof (const void  *_buffer,
11316                          uint32_t     items_len)
11317 {
11318     char *xcb_tmp = (char *)_buffer;
11319     unsigned int xcb_buffer_len = 0;
11320     unsigned int xcb_block_len = 0;
11321     unsigned int xcb_pad = 0;
11322     unsigned int xcb_align_to = 0;
11323 
11324 
11325     xcb_block_len += sizeof(xcb_store_colors_request_t);
11326     xcb_tmp += xcb_block_len;
11327     xcb_buffer_len += xcb_block_len;
11328     xcb_block_len = 0;
11329     /* items */
11330     xcb_block_len += items_len * sizeof(xcb_coloritem_t);
11331     xcb_tmp += xcb_block_len;
11332     xcb_align_to = ALIGNOF(xcb_coloritem_t);
11333     /* insert padding */
11334     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11335     xcb_buffer_len += xcb_block_len + xcb_pad;
11336     if (0 != xcb_pad) {
11337         xcb_tmp += xcb_pad;
11338         xcb_pad = 0;
11339     }
11340     xcb_block_len = 0;
11341 
11342     return xcb_buffer_len;
11343 }
11344 
11345 xcb_void_cookie_t
xcb_store_colors_checked(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t items_len,const xcb_coloritem_t * items)11346 xcb_store_colors_checked (xcb_connection_t      *c,
11347                           xcb_colormap_t         cmap,
11348                           uint32_t               items_len,
11349                           const xcb_coloritem_t *items)
11350 {
11351     static const xcb_protocol_request_t xcb_req = {
11352         .count = 4,
11353         .ext = 0,
11354         .opcode = XCB_STORE_COLORS,
11355         .isvoid = 1
11356     };
11357 
11358     struct iovec xcb_parts[6];
11359     xcb_void_cookie_t xcb_ret;
11360     xcb_store_colors_request_t xcb_out;
11361 
11362     xcb_out.pad0 = 0;
11363     xcb_out.cmap = cmap;
11364 
11365     xcb_parts[2].iov_base = (char *) &xcb_out;
11366     xcb_parts[2].iov_len = sizeof(xcb_out);
11367     xcb_parts[3].iov_base = 0;
11368     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11369     /* xcb_coloritem_t items */
11370     xcb_parts[4].iov_base = (char *) items;
11371     xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t);
11372     xcb_parts[5].iov_base = 0;
11373     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11374 
11375     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11376     return xcb_ret;
11377 }
11378 
11379 xcb_void_cookie_t
xcb_store_colors(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t items_len,const xcb_coloritem_t * items)11380 xcb_store_colors (xcb_connection_t      *c,
11381                   xcb_colormap_t         cmap,
11382                   uint32_t               items_len,
11383                   const xcb_coloritem_t *items)
11384 {
11385     static const xcb_protocol_request_t xcb_req = {
11386         .count = 4,
11387         .ext = 0,
11388         .opcode = XCB_STORE_COLORS,
11389         .isvoid = 1
11390     };
11391 
11392     struct iovec xcb_parts[6];
11393     xcb_void_cookie_t xcb_ret;
11394     xcb_store_colors_request_t xcb_out;
11395 
11396     xcb_out.pad0 = 0;
11397     xcb_out.cmap = cmap;
11398 
11399     xcb_parts[2].iov_base = (char *) &xcb_out;
11400     xcb_parts[2].iov_len = sizeof(xcb_out);
11401     xcb_parts[3].iov_base = 0;
11402     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11403     /* xcb_coloritem_t items */
11404     xcb_parts[4].iov_base = (char *) items;
11405     xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t);
11406     xcb_parts[5].iov_base = 0;
11407     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11408 
11409     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11410     return xcb_ret;
11411 }
11412 
11413 xcb_coloritem_t *
xcb_store_colors_items(const xcb_store_colors_request_t * R)11414 xcb_store_colors_items (const xcb_store_colors_request_t *R)
11415 {
11416     return (xcb_coloritem_t *) (R + 1);
11417 }
11418 
11419 int
xcb_store_colors_items_length(const xcb_store_colors_request_t * R)11420 xcb_store_colors_items_length (const xcb_store_colors_request_t *R)
11421 {
11422     return (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t));
11423 }
11424 
11425 xcb_coloritem_iterator_t
xcb_store_colors_items_iterator(const xcb_store_colors_request_t * R)11426 xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R)
11427 {
11428     xcb_coloritem_iterator_t i;
11429     i.data = (xcb_coloritem_t *) (R + 1);
11430     i.rem = (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t));
11431     i.index = (char *) i.data - (char *) R;
11432     return i;
11433 }
11434 
11435 int
xcb_store_named_color_sizeof(const void * _buffer)11436 xcb_store_named_color_sizeof (const void  *_buffer)
11437 {
11438     char *xcb_tmp = (char *)_buffer;
11439     const xcb_store_named_color_request_t *_aux = (xcb_store_named_color_request_t *)_buffer;
11440     unsigned int xcb_buffer_len = 0;
11441     unsigned int xcb_block_len = 0;
11442     unsigned int xcb_pad = 0;
11443     unsigned int xcb_align_to = 0;
11444 
11445 
11446     xcb_block_len += sizeof(xcb_store_named_color_request_t);
11447     xcb_tmp += xcb_block_len;
11448     xcb_buffer_len += xcb_block_len;
11449     xcb_block_len = 0;
11450     /* name */
11451     xcb_block_len += _aux->name_len * sizeof(char);
11452     xcb_tmp += xcb_block_len;
11453     xcb_align_to = ALIGNOF(char);
11454     /* insert padding */
11455     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11456     xcb_buffer_len += xcb_block_len + xcb_pad;
11457     if (0 != xcb_pad) {
11458         xcb_tmp += xcb_pad;
11459         xcb_pad = 0;
11460     }
11461     xcb_block_len = 0;
11462 
11463     return xcb_buffer_len;
11464 }
11465 
11466 xcb_void_cookie_t
xcb_store_named_color_checked(xcb_connection_t * c,uint8_t flags,xcb_colormap_t cmap,uint32_t pixel,uint16_t name_len,const char * name)11467 xcb_store_named_color_checked (xcb_connection_t *c,
11468                                uint8_t           flags,
11469                                xcb_colormap_t    cmap,
11470                                uint32_t          pixel,
11471                                uint16_t          name_len,
11472                                const char       *name)
11473 {
11474     static const xcb_protocol_request_t xcb_req = {
11475         .count = 4,
11476         .ext = 0,
11477         .opcode = XCB_STORE_NAMED_COLOR,
11478         .isvoid = 1
11479     };
11480 
11481     struct iovec xcb_parts[6];
11482     xcb_void_cookie_t xcb_ret;
11483     xcb_store_named_color_request_t xcb_out;
11484 
11485     xcb_out.flags = flags;
11486     xcb_out.cmap = cmap;
11487     xcb_out.pixel = pixel;
11488     xcb_out.name_len = name_len;
11489     memset(xcb_out.pad0, 0, 2);
11490 
11491     xcb_parts[2].iov_base = (char *) &xcb_out;
11492     xcb_parts[2].iov_len = sizeof(xcb_out);
11493     xcb_parts[3].iov_base = 0;
11494     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11495     /* char name */
11496     xcb_parts[4].iov_base = (char *) name;
11497     xcb_parts[4].iov_len = name_len * sizeof(char);
11498     xcb_parts[5].iov_base = 0;
11499     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11500 
11501     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11502     return xcb_ret;
11503 }
11504 
11505 xcb_void_cookie_t
xcb_store_named_color(xcb_connection_t * c,uint8_t flags,xcb_colormap_t cmap,uint32_t pixel,uint16_t name_len,const char * name)11506 xcb_store_named_color (xcb_connection_t *c,
11507                        uint8_t           flags,
11508                        xcb_colormap_t    cmap,
11509                        uint32_t          pixel,
11510                        uint16_t          name_len,
11511                        const char       *name)
11512 {
11513     static const xcb_protocol_request_t xcb_req = {
11514         .count = 4,
11515         .ext = 0,
11516         .opcode = XCB_STORE_NAMED_COLOR,
11517         .isvoid = 1
11518     };
11519 
11520     struct iovec xcb_parts[6];
11521     xcb_void_cookie_t xcb_ret;
11522     xcb_store_named_color_request_t xcb_out;
11523 
11524     xcb_out.flags = flags;
11525     xcb_out.cmap = cmap;
11526     xcb_out.pixel = pixel;
11527     xcb_out.name_len = name_len;
11528     memset(xcb_out.pad0, 0, 2);
11529 
11530     xcb_parts[2].iov_base = (char *) &xcb_out;
11531     xcb_parts[2].iov_len = sizeof(xcb_out);
11532     xcb_parts[3].iov_base = 0;
11533     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11534     /* char name */
11535     xcb_parts[4].iov_base = (char *) name;
11536     xcb_parts[4].iov_len = name_len * sizeof(char);
11537     xcb_parts[5].iov_base = 0;
11538     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11539 
11540     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11541     return xcb_ret;
11542 }
11543 
11544 char *
xcb_store_named_color_name(const xcb_store_named_color_request_t * R)11545 xcb_store_named_color_name (const xcb_store_named_color_request_t *R)
11546 {
11547     return (char *) (R + 1);
11548 }
11549 
11550 int
xcb_store_named_color_name_length(const xcb_store_named_color_request_t * R)11551 xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R)
11552 {
11553     return R->name_len;
11554 }
11555 
11556 xcb_generic_iterator_t
xcb_store_named_color_name_end(const xcb_store_named_color_request_t * R)11557 xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R)
11558 {
11559     xcb_generic_iterator_t i;
11560     i.data = ((char *) (R + 1)) + (R->name_len);
11561     i.rem = 0;
11562     i.index = (char *) i.data - (char *) R;
11563     return i;
11564 }
11565 
11566 void
xcb_rgb_next(xcb_rgb_iterator_t * i)11567 xcb_rgb_next (xcb_rgb_iterator_t *i)
11568 {
11569     --i->rem;
11570     ++i->data;
11571     i->index += sizeof(xcb_rgb_t);
11572 }
11573 
11574 xcb_generic_iterator_t
xcb_rgb_end(xcb_rgb_iterator_t i)11575 xcb_rgb_end (xcb_rgb_iterator_t i)
11576 {
11577     xcb_generic_iterator_t ret;
11578     ret.data = i.data + i.rem;
11579     ret.index = i.index + ((char *) ret.data - (char *) i.data);
11580     ret.rem = 0;
11581     return ret;
11582 }
11583 
11584 int
xcb_query_colors_sizeof(const void * _buffer,uint32_t pixels_len)11585 xcb_query_colors_sizeof (const void  *_buffer,
11586                          uint32_t     pixels_len)
11587 {
11588     char *xcb_tmp = (char *)_buffer;
11589     unsigned int xcb_buffer_len = 0;
11590     unsigned int xcb_block_len = 0;
11591     unsigned int xcb_pad = 0;
11592     unsigned int xcb_align_to = 0;
11593 
11594 
11595     xcb_block_len += sizeof(xcb_query_colors_request_t);
11596     xcb_tmp += xcb_block_len;
11597     xcb_buffer_len += xcb_block_len;
11598     xcb_block_len = 0;
11599     /* pixels */
11600     xcb_block_len += pixels_len * sizeof(uint32_t);
11601     xcb_tmp += xcb_block_len;
11602     xcb_align_to = ALIGNOF(uint32_t);
11603     /* insert padding */
11604     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11605     xcb_buffer_len += xcb_block_len + xcb_pad;
11606     if (0 != xcb_pad) {
11607         xcb_tmp += xcb_pad;
11608         xcb_pad = 0;
11609     }
11610     xcb_block_len = 0;
11611 
11612     return xcb_buffer_len;
11613 }
11614 
11615 xcb_query_colors_cookie_t
xcb_query_colors(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t pixels_len,const uint32_t * pixels)11616 xcb_query_colors (xcb_connection_t *c,
11617                   xcb_colormap_t    cmap,
11618                   uint32_t          pixels_len,
11619                   const uint32_t   *pixels)
11620 {
11621     static const xcb_protocol_request_t xcb_req = {
11622         .count = 4,
11623         .ext = 0,
11624         .opcode = XCB_QUERY_COLORS,
11625         .isvoid = 0
11626     };
11627 
11628     struct iovec xcb_parts[6];
11629     xcb_query_colors_cookie_t xcb_ret;
11630     xcb_query_colors_request_t xcb_out;
11631 
11632     xcb_out.pad0 = 0;
11633     xcb_out.cmap = cmap;
11634 
11635     xcb_parts[2].iov_base = (char *) &xcb_out;
11636     xcb_parts[2].iov_len = sizeof(xcb_out);
11637     xcb_parts[3].iov_base = 0;
11638     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11639     /* uint32_t pixels */
11640     xcb_parts[4].iov_base = (char *) pixels;
11641     xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
11642     xcb_parts[5].iov_base = 0;
11643     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11644 
11645     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11646     return xcb_ret;
11647 }
11648 
11649 xcb_query_colors_cookie_t
xcb_query_colors_unchecked(xcb_connection_t * c,xcb_colormap_t cmap,uint32_t pixels_len,const uint32_t * pixels)11650 xcb_query_colors_unchecked (xcb_connection_t *c,
11651                             xcb_colormap_t    cmap,
11652                             uint32_t          pixels_len,
11653                             const uint32_t   *pixels)
11654 {
11655     static const xcb_protocol_request_t xcb_req = {
11656         .count = 4,
11657         .ext = 0,
11658         .opcode = XCB_QUERY_COLORS,
11659         .isvoid = 0
11660     };
11661 
11662     struct iovec xcb_parts[6];
11663     xcb_query_colors_cookie_t xcb_ret;
11664     xcb_query_colors_request_t xcb_out;
11665 
11666     xcb_out.pad0 = 0;
11667     xcb_out.cmap = cmap;
11668 
11669     xcb_parts[2].iov_base = (char *) &xcb_out;
11670     xcb_parts[2].iov_len = sizeof(xcb_out);
11671     xcb_parts[3].iov_base = 0;
11672     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11673     /* uint32_t pixels */
11674     xcb_parts[4].iov_base = (char *) pixels;
11675     xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
11676     xcb_parts[5].iov_base = 0;
11677     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11678 
11679     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11680     return xcb_ret;
11681 }
11682 
11683 xcb_rgb_t *
xcb_query_colors_colors(const xcb_query_colors_reply_t * R)11684 xcb_query_colors_colors (const xcb_query_colors_reply_t *R)
11685 {
11686     return (xcb_rgb_t *) (R + 1);
11687 }
11688 
11689 int
xcb_query_colors_colors_length(const xcb_query_colors_reply_t * R)11690 xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R)
11691 {
11692     return R->colors_len;
11693 }
11694 
11695 xcb_rgb_iterator_t
xcb_query_colors_colors_iterator(const xcb_query_colors_reply_t * R)11696 xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R)
11697 {
11698     xcb_rgb_iterator_t i;
11699     i.data = (xcb_rgb_t *) (R + 1);
11700     i.rem = R->colors_len;
11701     i.index = (char *) i.data - (char *) R;
11702     return i;
11703 }
11704 
11705 xcb_query_colors_reply_t *
xcb_query_colors_reply(xcb_connection_t * c,xcb_query_colors_cookie_t cookie,xcb_generic_error_t ** e)11706 xcb_query_colors_reply (xcb_connection_t           *c,
11707                         xcb_query_colors_cookie_t   cookie  /**< */,
11708                         xcb_generic_error_t       **e)
11709 {
11710     return (xcb_query_colors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11711 }
11712 
11713 int
xcb_lookup_color_sizeof(const void * _buffer)11714 xcb_lookup_color_sizeof (const void  *_buffer)
11715 {
11716     char *xcb_tmp = (char *)_buffer;
11717     const xcb_lookup_color_request_t *_aux = (xcb_lookup_color_request_t *)_buffer;
11718     unsigned int xcb_buffer_len = 0;
11719     unsigned int xcb_block_len = 0;
11720     unsigned int xcb_pad = 0;
11721     unsigned int xcb_align_to = 0;
11722 
11723 
11724     xcb_block_len += sizeof(xcb_lookup_color_request_t);
11725     xcb_tmp += xcb_block_len;
11726     xcb_buffer_len += xcb_block_len;
11727     xcb_block_len = 0;
11728     /* name */
11729     xcb_block_len += _aux->name_len * sizeof(char);
11730     xcb_tmp += xcb_block_len;
11731     xcb_align_to = ALIGNOF(char);
11732     /* insert padding */
11733     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11734     xcb_buffer_len += xcb_block_len + xcb_pad;
11735     if (0 != xcb_pad) {
11736         xcb_tmp += xcb_pad;
11737         xcb_pad = 0;
11738     }
11739     xcb_block_len = 0;
11740 
11741     return xcb_buffer_len;
11742 }
11743 
11744 xcb_lookup_color_cookie_t
xcb_lookup_color(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t name_len,const char * name)11745 xcb_lookup_color (xcb_connection_t *c,
11746                   xcb_colormap_t    cmap,
11747                   uint16_t          name_len,
11748                   const char       *name)
11749 {
11750     static const xcb_protocol_request_t xcb_req = {
11751         .count = 4,
11752         .ext = 0,
11753         .opcode = XCB_LOOKUP_COLOR,
11754         .isvoid = 0
11755     };
11756 
11757     struct iovec xcb_parts[6];
11758     xcb_lookup_color_cookie_t xcb_ret;
11759     xcb_lookup_color_request_t xcb_out;
11760 
11761     xcb_out.pad0 = 0;
11762     xcb_out.cmap = cmap;
11763     xcb_out.name_len = name_len;
11764     memset(xcb_out.pad1, 0, 2);
11765 
11766     xcb_parts[2].iov_base = (char *) &xcb_out;
11767     xcb_parts[2].iov_len = sizeof(xcb_out);
11768     xcb_parts[3].iov_base = 0;
11769     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11770     /* char name */
11771     xcb_parts[4].iov_base = (char *) name;
11772     xcb_parts[4].iov_len = name_len * sizeof(char);
11773     xcb_parts[5].iov_base = 0;
11774     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11775 
11776     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11777     return xcb_ret;
11778 }
11779 
11780 xcb_lookup_color_cookie_t
xcb_lookup_color_unchecked(xcb_connection_t * c,xcb_colormap_t cmap,uint16_t name_len,const char * name)11781 xcb_lookup_color_unchecked (xcb_connection_t *c,
11782                             xcb_colormap_t    cmap,
11783                             uint16_t          name_len,
11784                             const char       *name)
11785 {
11786     static const xcb_protocol_request_t xcb_req = {
11787         .count = 4,
11788         .ext = 0,
11789         .opcode = XCB_LOOKUP_COLOR,
11790         .isvoid = 0
11791     };
11792 
11793     struct iovec xcb_parts[6];
11794     xcb_lookup_color_cookie_t xcb_ret;
11795     xcb_lookup_color_request_t xcb_out;
11796 
11797     xcb_out.pad0 = 0;
11798     xcb_out.cmap = cmap;
11799     xcb_out.name_len = name_len;
11800     memset(xcb_out.pad1, 0, 2);
11801 
11802     xcb_parts[2].iov_base = (char *) &xcb_out;
11803     xcb_parts[2].iov_len = sizeof(xcb_out);
11804     xcb_parts[3].iov_base = 0;
11805     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11806     /* char name */
11807     xcb_parts[4].iov_base = (char *) name;
11808     xcb_parts[4].iov_len = name_len * sizeof(char);
11809     xcb_parts[5].iov_base = 0;
11810     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11811 
11812     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11813     return xcb_ret;
11814 }
11815 
11816 xcb_lookup_color_reply_t *
xcb_lookup_color_reply(xcb_connection_t * c,xcb_lookup_color_cookie_t cookie,xcb_generic_error_t ** e)11817 xcb_lookup_color_reply (xcb_connection_t           *c,
11818                         xcb_lookup_color_cookie_t   cookie  /**< */,
11819                         xcb_generic_error_t       **e)
11820 {
11821     return (xcb_lookup_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11822 }
11823 
11824 xcb_void_cookie_t
xcb_create_cursor_checked(xcb_connection_t * c,xcb_cursor_t cid,xcb_pixmap_t source,xcb_pixmap_t mask,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue,uint16_t x,uint16_t y)11825 xcb_create_cursor_checked (xcb_connection_t *c,
11826                            xcb_cursor_t      cid,
11827                            xcb_pixmap_t      source,
11828                            xcb_pixmap_t      mask,
11829                            uint16_t          fore_red,
11830                            uint16_t          fore_green,
11831                            uint16_t          fore_blue,
11832                            uint16_t          back_red,
11833                            uint16_t          back_green,
11834                            uint16_t          back_blue,
11835                            uint16_t          x,
11836                            uint16_t          y)
11837 {
11838     static const xcb_protocol_request_t xcb_req = {
11839         .count = 2,
11840         .ext = 0,
11841         .opcode = XCB_CREATE_CURSOR,
11842         .isvoid = 1
11843     };
11844 
11845     struct iovec xcb_parts[4];
11846     xcb_void_cookie_t xcb_ret;
11847     xcb_create_cursor_request_t xcb_out;
11848 
11849     xcb_out.pad0 = 0;
11850     xcb_out.cid = cid;
11851     xcb_out.source = source;
11852     xcb_out.mask = mask;
11853     xcb_out.fore_red = fore_red;
11854     xcb_out.fore_green = fore_green;
11855     xcb_out.fore_blue = fore_blue;
11856     xcb_out.back_red = back_red;
11857     xcb_out.back_green = back_green;
11858     xcb_out.back_blue = back_blue;
11859     xcb_out.x = x;
11860     xcb_out.y = y;
11861 
11862     xcb_parts[2].iov_base = (char *) &xcb_out;
11863     xcb_parts[2].iov_len = sizeof(xcb_out);
11864     xcb_parts[3].iov_base = 0;
11865     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11866 
11867     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11868     return xcb_ret;
11869 }
11870 
11871 xcb_void_cookie_t
xcb_create_cursor(xcb_connection_t * c,xcb_cursor_t cid,xcb_pixmap_t source,xcb_pixmap_t mask,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue,uint16_t x,uint16_t y)11872 xcb_create_cursor (xcb_connection_t *c,
11873                    xcb_cursor_t      cid,
11874                    xcb_pixmap_t      source,
11875                    xcb_pixmap_t      mask,
11876                    uint16_t          fore_red,
11877                    uint16_t          fore_green,
11878                    uint16_t          fore_blue,
11879                    uint16_t          back_red,
11880                    uint16_t          back_green,
11881                    uint16_t          back_blue,
11882                    uint16_t          x,
11883                    uint16_t          y)
11884 {
11885     static const xcb_protocol_request_t xcb_req = {
11886         .count = 2,
11887         .ext = 0,
11888         .opcode = XCB_CREATE_CURSOR,
11889         .isvoid = 1
11890     };
11891 
11892     struct iovec xcb_parts[4];
11893     xcb_void_cookie_t xcb_ret;
11894     xcb_create_cursor_request_t xcb_out;
11895 
11896     xcb_out.pad0 = 0;
11897     xcb_out.cid = cid;
11898     xcb_out.source = source;
11899     xcb_out.mask = mask;
11900     xcb_out.fore_red = fore_red;
11901     xcb_out.fore_green = fore_green;
11902     xcb_out.fore_blue = fore_blue;
11903     xcb_out.back_red = back_red;
11904     xcb_out.back_green = back_green;
11905     xcb_out.back_blue = back_blue;
11906     xcb_out.x = x;
11907     xcb_out.y = y;
11908 
11909     xcb_parts[2].iov_base = (char *) &xcb_out;
11910     xcb_parts[2].iov_len = sizeof(xcb_out);
11911     xcb_parts[3].iov_base = 0;
11912     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11913 
11914     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11915     return xcb_ret;
11916 }
11917 
11918 xcb_void_cookie_t
xcb_create_glyph_cursor_checked(xcb_connection_t * c,xcb_cursor_t cid,xcb_font_t source_font,xcb_font_t mask_font,uint16_t source_char,uint16_t mask_char,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue)11919 xcb_create_glyph_cursor_checked (xcb_connection_t *c,
11920                                  xcb_cursor_t      cid,
11921                                  xcb_font_t        source_font,
11922                                  xcb_font_t        mask_font,
11923                                  uint16_t          source_char,
11924                                  uint16_t          mask_char,
11925                                  uint16_t          fore_red,
11926                                  uint16_t          fore_green,
11927                                  uint16_t          fore_blue,
11928                                  uint16_t          back_red,
11929                                  uint16_t          back_green,
11930                                  uint16_t          back_blue)
11931 {
11932     static const xcb_protocol_request_t xcb_req = {
11933         .count = 2,
11934         .ext = 0,
11935         .opcode = XCB_CREATE_GLYPH_CURSOR,
11936         .isvoid = 1
11937     };
11938 
11939     struct iovec xcb_parts[4];
11940     xcb_void_cookie_t xcb_ret;
11941     xcb_create_glyph_cursor_request_t xcb_out;
11942 
11943     xcb_out.pad0 = 0;
11944     xcb_out.cid = cid;
11945     xcb_out.source_font = source_font;
11946     xcb_out.mask_font = mask_font;
11947     xcb_out.source_char = source_char;
11948     xcb_out.mask_char = mask_char;
11949     xcb_out.fore_red = fore_red;
11950     xcb_out.fore_green = fore_green;
11951     xcb_out.fore_blue = fore_blue;
11952     xcb_out.back_red = back_red;
11953     xcb_out.back_green = back_green;
11954     xcb_out.back_blue = back_blue;
11955 
11956     xcb_parts[2].iov_base = (char *) &xcb_out;
11957     xcb_parts[2].iov_len = sizeof(xcb_out);
11958     xcb_parts[3].iov_base = 0;
11959     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11960 
11961     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11962     return xcb_ret;
11963 }
11964 
11965 xcb_void_cookie_t
xcb_create_glyph_cursor(xcb_connection_t * c,xcb_cursor_t cid,xcb_font_t source_font,xcb_font_t mask_font,uint16_t source_char,uint16_t mask_char,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue)11966 xcb_create_glyph_cursor (xcb_connection_t *c,
11967                          xcb_cursor_t      cid,
11968                          xcb_font_t        source_font,
11969                          xcb_font_t        mask_font,
11970                          uint16_t          source_char,
11971                          uint16_t          mask_char,
11972                          uint16_t          fore_red,
11973                          uint16_t          fore_green,
11974                          uint16_t          fore_blue,
11975                          uint16_t          back_red,
11976                          uint16_t          back_green,
11977                          uint16_t          back_blue)
11978 {
11979     static const xcb_protocol_request_t xcb_req = {
11980         .count = 2,
11981         .ext = 0,
11982         .opcode = XCB_CREATE_GLYPH_CURSOR,
11983         .isvoid = 1
11984     };
11985 
11986     struct iovec xcb_parts[4];
11987     xcb_void_cookie_t xcb_ret;
11988     xcb_create_glyph_cursor_request_t xcb_out;
11989 
11990     xcb_out.pad0 = 0;
11991     xcb_out.cid = cid;
11992     xcb_out.source_font = source_font;
11993     xcb_out.mask_font = mask_font;
11994     xcb_out.source_char = source_char;
11995     xcb_out.mask_char = mask_char;
11996     xcb_out.fore_red = fore_red;
11997     xcb_out.fore_green = fore_green;
11998     xcb_out.fore_blue = fore_blue;
11999     xcb_out.back_red = back_red;
12000     xcb_out.back_green = back_green;
12001     xcb_out.back_blue = back_blue;
12002 
12003     xcb_parts[2].iov_base = (char *) &xcb_out;
12004     xcb_parts[2].iov_len = sizeof(xcb_out);
12005     xcb_parts[3].iov_base = 0;
12006     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12007 
12008     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12009     return xcb_ret;
12010 }
12011 
12012 xcb_void_cookie_t
xcb_free_cursor_checked(xcb_connection_t * c,xcb_cursor_t cursor)12013 xcb_free_cursor_checked (xcb_connection_t *c,
12014                          xcb_cursor_t      cursor)
12015 {
12016     static const xcb_protocol_request_t xcb_req = {
12017         .count = 2,
12018         .ext = 0,
12019         .opcode = XCB_FREE_CURSOR,
12020         .isvoid = 1
12021     };
12022 
12023     struct iovec xcb_parts[4];
12024     xcb_void_cookie_t xcb_ret;
12025     xcb_free_cursor_request_t xcb_out;
12026 
12027     xcb_out.pad0 = 0;
12028     xcb_out.cursor = cursor;
12029 
12030     xcb_parts[2].iov_base = (char *) &xcb_out;
12031     xcb_parts[2].iov_len = sizeof(xcb_out);
12032     xcb_parts[3].iov_base = 0;
12033     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12034 
12035     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12036     return xcb_ret;
12037 }
12038 
12039 xcb_void_cookie_t
xcb_free_cursor(xcb_connection_t * c,xcb_cursor_t cursor)12040 xcb_free_cursor (xcb_connection_t *c,
12041                  xcb_cursor_t      cursor)
12042 {
12043     static const xcb_protocol_request_t xcb_req = {
12044         .count = 2,
12045         .ext = 0,
12046         .opcode = XCB_FREE_CURSOR,
12047         .isvoid = 1
12048     };
12049 
12050     struct iovec xcb_parts[4];
12051     xcb_void_cookie_t xcb_ret;
12052     xcb_free_cursor_request_t xcb_out;
12053 
12054     xcb_out.pad0 = 0;
12055     xcb_out.cursor = cursor;
12056 
12057     xcb_parts[2].iov_base = (char *) &xcb_out;
12058     xcb_parts[2].iov_len = sizeof(xcb_out);
12059     xcb_parts[3].iov_base = 0;
12060     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12061 
12062     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12063     return xcb_ret;
12064 }
12065 
12066 xcb_void_cookie_t
xcb_recolor_cursor_checked(xcb_connection_t * c,xcb_cursor_t cursor,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue)12067 xcb_recolor_cursor_checked (xcb_connection_t *c,
12068                             xcb_cursor_t      cursor,
12069                             uint16_t          fore_red,
12070                             uint16_t          fore_green,
12071                             uint16_t          fore_blue,
12072                             uint16_t          back_red,
12073                             uint16_t          back_green,
12074                             uint16_t          back_blue)
12075 {
12076     static const xcb_protocol_request_t xcb_req = {
12077         .count = 2,
12078         .ext = 0,
12079         .opcode = XCB_RECOLOR_CURSOR,
12080         .isvoid = 1
12081     };
12082 
12083     struct iovec xcb_parts[4];
12084     xcb_void_cookie_t xcb_ret;
12085     xcb_recolor_cursor_request_t xcb_out;
12086 
12087     xcb_out.pad0 = 0;
12088     xcb_out.cursor = cursor;
12089     xcb_out.fore_red = fore_red;
12090     xcb_out.fore_green = fore_green;
12091     xcb_out.fore_blue = fore_blue;
12092     xcb_out.back_red = back_red;
12093     xcb_out.back_green = back_green;
12094     xcb_out.back_blue = back_blue;
12095 
12096     xcb_parts[2].iov_base = (char *) &xcb_out;
12097     xcb_parts[2].iov_len = sizeof(xcb_out);
12098     xcb_parts[3].iov_base = 0;
12099     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12100 
12101     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12102     return xcb_ret;
12103 }
12104 
12105 xcb_void_cookie_t
xcb_recolor_cursor(xcb_connection_t * c,xcb_cursor_t cursor,uint16_t fore_red,uint16_t fore_green,uint16_t fore_blue,uint16_t back_red,uint16_t back_green,uint16_t back_blue)12106 xcb_recolor_cursor (xcb_connection_t *c,
12107                     xcb_cursor_t      cursor,
12108                     uint16_t          fore_red,
12109                     uint16_t          fore_green,
12110                     uint16_t          fore_blue,
12111                     uint16_t          back_red,
12112                     uint16_t          back_green,
12113                     uint16_t          back_blue)
12114 {
12115     static const xcb_protocol_request_t xcb_req = {
12116         .count = 2,
12117         .ext = 0,
12118         .opcode = XCB_RECOLOR_CURSOR,
12119         .isvoid = 1
12120     };
12121 
12122     struct iovec xcb_parts[4];
12123     xcb_void_cookie_t xcb_ret;
12124     xcb_recolor_cursor_request_t xcb_out;
12125 
12126     xcb_out.pad0 = 0;
12127     xcb_out.cursor = cursor;
12128     xcb_out.fore_red = fore_red;
12129     xcb_out.fore_green = fore_green;
12130     xcb_out.fore_blue = fore_blue;
12131     xcb_out.back_red = back_red;
12132     xcb_out.back_green = back_green;
12133     xcb_out.back_blue = back_blue;
12134 
12135     xcb_parts[2].iov_base = (char *) &xcb_out;
12136     xcb_parts[2].iov_len = sizeof(xcb_out);
12137     xcb_parts[3].iov_base = 0;
12138     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12139 
12140     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12141     return xcb_ret;
12142 }
12143 
12144 xcb_query_best_size_cookie_t
xcb_query_best_size(xcb_connection_t * c,uint8_t _class,xcb_drawable_t drawable,uint16_t width,uint16_t height)12145 xcb_query_best_size (xcb_connection_t *c,
12146                      uint8_t           _class,
12147                      xcb_drawable_t    drawable,
12148                      uint16_t          width,
12149                      uint16_t          height)
12150 {
12151     static const xcb_protocol_request_t xcb_req = {
12152         .count = 2,
12153         .ext = 0,
12154         .opcode = XCB_QUERY_BEST_SIZE,
12155         .isvoid = 0
12156     };
12157 
12158     struct iovec xcb_parts[4];
12159     xcb_query_best_size_cookie_t xcb_ret;
12160     xcb_query_best_size_request_t xcb_out;
12161 
12162     xcb_out._class = _class;
12163     xcb_out.drawable = drawable;
12164     xcb_out.width = width;
12165     xcb_out.height = height;
12166 
12167     xcb_parts[2].iov_base = (char *) &xcb_out;
12168     xcb_parts[2].iov_len = sizeof(xcb_out);
12169     xcb_parts[3].iov_base = 0;
12170     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12171 
12172     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12173     return xcb_ret;
12174 }
12175 
12176 xcb_query_best_size_cookie_t
xcb_query_best_size_unchecked(xcb_connection_t * c,uint8_t _class,xcb_drawable_t drawable,uint16_t width,uint16_t height)12177 xcb_query_best_size_unchecked (xcb_connection_t *c,
12178                                uint8_t           _class,
12179                                xcb_drawable_t    drawable,
12180                                uint16_t          width,
12181                                uint16_t          height)
12182 {
12183     static const xcb_protocol_request_t xcb_req = {
12184         .count = 2,
12185         .ext = 0,
12186         .opcode = XCB_QUERY_BEST_SIZE,
12187         .isvoid = 0
12188     };
12189 
12190     struct iovec xcb_parts[4];
12191     xcb_query_best_size_cookie_t xcb_ret;
12192     xcb_query_best_size_request_t xcb_out;
12193 
12194     xcb_out._class = _class;
12195     xcb_out.drawable = drawable;
12196     xcb_out.width = width;
12197     xcb_out.height = height;
12198 
12199     xcb_parts[2].iov_base = (char *) &xcb_out;
12200     xcb_parts[2].iov_len = sizeof(xcb_out);
12201     xcb_parts[3].iov_base = 0;
12202     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12203 
12204     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12205     return xcb_ret;
12206 }
12207 
12208 xcb_query_best_size_reply_t *
xcb_query_best_size_reply(xcb_connection_t * c,xcb_query_best_size_cookie_t cookie,xcb_generic_error_t ** e)12209 xcb_query_best_size_reply (xcb_connection_t              *c,
12210                            xcb_query_best_size_cookie_t   cookie  /**< */,
12211                            xcb_generic_error_t          **e)
12212 {
12213     return (xcb_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12214 }
12215 
12216 int
xcb_query_extension_sizeof(const void * _buffer)12217 xcb_query_extension_sizeof (const void  *_buffer)
12218 {
12219     char *xcb_tmp = (char *)_buffer;
12220     const xcb_query_extension_request_t *_aux = (xcb_query_extension_request_t *)_buffer;
12221     unsigned int xcb_buffer_len = 0;
12222     unsigned int xcb_block_len = 0;
12223     unsigned int xcb_pad = 0;
12224     unsigned int xcb_align_to = 0;
12225 
12226 
12227     xcb_block_len += sizeof(xcb_query_extension_request_t);
12228     xcb_tmp += xcb_block_len;
12229     xcb_buffer_len += xcb_block_len;
12230     xcb_block_len = 0;
12231     /* name */
12232     xcb_block_len += _aux->name_len * sizeof(char);
12233     xcb_tmp += xcb_block_len;
12234     xcb_align_to = ALIGNOF(char);
12235     /* insert padding */
12236     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12237     xcb_buffer_len += xcb_block_len + xcb_pad;
12238     if (0 != xcb_pad) {
12239         xcb_tmp += xcb_pad;
12240         xcb_pad = 0;
12241     }
12242     xcb_block_len = 0;
12243 
12244     return xcb_buffer_len;
12245 }
12246 
12247 xcb_query_extension_cookie_t
xcb_query_extension(xcb_connection_t * c,uint16_t name_len,const char * name)12248 xcb_query_extension (xcb_connection_t *c,
12249                      uint16_t          name_len,
12250                      const char       *name)
12251 {
12252     static const xcb_protocol_request_t xcb_req = {
12253         .count = 4,
12254         .ext = 0,
12255         .opcode = XCB_QUERY_EXTENSION,
12256         .isvoid = 0
12257     };
12258 
12259     struct iovec xcb_parts[6];
12260     xcb_query_extension_cookie_t xcb_ret;
12261     xcb_query_extension_request_t xcb_out;
12262 
12263     xcb_out.pad0 = 0;
12264     xcb_out.name_len = name_len;
12265     memset(xcb_out.pad1, 0, 2);
12266 
12267     xcb_parts[2].iov_base = (char *) &xcb_out;
12268     xcb_parts[2].iov_len = sizeof(xcb_out);
12269     xcb_parts[3].iov_base = 0;
12270     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12271     /* char name */
12272     xcb_parts[4].iov_base = (char *) name;
12273     xcb_parts[4].iov_len = name_len * sizeof(char);
12274     xcb_parts[5].iov_base = 0;
12275     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12276 
12277     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12278     return xcb_ret;
12279 }
12280 
12281 xcb_query_extension_cookie_t
xcb_query_extension_unchecked(xcb_connection_t * c,uint16_t name_len,const char * name)12282 xcb_query_extension_unchecked (xcb_connection_t *c,
12283                                uint16_t          name_len,
12284                                const char       *name)
12285 {
12286     static const xcb_protocol_request_t xcb_req = {
12287         .count = 4,
12288         .ext = 0,
12289         .opcode = XCB_QUERY_EXTENSION,
12290         .isvoid = 0
12291     };
12292 
12293     struct iovec xcb_parts[6];
12294     xcb_query_extension_cookie_t xcb_ret;
12295     xcb_query_extension_request_t xcb_out;
12296 
12297     xcb_out.pad0 = 0;
12298     xcb_out.name_len = name_len;
12299     memset(xcb_out.pad1, 0, 2);
12300 
12301     xcb_parts[2].iov_base = (char *) &xcb_out;
12302     xcb_parts[2].iov_len = sizeof(xcb_out);
12303     xcb_parts[3].iov_base = 0;
12304     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12305     /* char name */
12306     xcb_parts[4].iov_base = (char *) name;
12307     xcb_parts[4].iov_len = name_len * sizeof(char);
12308     xcb_parts[5].iov_base = 0;
12309     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12310 
12311     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12312     return xcb_ret;
12313 }
12314 
12315 xcb_query_extension_reply_t *
xcb_query_extension_reply(xcb_connection_t * c,xcb_query_extension_cookie_t cookie,xcb_generic_error_t ** e)12316 xcb_query_extension_reply (xcb_connection_t              *c,
12317                            xcb_query_extension_cookie_t   cookie  /**< */,
12318                            xcb_generic_error_t          **e)
12319 {
12320     return (xcb_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12321 }
12322 
12323 int
xcb_list_extensions_sizeof(const void * _buffer)12324 xcb_list_extensions_sizeof (const void  *_buffer)
12325 {
12326     char *xcb_tmp = (char *)_buffer;
12327     const xcb_list_extensions_reply_t *_aux = (xcb_list_extensions_reply_t *)_buffer;
12328     unsigned int xcb_buffer_len = 0;
12329     unsigned int xcb_block_len = 0;
12330     unsigned int xcb_pad = 0;
12331     unsigned int xcb_align_to = 0;
12332 
12333     unsigned int i;
12334     unsigned int xcb_tmp_len;
12335 
12336     xcb_block_len += sizeof(xcb_list_extensions_reply_t);
12337     xcb_tmp += xcb_block_len;
12338     xcb_buffer_len += xcb_block_len;
12339     xcb_block_len = 0;
12340     /* names */
12341     for(i=0; i<_aux->names_len; i++) {
12342         xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
12343         xcb_block_len += xcb_tmp_len;
12344         xcb_tmp += xcb_tmp_len;
12345     }
12346     xcb_align_to = ALIGNOF(xcb_str_t);
12347     /* insert padding */
12348     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12349     xcb_buffer_len += xcb_block_len + xcb_pad;
12350     if (0 != xcb_pad) {
12351         xcb_tmp += xcb_pad;
12352         xcb_pad = 0;
12353     }
12354     xcb_block_len = 0;
12355 
12356     return xcb_buffer_len;
12357 }
12358 
12359 xcb_list_extensions_cookie_t
xcb_list_extensions(xcb_connection_t * c)12360 xcb_list_extensions (xcb_connection_t *c)
12361 {
12362     static const xcb_protocol_request_t xcb_req = {
12363         .count = 2,
12364         .ext = 0,
12365         .opcode = XCB_LIST_EXTENSIONS,
12366         .isvoid = 0
12367     };
12368 
12369     struct iovec xcb_parts[4];
12370     xcb_list_extensions_cookie_t xcb_ret;
12371     xcb_list_extensions_request_t xcb_out;
12372 
12373     xcb_out.pad0 = 0;
12374 
12375     xcb_parts[2].iov_base = (char *) &xcb_out;
12376     xcb_parts[2].iov_len = sizeof(xcb_out);
12377     xcb_parts[3].iov_base = 0;
12378     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12379 
12380     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12381     return xcb_ret;
12382 }
12383 
12384 xcb_list_extensions_cookie_t
xcb_list_extensions_unchecked(xcb_connection_t * c)12385 xcb_list_extensions_unchecked (xcb_connection_t *c)
12386 {
12387     static const xcb_protocol_request_t xcb_req = {
12388         .count = 2,
12389         .ext = 0,
12390         .opcode = XCB_LIST_EXTENSIONS,
12391         .isvoid = 0
12392     };
12393 
12394     struct iovec xcb_parts[4];
12395     xcb_list_extensions_cookie_t xcb_ret;
12396     xcb_list_extensions_request_t xcb_out;
12397 
12398     xcb_out.pad0 = 0;
12399 
12400     xcb_parts[2].iov_base = (char *) &xcb_out;
12401     xcb_parts[2].iov_len = sizeof(xcb_out);
12402     xcb_parts[3].iov_base = 0;
12403     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12404 
12405     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12406     return xcb_ret;
12407 }
12408 
12409 int
xcb_list_extensions_names_length(const xcb_list_extensions_reply_t * R)12410 xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R)
12411 {
12412     return R->names_len;
12413 }
12414 
12415 xcb_str_iterator_t
xcb_list_extensions_names_iterator(const xcb_list_extensions_reply_t * R)12416 xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R)
12417 {
12418     xcb_str_iterator_t i;
12419     i.data = (xcb_str_t *) (R + 1);
12420     i.rem = R->names_len;
12421     i.index = (char *) i.data - (char *) R;
12422     return i;
12423 }
12424 
12425 xcb_list_extensions_reply_t *
xcb_list_extensions_reply(xcb_connection_t * c,xcb_list_extensions_cookie_t cookie,xcb_generic_error_t ** e)12426 xcb_list_extensions_reply (xcb_connection_t              *c,
12427                            xcb_list_extensions_cookie_t   cookie  /**< */,
12428                            xcb_generic_error_t          **e)
12429 {
12430     return (xcb_list_extensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12431 }
12432 
12433 int
xcb_change_keyboard_mapping_sizeof(const void * _buffer)12434 xcb_change_keyboard_mapping_sizeof (const void  *_buffer)
12435 {
12436     char *xcb_tmp = (char *)_buffer;
12437     const xcb_change_keyboard_mapping_request_t *_aux = (xcb_change_keyboard_mapping_request_t *)_buffer;
12438     unsigned int xcb_buffer_len = 0;
12439     unsigned int xcb_block_len = 0;
12440     unsigned int xcb_pad = 0;
12441     unsigned int xcb_align_to = 0;
12442 
12443 
12444     xcb_block_len += sizeof(xcb_change_keyboard_mapping_request_t);
12445     xcb_tmp += xcb_block_len;
12446     xcb_buffer_len += xcb_block_len;
12447     xcb_block_len = 0;
12448     /* keysyms */
12449     xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t);
12450     xcb_tmp += xcb_block_len;
12451     xcb_align_to = ALIGNOF(xcb_keysym_t);
12452     /* insert padding */
12453     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12454     xcb_buffer_len += xcb_block_len + xcb_pad;
12455     if (0 != xcb_pad) {
12456         xcb_tmp += xcb_pad;
12457         xcb_pad = 0;
12458     }
12459     xcb_block_len = 0;
12460 
12461     return xcb_buffer_len;
12462 }
12463 
12464 xcb_void_cookie_t
xcb_change_keyboard_mapping_checked(xcb_connection_t * c,uint8_t keycode_count,xcb_keycode_t first_keycode,uint8_t keysyms_per_keycode,const xcb_keysym_t * keysyms)12465 xcb_change_keyboard_mapping_checked (xcb_connection_t   *c,
12466                                      uint8_t             keycode_count,
12467                                      xcb_keycode_t       first_keycode,
12468                                      uint8_t             keysyms_per_keycode,
12469                                      const xcb_keysym_t *keysyms)
12470 {
12471     static const xcb_protocol_request_t xcb_req = {
12472         .count = 4,
12473         .ext = 0,
12474         .opcode = XCB_CHANGE_KEYBOARD_MAPPING,
12475         .isvoid = 1
12476     };
12477 
12478     struct iovec xcb_parts[6];
12479     xcb_void_cookie_t xcb_ret;
12480     xcb_change_keyboard_mapping_request_t xcb_out;
12481 
12482     xcb_out.keycode_count = keycode_count;
12483     xcb_out.first_keycode = first_keycode;
12484     xcb_out.keysyms_per_keycode = keysyms_per_keycode;
12485     memset(xcb_out.pad0, 0, 2);
12486 
12487     xcb_parts[2].iov_base = (char *) &xcb_out;
12488     xcb_parts[2].iov_len = sizeof(xcb_out);
12489     xcb_parts[3].iov_base = 0;
12490     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12491     /* xcb_keysym_t keysyms */
12492     xcb_parts[4].iov_base = (char *) keysyms;
12493     xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
12494     xcb_parts[5].iov_base = 0;
12495     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12496 
12497     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12498     return xcb_ret;
12499 }
12500 
12501 xcb_void_cookie_t
xcb_change_keyboard_mapping(xcb_connection_t * c,uint8_t keycode_count,xcb_keycode_t first_keycode,uint8_t keysyms_per_keycode,const xcb_keysym_t * keysyms)12502 xcb_change_keyboard_mapping (xcb_connection_t   *c,
12503                              uint8_t             keycode_count,
12504                              xcb_keycode_t       first_keycode,
12505                              uint8_t             keysyms_per_keycode,
12506                              const xcb_keysym_t *keysyms)
12507 {
12508     static const xcb_protocol_request_t xcb_req = {
12509         .count = 4,
12510         .ext = 0,
12511         .opcode = XCB_CHANGE_KEYBOARD_MAPPING,
12512         .isvoid = 1
12513     };
12514 
12515     struct iovec xcb_parts[6];
12516     xcb_void_cookie_t xcb_ret;
12517     xcb_change_keyboard_mapping_request_t xcb_out;
12518 
12519     xcb_out.keycode_count = keycode_count;
12520     xcb_out.first_keycode = first_keycode;
12521     xcb_out.keysyms_per_keycode = keysyms_per_keycode;
12522     memset(xcb_out.pad0, 0, 2);
12523 
12524     xcb_parts[2].iov_base = (char *) &xcb_out;
12525     xcb_parts[2].iov_len = sizeof(xcb_out);
12526     xcb_parts[3].iov_base = 0;
12527     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12528     /* xcb_keysym_t keysyms */
12529     xcb_parts[4].iov_base = (char *) keysyms;
12530     xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
12531     xcb_parts[5].iov_base = 0;
12532     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12533 
12534     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12535     return xcb_ret;
12536 }
12537 
12538 xcb_keysym_t *
xcb_change_keyboard_mapping_keysyms(const xcb_change_keyboard_mapping_request_t * R)12539 xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R)
12540 {
12541     return (xcb_keysym_t *) (R + 1);
12542 }
12543 
12544 int
xcb_change_keyboard_mapping_keysyms_length(const xcb_change_keyboard_mapping_request_t * R)12545 xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R)
12546 {
12547     return (R->keycode_count * R->keysyms_per_keycode);
12548 }
12549 
12550 xcb_generic_iterator_t
xcb_change_keyboard_mapping_keysyms_end(const xcb_change_keyboard_mapping_request_t * R)12551 xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R)
12552 {
12553     xcb_generic_iterator_t i;
12554     i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode));
12555     i.rem = 0;
12556     i.index = (char *) i.data - (char *) R;
12557     return i;
12558 }
12559 
12560 int
xcb_get_keyboard_mapping_sizeof(const void * _buffer)12561 xcb_get_keyboard_mapping_sizeof (const void  *_buffer)
12562 {
12563     char *xcb_tmp = (char *)_buffer;
12564     const xcb_get_keyboard_mapping_reply_t *_aux = (xcb_get_keyboard_mapping_reply_t *)_buffer;
12565     unsigned int xcb_buffer_len = 0;
12566     unsigned int xcb_block_len = 0;
12567     unsigned int xcb_pad = 0;
12568     unsigned int xcb_align_to = 0;
12569 
12570 
12571     xcb_block_len += sizeof(xcb_get_keyboard_mapping_reply_t);
12572     xcb_tmp += xcb_block_len;
12573     xcb_buffer_len += xcb_block_len;
12574     xcb_block_len = 0;
12575     /* keysyms */
12576     xcb_block_len += _aux->length * sizeof(xcb_keysym_t);
12577     xcb_tmp += xcb_block_len;
12578     xcb_align_to = ALIGNOF(xcb_keysym_t);
12579     /* insert padding */
12580     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12581     xcb_buffer_len += xcb_block_len + xcb_pad;
12582     if (0 != xcb_pad) {
12583         xcb_tmp += xcb_pad;
12584         xcb_pad = 0;
12585     }
12586     xcb_block_len = 0;
12587 
12588     return xcb_buffer_len;
12589 }
12590 
12591 xcb_get_keyboard_mapping_cookie_t
xcb_get_keyboard_mapping(xcb_connection_t * c,xcb_keycode_t first_keycode,uint8_t count)12592 xcb_get_keyboard_mapping (xcb_connection_t *c,
12593                           xcb_keycode_t     first_keycode,
12594                           uint8_t           count)
12595 {
12596     static const xcb_protocol_request_t xcb_req = {
12597         .count = 2,
12598         .ext = 0,
12599         .opcode = XCB_GET_KEYBOARD_MAPPING,
12600         .isvoid = 0
12601     };
12602 
12603     struct iovec xcb_parts[4];
12604     xcb_get_keyboard_mapping_cookie_t xcb_ret;
12605     xcb_get_keyboard_mapping_request_t xcb_out;
12606 
12607     xcb_out.pad0 = 0;
12608     xcb_out.first_keycode = first_keycode;
12609     xcb_out.count = count;
12610 
12611     xcb_parts[2].iov_base = (char *) &xcb_out;
12612     xcb_parts[2].iov_len = sizeof(xcb_out);
12613     xcb_parts[3].iov_base = 0;
12614     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12615 
12616     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12617     return xcb_ret;
12618 }
12619 
12620 xcb_get_keyboard_mapping_cookie_t
xcb_get_keyboard_mapping_unchecked(xcb_connection_t * c,xcb_keycode_t first_keycode,uint8_t count)12621 xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c,
12622                                     xcb_keycode_t     first_keycode,
12623                                     uint8_t           count)
12624 {
12625     static const xcb_protocol_request_t xcb_req = {
12626         .count = 2,
12627         .ext = 0,
12628         .opcode = XCB_GET_KEYBOARD_MAPPING,
12629         .isvoid = 0
12630     };
12631 
12632     struct iovec xcb_parts[4];
12633     xcb_get_keyboard_mapping_cookie_t xcb_ret;
12634     xcb_get_keyboard_mapping_request_t xcb_out;
12635 
12636     xcb_out.pad0 = 0;
12637     xcb_out.first_keycode = first_keycode;
12638     xcb_out.count = count;
12639 
12640     xcb_parts[2].iov_base = (char *) &xcb_out;
12641     xcb_parts[2].iov_len = sizeof(xcb_out);
12642     xcb_parts[3].iov_base = 0;
12643     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12644 
12645     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12646     return xcb_ret;
12647 }
12648 
12649 xcb_keysym_t *
xcb_get_keyboard_mapping_keysyms(const xcb_get_keyboard_mapping_reply_t * R)12650 xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R)
12651 {
12652     return (xcb_keysym_t *) (R + 1);
12653 }
12654 
12655 int
xcb_get_keyboard_mapping_keysyms_length(const xcb_get_keyboard_mapping_reply_t * R)12656 xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R)
12657 {
12658     return R->length;
12659 }
12660 
12661 xcb_generic_iterator_t
xcb_get_keyboard_mapping_keysyms_end(const xcb_get_keyboard_mapping_reply_t * R)12662 xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R)
12663 {
12664     xcb_generic_iterator_t i;
12665     i.data = ((xcb_keysym_t *) (R + 1)) + (R->length);
12666     i.rem = 0;
12667     i.index = (char *) i.data - (char *) R;
12668     return i;
12669 }
12670 
12671 xcb_get_keyboard_mapping_reply_t *
xcb_get_keyboard_mapping_reply(xcb_connection_t * c,xcb_get_keyboard_mapping_cookie_t cookie,xcb_generic_error_t ** e)12672 xcb_get_keyboard_mapping_reply (xcb_connection_t                   *c,
12673                                 xcb_get_keyboard_mapping_cookie_t   cookie  /**< */,
12674                                 xcb_generic_error_t               **e)
12675 {
12676     return (xcb_get_keyboard_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12677 }
12678 
12679 int
xcb_change_keyboard_control_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_change_keyboard_control_value_list_t * _aux)12680 xcb_change_keyboard_control_value_list_serialize (void                                           **_buffer,
12681                                                   uint32_t                                         value_mask,
12682                                                   const xcb_change_keyboard_control_value_list_t  *_aux)
12683 {
12684     char *xcb_out = *_buffer;
12685     unsigned int xcb_buffer_len = 0;
12686     unsigned int xcb_align_to = 0;
12687     unsigned int xcb_padding_offset = 0;
12688 
12689     unsigned int xcb_pad = 0;
12690     char xcb_pad0[3] = {0, 0, 0};
12691     struct iovec xcb_parts[9];
12692     unsigned int xcb_parts_idx = 0;
12693     unsigned int xcb_block_len = 0;
12694     unsigned int i;
12695     char *xcb_tmp;
12696 
12697     if(value_mask & XCB_KB_KEY_CLICK_PERCENT) {
12698         /* xcb_change_keyboard_control_value_list_t.key_click_percent */
12699         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_click_percent;
12700         xcb_block_len += sizeof(int32_t);
12701         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
12702         xcb_parts_idx++;
12703         xcb_align_to = ALIGNOF(int32_t);
12704     }
12705     if(value_mask & XCB_KB_BELL_PERCENT) {
12706         /* xcb_change_keyboard_control_value_list_t.bell_percent */
12707         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_percent;
12708         xcb_block_len += sizeof(int32_t);
12709         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
12710         xcb_parts_idx++;
12711         xcb_align_to = ALIGNOF(int32_t);
12712     }
12713     if(value_mask & XCB_KB_BELL_PITCH) {
12714         /* xcb_change_keyboard_control_value_list_t.bell_pitch */
12715         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_pitch;
12716         xcb_block_len += sizeof(int32_t);
12717         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
12718         xcb_parts_idx++;
12719         xcb_align_to = ALIGNOF(int32_t);
12720     }
12721     if(value_mask & XCB_KB_BELL_DURATION) {
12722         /* xcb_change_keyboard_control_value_list_t.bell_duration */
12723         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_duration;
12724         xcb_block_len += sizeof(int32_t);
12725         xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
12726         xcb_parts_idx++;
12727         xcb_align_to = ALIGNOF(int32_t);
12728     }
12729     if(value_mask & XCB_KB_LED) {
12730         /* xcb_change_keyboard_control_value_list_t.led */
12731         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led;
12732         xcb_block_len += sizeof(uint32_t);
12733         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
12734         xcb_parts_idx++;
12735         xcb_align_to = ALIGNOF(uint32_t);
12736     }
12737     if(value_mask & XCB_KB_LED_MODE) {
12738         /* xcb_change_keyboard_control_value_list_t.led_mode */
12739         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led_mode;
12740         xcb_block_len += sizeof(uint32_t);
12741         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
12742         xcb_parts_idx++;
12743         xcb_align_to = ALIGNOF(uint32_t);
12744     }
12745     if(value_mask & XCB_KB_KEY) {
12746         /* xcb_change_keyboard_control_value_list_t.key */
12747         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key;
12748         xcb_block_len += sizeof(xcb_keycode32_t);
12749         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode32_t);
12750         xcb_parts_idx++;
12751         xcb_align_to = ALIGNOF(xcb_keycode32_t);
12752     }
12753     if(value_mask & XCB_KB_AUTO_REPEAT_MODE) {
12754         /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */
12755         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->auto_repeat_mode;
12756         xcb_block_len += sizeof(uint32_t);
12757         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
12758         xcb_parts_idx++;
12759         xcb_align_to = ALIGNOF(uint32_t);
12760     }
12761     /* insert padding */
12762     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12763     xcb_buffer_len += xcb_block_len + xcb_pad;
12764     if (0 != xcb_pad) {
12765         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12766         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12767         xcb_parts_idx++;
12768         xcb_pad = 0;
12769     }
12770     xcb_block_len = 0;
12771     xcb_padding_offset = 0;
12772 
12773     if (NULL == xcb_out) {
12774         /* allocate memory */
12775         xcb_out = malloc(xcb_buffer_len);
12776         *_buffer = xcb_out;
12777     }
12778 
12779     xcb_tmp = xcb_out;
12780     for(i=0; i<xcb_parts_idx; i++) {
12781         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
12782             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
12783         if (0 != xcb_parts[i].iov_len)
12784             xcb_tmp += xcb_parts[i].iov_len;
12785     }
12786 
12787     return xcb_buffer_len;
12788 }
12789 
12790 int
xcb_change_keyboard_control_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_change_keyboard_control_value_list_t * _aux)12791 xcb_change_keyboard_control_value_list_unpack (const void                                *_buffer,
12792                                                uint32_t                                   value_mask,
12793                                                xcb_change_keyboard_control_value_list_t  *_aux)
12794 {
12795     char *xcb_tmp = (char *)_buffer;
12796     unsigned int xcb_buffer_len = 0;
12797     unsigned int xcb_block_len = 0;
12798     unsigned int xcb_pad = 0;
12799     unsigned int xcb_align_to = 0;
12800     unsigned int xcb_padding_offset = 0;
12801 
12802 
12803     if(value_mask & XCB_KB_KEY_CLICK_PERCENT) {
12804         /* xcb_change_keyboard_control_value_list_t.key_click_percent */
12805         _aux->key_click_percent = *(int32_t *)xcb_tmp;
12806         xcb_block_len += sizeof(int32_t);
12807         xcb_tmp += sizeof(int32_t);
12808         xcb_align_to = ALIGNOF(int32_t);
12809     }
12810     if(value_mask & XCB_KB_BELL_PERCENT) {
12811         /* xcb_change_keyboard_control_value_list_t.bell_percent */
12812         _aux->bell_percent = *(int32_t *)xcb_tmp;
12813         xcb_block_len += sizeof(int32_t);
12814         xcb_tmp += sizeof(int32_t);
12815         xcb_align_to = ALIGNOF(int32_t);
12816     }
12817     if(value_mask & XCB_KB_BELL_PITCH) {
12818         /* xcb_change_keyboard_control_value_list_t.bell_pitch */
12819         _aux->bell_pitch = *(int32_t *)xcb_tmp;
12820         xcb_block_len += sizeof(int32_t);
12821         xcb_tmp += sizeof(int32_t);
12822         xcb_align_to = ALIGNOF(int32_t);
12823     }
12824     if(value_mask & XCB_KB_BELL_DURATION) {
12825         /* xcb_change_keyboard_control_value_list_t.bell_duration */
12826         _aux->bell_duration = *(int32_t *)xcb_tmp;
12827         xcb_block_len += sizeof(int32_t);
12828         xcb_tmp += sizeof(int32_t);
12829         xcb_align_to = ALIGNOF(int32_t);
12830     }
12831     if(value_mask & XCB_KB_LED) {
12832         /* xcb_change_keyboard_control_value_list_t.led */
12833         _aux->led = *(uint32_t *)xcb_tmp;
12834         xcb_block_len += sizeof(uint32_t);
12835         xcb_tmp += sizeof(uint32_t);
12836         xcb_align_to = ALIGNOF(uint32_t);
12837     }
12838     if(value_mask & XCB_KB_LED_MODE) {
12839         /* xcb_change_keyboard_control_value_list_t.led_mode */
12840         _aux->led_mode = *(uint32_t *)xcb_tmp;
12841         xcb_block_len += sizeof(uint32_t);
12842         xcb_tmp += sizeof(uint32_t);
12843         xcb_align_to = ALIGNOF(uint32_t);
12844     }
12845     if(value_mask & XCB_KB_KEY) {
12846         /* xcb_change_keyboard_control_value_list_t.key */
12847         _aux->key = *(xcb_keycode32_t *)xcb_tmp;
12848         xcb_block_len += sizeof(xcb_keycode32_t);
12849         xcb_tmp += sizeof(xcb_keycode32_t);
12850         xcb_align_to = ALIGNOF(xcb_keycode32_t);
12851     }
12852     if(value_mask & XCB_KB_AUTO_REPEAT_MODE) {
12853         /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */
12854         _aux->auto_repeat_mode = *(uint32_t *)xcb_tmp;
12855         xcb_block_len += sizeof(uint32_t);
12856         xcb_tmp += sizeof(uint32_t);
12857         xcb_align_to = ALIGNOF(uint32_t);
12858     }
12859     /* insert padding */
12860     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12861     xcb_buffer_len += xcb_block_len + xcb_pad;
12862     if (0 != xcb_pad) {
12863         xcb_tmp += xcb_pad;
12864         xcb_pad = 0;
12865     }
12866     xcb_block_len = 0;
12867     xcb_padding_offset = 0;
12868 
12869     return xcb_buffer_len;
12870 }
12871 
12872 int
xcb_change_keyboard_control_value_list_sizeof(const void * _buffer,uint32_t value_mask)12873 xcb_change_keyboard_control_value_list_sizeof (const void  *_buffer,
12874                                                uint32_t     value_mask)
12875 {
12876     xcb_change_keyboard_control_value_list_t _aux;
12877     return xcb_change_keyboard_control_value_list_unpack(_buffer, value_mask, &_aux);
12878 }
12879 
12880 int
xcb_change_keyboard_control_sizeof(const void * _buffer)12881 xcb_change_keyboard_control_sizeof (const void  *_buffer)
12882 {
12883     char *xcb_tmp = (char *)_buffer;
12884     const xcb_change_keyboard_control_request_t *_aux = (xcb_change_keyboard_control_request_t *)_buffer;
12885     unsigned int xcb_buffer_len = 0;
12886     unsigned int xcb_block_len = 0;
12887     unsigned int xcb_pad = 0;
12888     unsigned int xcb_align_to = 0;
12889 
12890 
12891     xcb_block_len += sizeof(xcb_change_keyboard_control_request_t);
12892     xcb_tmp += xcb_block_len;
12893     xcb_buffer_len += xcb_block_len;
12894     xcb_block_len = 0;
12895     /* value_list */
12896     xcb_block_len += xcb_change_keyboard_control_value_list_sizeof(xcb_tmp, _aux->value_mask);
12897     xcb_tmp += xcb_block_len;
12898     xcb_align_to = ALIGNOF(char);
12899     /* insert padding */
12900     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12901     xcb_buffer_len += xcb_block_len + xcb_pad;
12902     if (0 != xcb_pad) {
12903         xcb_tmp += xcb_pad;
12904         xcb_pad = 0;
12905     }
12906     xcb_block_len = 0;
12907 
12908     return xcb_buffer_len;
12909 }
12910 
12911 xcb_void_cookie_t
xcb_change_keyboard_control_checked(xcb_connection_t * c,uint32_t value_mask,const void * value_list)12912 xcb_change_keyboard_control_checked (xcb_connection_t *c,
12913                                      uint32_t          value_mask,
12914                                      const void       *value_list)
12915 {
12916     static const xcb_protocol_request_t xcb_req = {
12917         .count = 3,
12918         .ext = 0,
12919         .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
12920         .isvoid = 1
12921     };
12922 
12923     struct iovec xcb_parts[5];
12924     xcb_void_cookie_t xcb_ret;
12925     xcb_change_keyboard_control_request_t xcb_out;
12926 
12927     xcb_out.pad0 = 0;
12928     xcb_out.value_mask = value_mask;
12929 
12930     xcb_parts[2].iov_base = (char *) &xcb_out;
12931     xcb_parts[2].iov_len = sizeof(xcb_out);
12932     xcb_parts[3].iov_base = 0;
12933     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12934     /* xcb_change_keyboard_control_value_list_t value_list */
12935     xcb_parts[4].iov_base = (char *) value_list;
12936     xcb_parts[4].iov_len =
12937       xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask);
12938 
12939     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12940     return xcb_ret;
12941 }
12942 
12943 xcb_void_cookie_t
xcb_change_keyboard_control(xcb_connection_t * c,uint32_t value_mask,const void * value_list)12944 xcb_change_keyboard_control (xcb_connection_t *c,
12945                              uint32_t          value_mask,
12946                              const void       *value_list)
12947 {
12948     static const xcb_protocol_request_t xcb_req = {
12949         .count = 3,
12950         .ext = 0,
12951         .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
12952         .isvoid = 1
12953     };
12954 
12955     struct iovec xcb_parts[5];
12956     xcb_void_cookie_t xcb_ret;
12957     xcb_change_keyboard_control_request_t xcb_out;
12958 
12959     xcb_out.pad0 = 0;
12960     xcb_out.value_mask = value_mask;
12961 
12962     xcb_parts[2].iov_base = (char *) &xcb_out;
12963     xcb_parts[2].iov_len = sizeof(xcb_out);
12964     xcb_parts[3].iov_base = 0;
12965     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12966     /* xcb_change_keyboard_control_value_list_t value_list */
12967     xcb_parts[4].iov_base = (char *) value_list;
12968     xcb_parts[4].iov_len =
12969       xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask);
12970 
12971     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12972     return xcb_ret;
12973 }
12974 
12975 xcb_void_cookie_t
xcb_change_keyboard_control_aux_checked(xcb_connection_t * c,uint32_t value_mask,const xcb_change_keyboard_control_value_list_t * value_list)12976 xcb_change_keyboard_control_aux_checked (xcb_connection_t                               *c,
12977                                          uint32_t                                        value_mask,
12978                                          const xcb_change_keyboard_control_value_list_t *value_list)
12979 {
12980     static const xcb_protocol_request_t xcb_req = {
12981         .count = 3,
12982         .ext = 0,
12983         .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
12984         .isvoid = 1
12985     };
12986 
12987     struct iovec xcb_parts[5];
12988     xcb_void_cookie_t xcb_ret;
12989     xcb_change_keyboard_control_request_t xcb_out;
12990     void *xcb_aux0 = 0;
12991 
12992     xcb_out.pad0 = 0;
12993     xcb_out.value_mask = value_mask;
12994 
12995     xcb_parts[2].iov_base = (char *) &xcb_out;
12996     xcb_parts[2].iov_len = sizeof(xcb_out);
12997     xcb_parts[3].iov_base = 0;
12998     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12999     /* xcb_change_keyboard_control_value_list_t value_list */
13000     xcb_parts[4].iov_len =
13001       xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list);
13002     xcb_parts[4].iov_base = xcb_aux0;
13003 
13004     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13005     free(xcb_aux0);
13006     return xcb_ret;
13007 }
13008 
13009 xcb_void_cookie_t
xcb_change_keyboard_control_aux(xcb_connection_t * c,uint32_t value_mask,const xcb_change_keyboard_control_value_list_t * value_list)13010 xcb_change_keyboard_control_aux (xcb_connection_t                               *c,
13011                                  uint32_t                                        value_mask,
13012                                  const xcb_change_keyboard_control_value_list_t *value_list)
13013 {
13014     static const xcb_protocol_request_t xcb_req = {
13015         .count = 3,
13016         .ext = 0,
13017         .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
13018         .isvoid = 1
13019     };
13020 
13021     struct iovec xcb_parts[5];
13022     xcb_void_cookie_t xcb_ret;
13023     xcb_change_keyboard_control_request_t xcb_out;
13024     void *xcb_aux0 = 0;
13025 
13026     xcb_out.pad0 = 0;
13027     xcb_out.value_mask = value_mask;
13028 
13029     xcb_parts[2].iov_base = (char *) &xcb_out;
13030     xcb_parts[2].iov_len = sizeof(xcb_out);
13031     xcb_parts[3].iov_base = 0;
13032     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13033     /* xcb_change_keyboard_control_value_list_t value_list */
13034     xcb_parts[4].iov_len =
13035       xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list);
13036     xcb_parts[4].iov_base = xcb_aux0;
13037 
13038     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13039     free(xcb_aux0);
13040     return xcb_ret;
13041 }
13042 
13043 void *
xcb_change_keyboard_control_value_list(const xcb_change_keyboard_control_request_t * R)13044 xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R)
13045 {
13046     return (void *) (R + 1);
13047 }
13048 
13049 xcb_get_keyboard_control_cookie_t
xcb_get_keyboard_control(xcb_connection_t * c)13050 xcb_get_keyboard_control (xcb_connection_t *c)
13051 {
13052     static const xcb_protocol_request_t xcb_req = {
13053         .count = 2,
13054         .ext = 0,
13055         .opcode = XCB_GET_KEYBOARD_CONTROL,
13056         .isvoid = 0
13057     };
13058 
13059     struct iovec xcb_parts[4];
13060     xcb_get_keyboard_control_cookie_t xcb_ret;
13061     xcb_get_keyboard_control_request_t xcb_out;
13062 
13063     xcb_out.pad0 = 0;
13064 
13065     xcb_parts[2].iov_base = (char *) &xcb_out;
13066     xcb_parts[2].iov_len = sizeof(xcb_out);
13067     xcb_parts[3].iov_base = 0;
13068     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13069 
13070     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13071     return xcb_ret;
13072 }
13073 
13074 xcb_get_keyboard_control_cookie_t
xcb_get_keyboard_control_unchecked(xcb_connection_t * c)13075 xcb_get_keyboard_control_unchecked (xcb_connection_t *c)
13076 {
13077     static const xcb_protocol_request_t xcb_req = {
13078         .count = 2,
13079         .ext = 0,
13080         .opcode = XCB_GET_KEYBOARD_CONTROL,
13081         .isvoid = 0
13082     };
13083 
13084     struct iovec xcb_parts[4];
13085     xcb_get_keyboard_control_cookie_t xcb_ret;
13086     xcb_get_keyboard_control_request_t xcb_out;
13087 
13088     xcb_out.pad0 = 0;
13089 
13090     xcb_parts[2].iov_base = (char *) &xcb_out;
13091     xcb_parts[2].iov_len = sizeof(xcb_out);
13092     xcb_parts[3].iov_base = 0;
13093     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13094 
13095     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13096     return xcb_ret;
13097 }
13098 
13099 xcb_get_keyboard_control_reply_t *
xcb_get_keyboard_control_reply(xcb_connection_t * c,xcb_get_keyboard_control_cookie_t cookie,xcb_generic_error_t ** e)13100 xcb_get_keyboard_control_reply (xcb_connection_t                   *c,
13101                                 xcb_get_keyboard_control_cookie_t   cookie  /**< */,
13102                                 xcb_generic_error_t               **e)
13103 {
13104     return (xcb_get_keyboard_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
13105 }
13106 
13107 xcb_void_cookie_t
xcb_bell_checked(xcb_connection_t * c,int8_t percent)13108 xcb_bell_checked (xcb_connection_t *c,
13109                   int8_t            percent)
13110 {
13111     static const xcb_protocol_request_t xcb_req = {
13112         .count = 2,
13113         .ext = 0,
13114         .opcode = XCB_BELL,
13115         .isvoid = 1
13116     };
13117 
13118     struct iovec xcb_parts[4];
13119     xcb_void_cookie_t xcb_ret;
13120     xcb_bell_request_t xcb_out;
13121 
13122     xcb_out.percent = percent;
13123 
13124     xcb_parts[2].iov_base = (char *) &xcb_out;
13125     xcb_parts[2].iov_len = sizeof(xcb_out);
13126     xcb_parts[3].iov_base = 0;
13127     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13128 
13129     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13130     return xcb_ret;
13131 }
13132 
13133 xcb_void_cookie_t
xcb_bell(xcb_connection_t * c,int8_t percent)13134 xcb_bell (xcb_connection_t *c,
13135           int8_t            percent)
13136 {
13137     static const xcb_protocol_request_t xcb_req = {
13138         .count = 2,
13139         .ext = 0,
13140         .opcode = XCB_BELL,
13141         .isvoid = 1
13142     };
13143 
13144     struct iovec xcb_parts[4];
13145     xcb_void_cookie_t xcb_ret;
13146     xcb_bell_request_t xcb_out;
13147 
13148     xcb_out.percent = percent;
13149 
13150     xcb_parts[2].iov_base = (char *) &xcb_out;
13151     xcb_parts[2].iov_len = sizeof(xcb_out);
13152     xcb_parts[3].iov_base = 0;
13153     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13154 
13155     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13156     return xcb_ret;
13157 }
13158 
13159 xcb_void_cookie_t
xcb_change_pointer_control_checked(xcb_connection_t * c,int16_t acceleration_numerator,int16_t acceleration_denominator,int16_t threshold,uint8_t do_acceleration,uint8_t do_threshold)13160 xcb_change_pointer_control_checked (xcb_connection_t *c,
13161                                     int16_t           acceleration_numerator,
13162                                     int16_t           acceleration_denominator,
13163                                     int16_t           threshold,
13164                                     uint8_t           do_acceleration,
13165                                     uint8_t           do_threshold)
13166 {
13167     static const xcb_protocol_request_t xcb_req = {
13168         .count = 2,
13169         .ext = 0,
13170         .opcode = XCB_CHANGE_POINTER_CONTROL,
13171         .isvoid = 1
13172     };
13173 
13174     struct iovec xcb_parts[4];
13175     xcb_void_cookie_t xcb_ret;
13176     xcb_change_pointer_control_request_t xcb_out;
13177 
13178     xcb_out.pad0 = 0;
13179     xcb_out.acceleration_numerator = acceleration_numerator;
13180     xcb_out.acceleration_denominator = acceleration_denominator;
13181     xcb_out.threshold = threshold;
13182     xcb_out.do_acceleration = do_acceleration;
13183     xcb_out.do_threshold = do_threshold;
13184 
13185     xcb_parts[2].iov_base = (char *) &xcb_out;
13186     xcb_parts[2].iov_len = sizeof(xcb_out);
13187     xcb_parts[3].iov_base = 0;
13188     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13189 
13190     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13191     return xcb_ret;
13192 }
13193 
13194 xcb_void_cookie_t
xcb_change_pointer_control(xcb_connection_t * c,int16_t acceleration_numerator,int16_t acceleration_denominator,int16_t threshold,uint8_t do_acceleration,uint8_t do_threshold)13195 xcb_change_pointer_control (xcb_connection_t *c,
13196                             int16_t           acceleration_numerator,
13197                             int16_t           acceleration_denominator,
13198                             int16_t           threshold,
13199                             uint8_t           do_acceleration,
13200                             uint8_t           do_threshold)
13201 {
13202     static const xcb_protocol_request_t xcb_req = {
13203         .count = 2,
13204         .ext = 0,
13205         .opcode = XCB_CHANGE_POINTER_CONTROL,
13206         .isvoid = 1
13207     };
13208 
13209     struct iovec xcb_parts[4];
13210     xcb_void_cookie_t xcb_ret;
13211     xcb_change_pointer_control_request_t xcb_out;
13212 
13213     xcb_out.pad0 = 0;
13214     xcb_out.acceleration_numerator = acceleration_numerator;
13215     xcb_out.acceleration_denominator = acceleration_denominator;
13216     xcb_out.threshold = threshold;
13217     xcb_out.do_acceleration = do_acceleration;
13218     xcb_out.do_threshold = do_threshold;
13219 
13220     xcb_parts[2].iov_base = (char *) &xcb_out;
13221     xcb_parts[2].iov_len = sizeof(xcb_out);
13222     xcb_parts[3].iov_base = 0;
13223     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13224 
13225     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13226     return xcb_ret;
13227 }
13228 
13229 xcb_get_pointer_control_cookie_t
xcb_get_pointer_control(xcb_connection_t * c)13230 xcb_get_pointer_control (xcb_connection_t *c)
13231 {
13232     static const xcb_protocol_request_t xcb_req = {
13233         .count = 2,
13234         .ext = 0,
13235         .opcode = XCB_GET_POINTER_CONTROL,
13236         .isvoid = 0
13237     };
13238 
13239     struct iovec xcb_parts[4];
13240     xcb_get_pointer_control_cookie_t xcb_ret;
13241     xcb_get_pointer_control_request_t xcb_out;
13242 
13243     xcb_out.pad0 = 0;
13244 
13245     xcb_parts[2].iov_base = (char *) &xcb_out;
13246     xcb_parts[2].iov_len = sizeof(xcb_out);
13247     xcb_parts[3].iov_base = 0;
13248     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13249 
13250     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13251     return xcb_ret;
13252 }
13253 
13254 xcb_get_pointer_control_cookie_t
xcb_get_pointer_control_unchecked(xcb_connection_t * c)13255 xcb_get_pointer_control_unchecked (xcb_connection_t *c)
13256 {
13257     static const xcb_protocol_request_t xcb_req = {
13258         .count = 2,
13259         .ext = 0,
13260         .opcode = XCB_GET_POINTER_CONTROL,
13261         .isvoid = 0
13262     };
13263 
13264     struct iovec xcb_parts[4];
13265     xcb_get_pointer_control_cookie_t xcb_ret;
13266     xcb_get_pointer_control_request_t xcb_out;
13267 
13268     xcb_out.pad0 = 0;
13269 
13270     xcb_parts[2].iov_base = (char *) &xcb_out;
13271     xcb_parts[2].iov_len = sizeof(xcb_out);
13272     xcb_parts[3].iov_base = 0;
13273     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13274 
13275     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13276     return xcb_ret;
13277 }
13278 
13279 xcb_get_pointer_control_reply_t *
xcb_get_pointer_control_reply(xcb_connection_t * c,xcb_get_pointer_control_cookie_t cookie,xcb_generic_error_t ** e)13280 xcb_get_pointer_control_reply (xcb_connection_t                  *c,
13281                                xcb_get_pointer_control_cookie_t   cookie  /**< */,
13282                                xcb_generic_error_t              **e)
13283 {
13284     return (xcb_get_pointer_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
13285 }
13286 
13287 xcb_void_cookie_t
xcb_set_screen_saver_checked(xcb_connection_t * c,int16_t timeout,int16_t interval,uint8_t prefer_blanking,uint8_t allow_exposures)13288 xcb_set_screen_saver_checked (xcb_connection_t *c,
13289                               int16_t           timeout,
13290                               int16_t           interval,
13291                               uint8_t           prefer_blanking,
13292                               uint8_t           allow_exposures)
13293 {
13294     static const xcb_protocol_request_t xcb_req = {
13295         .count = 2,
13296         .ext = 0,
13297         .opcode = XCB_SET_SCREEN_SAVER,
13298         .isvoid = 1
13299     };
13300 
13301     struct iovec xcb_parts[4];
13302     xcb_void_cookie_t xcb_ret;
13303     xcb_set_screen_saver_request_t xcb_out;
13304 
13305     xcb_out.pad0 = 0;
13306     xcb_out.timeout = timeout;
13307     xcb_out.interval = interval;
13308     xcb_out.prefer_blanking = prefer_blanking;
13309     xcb_out.allow_exposures = allow_exposures;
13310 
13311     xcb_parts[2].iov_base = (char *) &xcb_out;
13312     xcb_parts[2].iov_len = sizeof(xcb_out);
13313     xcb_parts[3].iov_base = 0;
13314     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13315 
13316     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13317     return xcb_ret;
13318 }
13319 
13320 xcb_void_cookie_t
xcb_set_screen_saver(xcb_connection_t * c,int16_t timeout,int16_t interval,uint8_t prefer_blanking,uint8_t allow_exposures)13321 xcb_set_screen_saver (xcb_connection_t *c,
13322                       int16_t           timeout,
13323                       int16_t           interval,
13324                       uint8_t           prefer_blanking,
13325                       uint8_t           allow_exposures)
13326 {
13327     static const xcb_protocol_request_t xcb_req = {
13328         .count = 2,
13329         .ext = 0,
13330         .opcode = XCB_SET_SCREEN_SAVER,
13331         .isvoid = 1
13332     };
13333 
13334     struct iovec xcb_parts[4];
13335     xcb_void_cookie_t xcb_ret;
13336     xcb_set_screen_saver_request_t xcb_out;
13337 
13338     xcb_out.pad0 = 0;
13339     xcb_out.timeout = timeout;
13340     xcb_out.interval = interval;
13341     xcb_out.prefer_blanking = prefer_blanking;
13342     xcb_out.allow_exposures = allow_exposures;
13343 
13344     xcb_parts[2].iov_base = (char *) &xcb_out;
13345     xcb_parts[2].iov_len = sizeof(xcb_out);
13346     xcb_parts[3].iov_base = 0;
13347     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13348 
13349     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13350     return xcb_ret;
13351 }
13352 
13353 xcb_get_screen_saver_cookie_t
xcb_get_screen_saver(xcb_connection_t * c)13354 xcb_get_screen_saver (xcb_connection_t *c)
13355 {
13356     static const xcb_protocol_request_t xcb_req = {
13357         .count = 2,
13358         .ext = 0,
13359         .opcode = XCB_GET_SCREEN_SAVER,
13360         .isvoid = 0
13361     };
13362 
13363     struct iovec xcb_parts[4];
13364     xcb_get_screen_saver_cookie_t xcb_ret;
13365     xcb_get_screen_saver_request_t xcb_out;
13366 
13367     xcb_out.pad0 = 0;
13368 
13369     xcb_parts[2].iov_base = (char *) &xcb_out;
13370     xcb_parts[2].iov_len = sizeof(xcb_out);
13371     xcb_parts[3].iov_base = 0;
13372     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13373 
13374     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13375     return xcb_ret;
13376 }
13377 
13378 xcb_get_screen_saver_cookie_t
xcb_get_screen_saver_unchecked(xcb_connection_t * c)13379 xcb_get_screen_saver_unchecked (xcb_connection_t *c)
13380 {
13381     static const xcb_protocol_request_t xcb_req = {
13382         .count = 2,
13383         .ext = 0,
13384         .opcode = XCB_GET_SCREEN_SAVER,
13385         .isvoid = 0
13386     };
13387 
13388     struct iovec xcb_parts[4];
13389     xcb_get_screen_saver_cookie_t xcb_ret;
13390     xcb_get_screen_saver_request_t xcb_out;
13391 
13392     xcb_out.pad0 = 0;
13393 
13394     xcb_parts[2].iov_base = (char *) &xcb_out;
13395     xcb_parts[2].iov_len = sizeof(xcb_out);
13396     xcb_parts[3].iov_base = 0;
13397     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13398 
13399     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13400     return xcb_ret;
13401 }
13402 
13403 xcb_get_screen_saver_reply_t *
xcb_get_screen_saver_reply(xcb_connection_t * c,xcb_get_screen_saver_cookie_t cookie,xcb_generic_error_t ** e)13404 xcb_get_screen_saver_reply (xcb_connection_t               *c,
13405                             xcb_get_screen_saver_cookie_t   cookie  /**< */,
13406                             xcb_generic_error_t           **e)
13407 {
13408     return (xcb_get_screen_saver_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
13409 }
13410 
13411 int
xcb_change_hosts_sizeof(const void * _buffer)13412 xcb_change_hosts_sizeof (const void  *_buffer)
13413 {
13414     char *xcb_tmp = (char *)_buffer;
13415     const xcb_change_hosts_request_t *_aux = (xcb_change_hosts_request_t *)_buffer;
13416     unsigned int xcb_buffer_len = 0;
13417     unsigned int xcb_block_len = 0;
13418     unsigned int xcb_pad = 0;
13419     unsigned int xcb_align_to = 0;
13420 
13421 
13422     xcb_block_len += sizeof(xcb_change_hosts_request_t);
13423     xcb_tmp += xcb_block_len;
13424     xcb_buffer_len += xcb_block_len;
13425     xcb_block_len = 0;
13426     /* address */
13427     xcb_block_len += _aux->address_len * sizeof(uint8_t);
13428     xcb_tmp += xcb_block_len;
13429     xcb_align_to = ALIGNOF(uint8_t);
13430     /* insert padding */
13431     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13432     xcb_buffer_len += xcb_block_len + xcb_pad;
13433     if (0 != xcb_pad) {
13434         xcb_tmp += xcb_pad;
13435         xcb_pad = 0;
13436     }
13437     xcb_block_len = 0;
13438 
13439     return xcb_buffer_len;
13440 }
13441 
13442 xcb_void_cookie_t
xcb_change_hosts_checked(xcb_connection_t * c,uint8_t mode,uint8_t family,uint16_t address_len,const uint8_t * address)13443 xcb_change_hosts_checked (xcb_connection_t *c,
13444                           uint8_t           mode,
13445                           uint8_t           family,
13446                           uint16_t          address_len,
13447                           const uint8_t    *address)
13448 {
13449     static const xcb_protocol_request_t xcb_req = {
13450         .count = 4,
13451         .ext = 0,
13452         .opcode = XCB_CHANGE_HOSTS,
13453         .isvoid = 1
13454     };
13455 
13456     struct iovec xcb_parts[6];
13457     xcb_void_cookie_t xcb_ret;
13458     xcb_change_hosts_request_t xcb_out;
13459 
13460     xcb_out.mode = mode;
13461     xcb_out.family = family;
13462     xcb_out.pad0 = 0;
13463     xcb_out.address_len = address_len;
13464 
13465     xcb_parts[2].iov_base = (char *) &xcb_out;
13466     xcb_parts[2].iov_len = sizeof(xcb_out);
13467     xcb_parts[3].iov_base = 0;
13468     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13469     /* uint8_t address */
13470     xcb_parts[4].iov_base = (char *) address;
13471     xcb_parts[4].iov_len = address_len * sizeof(uint8_t);
13472     xcb_parts[5].iov_base = 0;
13473     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
13474 
13475     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13476     return xcb_ret;
13477 }
13478 
13479 xcb_void_cookie_t
xcb_change_hosts(xcb_connection_t * c,uint8_t mode,uint8_t family,uint16_t address_len,const uint8_t * address)13480 xcb_change_hosts (xcb_connection_t *c,
13481                   uint8_t           mode,
13482                   uint8_t           family,
13483                   uint16_t          address_len,
13484                   const uint8_t    *address)
13485 {
13486     static const xcb_protocol_request_t xcb_req = {
13487         .count = 4,
13488         .ext = 0,
13489         .opcode = XCB_CHANGE_HOSTS,
13490         .isvoid = 1
13491     };
13492 
13493     struct iovec xcb_parts[6];
13494     xcb_void_cookie_t xcb_ret;
13495     xcb_change_hosts_request_t xcb_out;
13496 
13497     xcb_out.mode = mode;
13498     xcb_out.family = family;
13499     xcb_out.pad0 = 0;
13500     xcb_out.address_len = address_len;
13501 
13502     xcb_parts[2].iov_base = (char *) &xcb_out;
13503     xcb_parts[2].iov_len = sizeof(xcb_out);
13504     xcb_parts[3].iov_base = 0;
13505     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13506     /* uint8_t address */
13507     xcb_parts[4].iov_base = (char *) address;
13508     xcb_parts[4].iov_len = address_len * sizeof(uint8_t);
13509     xcb_parts[5].iov_base = 0;
13510     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
13511 
13512     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13513     return xcb_ret;
13514 }
13515 
13516 uint8_t *
xcb_change_hosts_address(const xcb_change_hosts_request_t * R)13517 xcb_change_hosts_address (const xcb_change_hosts_request_t *R)
13518 {
13519     return (uint8_t *) (R + 1);
13520 }
13521 
13522 int
xcb_change_hosts_address_length(const xcb_change_hosts_request_t * R)13523 xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R)
13524 {
13525     return R->address_len;
13526 }
13527 
13528 xcb_generic_iterator_t
xcb_change_hosts_address_end(const xcb_change_hosts_request_t * R)13529 xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R)
13530 {
13531     xcb_generic_iterator_t i;
13532     i.data = ((uint8_t *) (R + 1)) + (R->address_len);
13533     i.rem = 0;
13534     i.index = (char *) i.data - (char *) R;
13535     return i;
13536 }
13537 
13538 int
xcb_host_sizeof(const void * _buffer)13539 xcb_host_sizeof (const void  *_buffer)
13540 {
13541     char *xcb_tmp = (char *)_buffer;
13542     const xcb_host_t *_aux = (xcb_host_t *)_buffer;
13543     unsigned int xcb_buffer_len = 0;
13544     unsigned int xcb_block_len = 0;
13545     unsigned int xcb_pad = 0;
13546     unsigned int xcb_align_to = 0;
13547 
13548 
13549     xcb_block_len += sizeof(xcb_host_t);
13550     xcb_tmp += xcb_block_len;
13551     xcb_buffer_len += xcb_block_len;
13552     xcb_block_len = 0;
13553     /* address */
13554     xcb_block_len += _aux->address_len * sizeof(uint8_t);
13555     xcb_tmp += xcb_block_len;
13556     xcb_align_to = ALIGNOF(uint8_t);
13557     xcb_align_to = 4;
13558     /* insert padding */
13559     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13560     xcb_buffer_len += xcb_block_len + xcb_pad;
13561     if (0 != xcb_pad) {
13562         xcb_tmp += xcb_pad;
13563         xcb_pad = 0;
13564     }
13565     xcb_block_len = 0;
13566     /* insert padding */
13567     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13568     xcb_buffer_len += xcb_block_len + xcb_pad;
13569     if (0 != xcb_pad) {
13570         xcb_tmp += xcb_pad;
13571         xcb_pad = 0;
13572     }
13573     xcb_block_len = 0;
13574 
13575     return xcb_buffer_len;
13576 }
13577 
13578 uint8_t *
xcb_host_address(const xcb_host_t * R)13579 xcb_host_address (const xcb_host_t *R)
13580 {
13581     return (uint8_t *) (R + 1);
13582 }
13583 
13584 int
xcb_host_address_length(const xcb_host_t * R)13585 xcb_host_address_length (const xcb_host_t *R)
13586 {
13587     return R->address_len;
13588 }
13589 
13590 xcb_generic_iterator_t
xcb_host_address_end(const xcb_host_t * R)13591 xcb_host_address_end (const xcb_host_t *R)
13592 {
13593     xcb_generic_iterator_t i;
13594     i.data = ((uint8_t *) (R + 1)) + (R->address_len);
13595     i.rem = 0;
13596     i.index = (char *) i.data - (char *) R;
13597     return i;
13598 }
13599 
13600 void
xcb_host_next(xcb_host_iterator_t * i)13601 xcb_host_next (xcb_host_iterator_t *i)
13602 {
13603     xcb_host_t *R = i->data;
13604     xcb_generic_iterator_t child;
13605     child.data = (xcb_host_t *)(((char *)R) + xcb_host_sizeof(R));
13606     i->index = (char *) child.data - (char *) i->data;
13607     --i->rem;
13608     i->data = (xcb_host_t *) child.data;
13609 }
13610 
13611 xcb_generic_iterator_t
xcb_host_end(xcb_host_iterator_t i)13612 xcb_host_end (xcb_host_iterator_t i)
13613 {
13614     xcb_generic_iterator_t ret;
13615     while(i.rem > 0)
13616         xcb_host_next(&i);
13617     ret.data = i.data;
13618     ret.rem = i.rem;
13619     ret.index = i.index;
13620     return ret;
13621 }
13622 
13623 int
xcb_list_hosts_sizeof(const void * _buffer)13624 xcb_list_hosts_sizeof (const void  *_buffer)
13625 {
13626     char *xcb_tmp = (char *)_buffer;
13627     const xcb_list_hosts_reply_t *_aux = (xcb_list_hosts_reply_t *)_buffer;
13628     unsigned int xcb_buffer_len = 0;
13629     unsigned int xcb_block_len = 0;
13630     unsigned int xcb_pad = 0;
13631     unsigned int xcb_align_to = 0;
13632 
13633     unsigned int i;
13634     unsigned int xcb_tmp_len;
13635 
13636     xcb_block_len += sizeof(xcb_list_hosts_reply_t);
13637     xcb_tmp += xcb_block_len;
13638     xcb_buffer_len += xcb_block_len;
13639     xcb_block_len = 0;
13640     /* hosts */
13641     for(i=0; i<_aux->hosts_len; i++) {
13642         xcb_tmp_len = xcb_host_sizeof(xcb_tmp);
13643         xcb_block_len += xcb_tmp_len;
13644         xcb_tmp += xcb_tmp_len;
13645     }
13646     xcb_align_to = ALIGNOF(xcb_host_t);
13647     /* insert padding */
13648     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13649     xcb_buffer_len += xcb_block_len + xcb_pad;
13650     if (0 != xcb_pad) {
13651         xcb_tmp += xcb_pad;
13652         xcb_pad = 0;
13653     }
13654     xcb_block_len = 0;
13655 
13656     return xcb_buffer_len;
13657 }
13658 
13659 xcb_list_hosts_cookie_t
xcb_list_hosts(xcb_connection_t * c)13660 xcb_list_hosts (xcb_connection_t *c)
13661 {
13662     static const xcb_protocol_request_t xcb_req = {
13663         .count = 2,
13664         .ext = 0,
13665         .opcode = XCB_LIST_HOSTS,
13666         .isvoid = 0
13667     };
13668 
13669     struct iovec xcb_parts[4];
13670     xcb_list_hosts_cookie_t xcb_ret;
13671     xcb_list_hosts_request_t xcb_out;
13672 
13673     xcb_out.pad0 = 0;
13674 
13675     xcb_parts[2].iov_base = (char *) &xcb_out;
13676     xcb_parts[2].iov_len = sizeof(xcb_out);
13677     xcb_parts[3].iov_base = 0;
13678     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13679 
13680     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13681     return xcb_ret;
13682 }
13683 
13684 xcb_list_hosts_cookie_t
xcb_list_hosts_unchecked(xcb_connection_t * c)13685 xcb_list_hosts_unchecked (xcb_connection_t *c)
13686 {
13687     static const xcb_protocol_request_t xcb_req = {
13688         .count = 2,
13689         .ext = 0,
13690         .opcode = XCB_LIST_HOSTS,
13691         .isvoid = 0
13692     };
13693 
13694     struct iovec xcb_parts[4];
13695     xcb_list_hosts_cookie_t xcb_ret;
13696     xcb_list_hosts_request_t xcb_out;
13697 
13698     xcb_out.pad0 = 0;
13699 
13700     xcb_parts[2].iov_base = (char *) &xcb_out;
13701     xcb_parts[2].iov_len = sizeof(xcb_out);
13702     xcb_parts[3].iov_base = 0;
13703     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13704 
13705     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13706     return xcb_ret;
13707 }
13708 
13709 int
xcb_list_hosts_hosts_length(const xcb_list_hosts_reply_t * R)13710 xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R)
13711 {
13712     return R->hosts_len;
13713 }
13714 
13715 xcb_host_iterator_t
xcb_list_hosts_hosts_iterator(const xcb_list_hosts_reply_t * R)13716 xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R)
13717 {
13718     xcb_host_iterator_t i;
13719     i.data = (xcb_host_t *) (R + 1);
13720     i.rem = R->hosts_len;
13721     i.index = (char *) i.data - (char *) R;
13722     return i;
13723 }
13724 
13725 xcb_list_hosts_reply_t *
xcb_list_hosts_reply(xcb_connection_t * c,xcb_list_hosts_cookie_t cookie,xcb_generic_error_t ** e)13726 xcb_list_hosts_reply (xcb_connection_t         *c,
13727                       xcb_list_hosts_cookie_t   cookie  /**< */,
13728                       xcb_generic_error_t     **e)
13729 {
13730     return (xcb_list_hosts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
13731 }
13732 
13733 xcb_void_cookie_t
xcb_set_access_control_checked(xcb_connection_t * c,uint8_t mode)13734 xcb_set_access_control_checked (xcb_connection_t *c,
13735                                 uint8_t           mode)
13736 {
13737     static const xcb_protocol_request_t xcb_req = {
13738         .count = 2,
13739         .ext = 0,
13740         .opcode = XCB_SET_ACCESS_CONTROL,
13741         .isvoid = 1
13742     };
13743 
13744     struct iovec xcb_parts[4];
13745     xcb_void_cookie_t xcb_ret;
13746     xcb_set_access_control_request_t xcb_out;
13747 
13748     xcb_out.mode = mode;
13749 
13750     xcb_parts[2].iov_base = (char *) &xcb_out;
13751     xcb_parts[2].iov_len = sizeof(xcb_out);
13752     xcb_parts[3].iov_base = 0;
13753     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13754 
13755     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13756     return xcb_ret;
13757 }
13758 
13759 xcb_void_cookie_t
xcb_set_access_control(xcb_connection_t * c,uint8_t mode)13760 xcb_set_access_control (xcb_connection_t *c,
13761                         uint8_t           mode)
13762 {
13763     static const xcb_protocol_request_t xcb_req = {
13764         .count = 2,
13765         .ext = 0,
13766         .opcode = XCB_SET_ACCESS_CONTROL,
13767         .isvoid = 1
13768     };
13769 
13770     struct iovec xcb_parts[4];
13771     xcb_void_cookie_t xcb_ret;
13772     xcb_set_access_control_request_t xcb_out;
13773 
13774     xcb_out.mode = mode;
13775 
13776     xcb_parts[2].iov_base = (char *) &xcb_out;
13777     xcb_parts[2].iov_len = sizeof(xcb_out);
13778     xcb_parts[3].iov_base = 0;
13779     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13780 
13781     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13782     return xcb_ret;
13783 }
13784 
13785 xcb_void_cookie_t
xcb_set_close_down_mode_checked(xcb_connection_t * c,uint8_t mode)13786 xcb_set_close_down_mode_checked (xcb_connection_t *c,
13787                                  uint8_t           mode)
13788 {
13789     static const xcb_protocol_request_t xcb_req = {
13790         .count = 2,
13791         .ext = 0,
13792         .opcode = XCB_SET_CLOSE_DOWN_MODE,
13793         .isvoid = 1
13794     };
13795 
13796     struct iovec xcb_parts[4];
13797     xcb_void_cookie_t xcb_ret;
13798     xcb_set_close_down_mode_request_t xcb_out;
13799 
13800     xcb_out.mode = mode;
13801 
13802     xcb_parts[2].iov_base = (char *) &xcb_out;
13803     xcb_parts[2].iov_len = sizeof(xcb_out);
13804     xcb_parts[3].iov_base = 0;
13805     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13806 
13807     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13808     return xcb_ret;
13809 }
13810 
13811 xcb_void_cookie_t
xcb_set_close_down_mode(xcb_connection_t * c,uint8_t mode)13812 xcb_set_close_down_mode (xcb_connection_t *c,
13813                          uint8_t           mode)
13814 {
13815     static const xcb_protocol_request_t xcb_req = {
13816         .count = 2,
13817         .ext = 0,
13818         .opcode = XCB_SET_CLOSE_DOWN_MODE,
13819         .isvoid = 1
13820     };
13821 
13822     struct iovec xcb_parts[4];
13823     xcb_void_cookie_t xcb_ret;
13824     xcb_set_close_down_mode_request_t xcb_out;
13825 
13826     xcb_out.mode = mode;
13827 
13828     xcb_parts[2].iov_base = (char *) &xcb_out;
13829     xcb_parts[2].iov_len = sizeof(xcb_out);
13830     xcb_parts[3].iov_base = 0;
13831     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13832 
13833     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13834     return xcb_ret;
13835 }
13836 
13837 xcb_void_cookie_t
xcb_kill_client_checked(xcb_connection_t * c,uint32_t resource)13838 xcb_kill_client_checked (xcb_connection_t *c,
13839                          uint32_t          resource)
13840 {
13841     static const xcb_protocol_request_t xcb_req = {
13842         .count = 2,
13843         .ext = 0,
13844         .opcode = XCB_KILL_CLIENT,
13845         .isvoid = 1
13846     };
13847 
13848     struct iovec xcb_parts[4];
13849     xcb_void_cookie_t xcb_ret;
13850     xcb_kill_client_request_t xcb_out;
13851 
13852     xcb_out.pad0 = 0;
13853     xcb_out.resource = resource;
13854 
13855     xcb_parts[2].iov_base = (char *) &xcb_out;
13856     xcb_parts[2].iov_len = sizeof(xcb_out);
13857     xcb_parts[3].iov_base = 0;
13858     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13859 
13860     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13861     return xcb_ret;
13862 }
13863 
13864 xcb_void_cookie_t
xcb_kill_client(xcb_connection_t * c,uint32_t resource)13865 xcb_kill_client (xcb_connection_t *c,
13866                  uint32_t          resource)
13867 {
13868     static const xcb_protocol_request_t xcb_req = {
13869         .count = 2,
13870         .ext = 0,
13871         .opcode = XCB_KILL_CLIENT,
13872         .isvoid = 1
13873     };
13874 
13875     struct iovec xcb_parts[4];
13876     xcb_void_cookie_t xcb_ret;
13877     xcb_kill_client_request_t xcb_out;
13878 
13879     xcb_out.pad0 = 0;
13880     xcb_out.resource = resource;
13881 
13882     xcb_parts[2].iov_base = (char *) &xcb_out;
13883     xcb_parts[2].iov_len = sizeof(xcb_out);
13884     xcb_parts[3].iov_base = 0;
13885     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13886 
13887     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13888     return xcb_ret;
13889 }
13890 
13891 int
xcb_rotate_properties_sizeof(const void * _buffer)13892 xcb_rotate_properties_sizeof (const void  *_buffer)
13893 {
13894     char *xcb_tmp = (char *)_buffer;
13895     const xcb_rotate_properties_request_t *_aux = (xcb_rotate_properties_request_t *)_buffer;
13896     unsigned int xcb_buffer_len = 0;
13897     unsigned int xcb_block_len = 0;
13898     unsigned int xcb_pad = 0;
13899     unsigned int xcb_align_to = 0;
13900 
13901 
13902     xcb_block_len += sizeof(xcb_rotate_properties_request_t);
13903     xcb_tmp += xcb_block_len;
13904     xcb_buffer_len += xcb_block_len;
13905     xcb_block_len = 0;
13906     /* atoms */
13907     xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t);
13908     xcb_tmp += xcb_block_len;
13909     xcb_align_to = ALIGNOF(xcb_atom_t);
13910     /* insert padding */
13911     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13912     xcb_buffer_len += xcb_block_len + xcb_pad;
13913     if (0 != xcb_pad) {
13914         xcb_tmp += xcb_pad;
13915         xcb_pad = 0;
13916     }
13917     xcb_block_len = 0;
13918 
13919     return xcb_buffer_len;
13920 }
13921 
13922 xcb_void_cookie_t
xcb_rotate_properties_checked(xcb_connection_t * c,xcb_window_t window,uint16_t atoms_len,int16_t delta,const xcb_atom_t * atoms)13923 xcb_rotate_properties_checked (xcb_connection_t *c,
13924                                xcb_window_t      window,
13925                                uint16_t          atoms_len,
13926                                int16_t           delta,
13927                                const xcb_atom_t *atoms)
13928 {
13929     static const xcb_protocol_request_t xcb_req = {
13930         .count = 4,
13931         .ext = 0,
13932         .opcode = XCB_ROTATE_PROPERTIES,
13933         .isvoid = 1
13934     };
13935 
13936     struct iovec xcb_parts[6];
13937     xcb_void_cookie_t xcb_ret;
13938     xcb_rotate_properties_request_t xcb_out;
13939 
13940     xcb_out.pad0 = 0;
13941     xcb_out.window = window;
13942     xcb_out.atoms_len = atoms_len;
13943     xcb_out.delta = delta;
13944 
13945     xcb_parts[2].iov_base = (char *) &xcb_out;
13946     xcb_parts[2].iov_len = sizeof(xcb_out);
13947     xcb_parts[3].iov_base = 0;
13948     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13949     /* xcb_atom_t atoms */
13950     xcb_parts[4].iov_base = (char *) atoms;
13951     xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t);
13952     xcb_parts[5].iov_base = 0;
13953     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
13954 
13955     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
13956     return xcb_ret;
13957 }
13958 
13959 xcb_void_cookie_t
xcb_rotate_properties(xcb_connection_t * c,xcb_window_t window,uint16_t atoms_len,int16_t delta,const xcb_atom_t * atoms)13960 xcb_rotate_properties (xcb_connection_t *c,
13961                        xcb_window_t      window,
13962                        uint16_t          atoms_len,
13963                        int16_t           delta,
13964                        const xcb_atom_t *atoms)
13965 {
13966     static const xcb_protocol_request_t xcb_req = {
13967         .count = 4,
13968         .ext = 0,
13969         .opcode = XCB_ROTATE_PROPERTIES,
13970         .isvoid = 1
13971     };
13972 
13973     struct iovec xcb_parts[6];
13974     xcb_void_cookie_t xcb_ret;
13975     xcb_rotate_properties_request_t xcb_out;
13976 
13977     xcb_out.pad0 = 0;
13978     xcb_out.window = window;
13979     xcb_out.atoms_len = atoms_len;
13980     xcb_out.delta = delta;
13981 
13982     xcb_parts[2].iov_base = (char *) &xcb_out;
13983     xcb_parts[2].iov_len = sizeof(xcb_out);
13984     xcb_parts[3].iov_base = 0;
13985     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
13986     /* xcb_atom_t atoms */
13987     xcb_parts[4].iov_base = (char *) atoms;
13988     xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t);
13989     xcb_parts[5].iov_base = 0;
13990     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
13991 
13992     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
13993     return xcb_ret;
13994 }
13995 
13996 xcb_atom_t *
xcb_rotate_properties_atoms(const xcb_rotate_properties_request_t * R)13997 xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R)
13998 {
13999     return (xcb_atom_t *) (R + 1);
14000 }
14001 
14002 int
xcb_rotate_properties_atoms_length(const xcb_rotate_properties_request_t * R)14003 xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R)
14004 {
14005     return R->atoms_len;
14006 }
14007 
14008 xcb_generic_iterator_t
xcb_rotate_properties_atoms_end(const xcb_rotate_properties_request_t * R)14009 xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R)
14010 {
14011     xcb_generic_iterator_t i;
14012     i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len);
14013     i.rem = 0;
14014     i.index = (char *) i.data - (char *) R;
14015     return i;
14016 }
14017 
14018 xcb_void_cookie_t
xcb_force_screen_saver_checked(xcb_connection_t * c,uint8_t mode)14019 xcb_force_screen_saver_checked (xcb_connection_t *c,
14020                                 uint8_t           mode)
14021 {
14022     static const xcb_protocol_request_t xcb_req = {
14023         .count = 2,
14024         .ext = 0,
14025         .opcode = XCB_FORCE_SCREEN_SAVER,
14026         .isvoid = 1
14027     };
14028 
14029     struct iovec xcb_parts[4];
14030     xcb_void_cookie_t xcb_ret;
14031     xcb_force_screen_saver_request_t xcb_out;
14032 
14033     xcb_out.mode = mode;
14034 
14035     xcb_parts[2].iov_base = (char *) &xcb_out;
14036     xcb_parts[2].iov_len = sizeof(xcb_out);
14037     xcb_parts[3].iov_base = 0;
14038     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14039 
14040     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14041     return xcb_ret;
14042 }
14043 
14044 xcb_void_cookie_t
xcb_force_screen_saver(xcb_connection_t * c,uint8_t mode)14045 xcb_force_screen_saver (xcb_connection_t *c,
14046                         uint8_t           mode)
14047 {
14048     static const xcb_protocol_request_t xcb_req = {
14049         .count = 2,
14050         .ext = 0,
14051         .opcode = XCB_FORCE_SCREEN_SAVER,
14052         .isvoid = 1
14053     };
14054 
14055     struct iovec xcb_parts[4];
14056     xcb_void_cookie_t xcb_ret;
14057     xcb_force_screen_saver_request_t xcb_out;
14058 
14059     xcb_out.mode = mode;
14060 
14061     xcb_parts[2].iov_base = (char *) &xcb_out;
14062     xcb_parts[2].iov_len = sizeof(xcb_out);
14063     xcb_parts[3].iov_base = 0;
14064     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14065 
14066     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14067     return xcb_ret;
14068 }
14069 
14070 int
xcb_set_pointer_mapping_sizeof(const void * _buffer)14071 xcb_set_pointer_mapping_sizeof (const void  *_buffer)
14072 {
14073     char *xcb_tmp = (char *)_buffer;
14074     const xcb_set_pointer_mapping_request_t *_aux = (xcb_set_pointer_mapping_request_t *)_buffer;
14075     unsigned int xcb_buffer_len = 0;
14076     unsigned int xcb_block_len = 0;
14077     unsigned int xcb_pad = 0;
14078     unsigned int xcb_align_to = 0;
14079 
14080 
14081     xcb_block_len += sizeof(xcb_set_pointer_mapping_request_t);
14082     xcb_tmp += xcb_block_len;
14083     xcb_buffer_len += xcb_block_len;
14084     xcb_block_len = 0;
14085     /* map */
14086     xcb_block_len += _aux->map_len * sizeof(uint8_t);
14087     xcb_tmp += xcb_block_len;
14088     xcb_align_to = ALIGNOF(uint8_t);
14089     /* insert padding */
14090     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14091     xcb_buffer_len += xcb_block_len + xcb_pad;
14092     if (0 != xcb_pad) {
14093         xcb_tmp += xcb_pad;
14094         xcb_pad = 0;
14095     }
14096     xcb_block_len = 0;
14097 
14098     return xcb_buffer_len;
14099 }
14100 
14101 xcb_set_pointer_mapping_cookie_t
xcb_set_pointer_mapping(xcb_connection_t * c,uint8_t map_len,const uint8_t * map)14102 xcb_set_pointer_mapping (xcb_connection_t *c,
14103                          uint8_t           map_len,
14104                          const uint8_t    *map)
14105 {
14106     static const xcb_protocol_request_t xcb_req = {
14107         .count = 4,
14108         .ext = 0,
14109         .opcode = XCB_SET_POINTER_MAPPING,
14110         .isvoid = 0
14111     };
14112 
14113     struct iovec xcb_parts[6];
14114     xcb_set_pointer_mapping_cookie_t xcb_ret;
14115     xcb_set_pointer_mapping_request_t xcb_out;
14116 
14117     xcb_out.map_len = map_len;
14118 
14119     xcb_parts[2].iov_base = (char *) &xcb_out;
14120     xcb_parts[2].iov_len = sizeof(xcb_out);
14121     xcb_parts[3].iov_base = 0;
14122     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14123     /* uint8_t map */
14124     xcb_parts[4].iov_base = (char *) map;
14125     xcb_parts[4].iov_len = map_len * sizeof(uint8_t);
14126     xcb_parts[5].iov_base = 0;
14127     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14128 
14129     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14130     return xcb_ret;
14131 }
14132 
14133 xcb_set_pointer_mapping_cookie_t
xcb_set_pointer_mapping_unchecked(xcb_connection_t * c,uint8_t map_len,const uint8_t * map)14134 xcb_set_pointer_mapping_unchecked (xcb_connection_t *c,
14135                                    uint8_t           map_len,
14136                                    const uint8_t    *map)
14137 {
14138     static const xcb_protocol_request_t xcb_req = {
14139         .count = 4,
14140         .ext = 0,
14141         .opcode = XCB_SET_POINTER_MAPPING,
14142         .isvoid = 0
14143     };
14144 
14145     struct iovec xcb_parts[6];
14146     xcb_set_pointer_mapping_cookie_t xcb_ret;
14147     xcb_set_pointer_mapping_request_t xcb_out;
14148 
14149     xcb_out.map_len = map_len;
14150 
14151     xcb_parts[2].iov_base = (char *) &xcb_out;
14152     xcb_parts[2].iov_len = sizeof(xcb_out);
14153     xcb_parts[3].iov_base = 0;
14154     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14155     /* uint8_t map */
14156     xcb_parts[4].iov_base = (char *) map;
14157     xcb_parts[4].iov_len = map_len * sizeof(uint8_t);
14158     xcb_parts[5].iov_base = 0;
14159     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14160 
14161     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14162     return xcb_ret;
14163 }
14164 
14165 xcb_set_pointer_mapping_reply_t *
xcb_set_pointer_mapping_reply(xcb_connection_t * c,xcb_set_pointer_mapping_cookie_t cookie,xcb_generic_error_t ** e)14166 xcb_set_pointer_mapping_reply (xcb_connection_t                  *c,
14167                                xcb_set_pointer_mapping_cookie_t   cookie  /**< */,
14168                                xcb_generic_error_t              **e)
14169 {
14170     return (xcb_set_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
14171 }
14172 
14173 int
xcb_get_pointer_mapping_sizeof(const void * _buffer)14174 xcb_get_pointer_mapping_sizeof (const void  *_buffer)
14175 {
14176     char *xcb_tmp = (char *)_buffer;
14177     const xcb_get_pointer_mapping_reply_t *_aux = (xcb_get_pointer_mapping_reply_t *)_buffer;
14178     unsigned int xcb_buffer_len = 0;
14179     unsigned int xcb_block_len = 0;
14180     unsigned int xcb_pad = 0;
14181     unsigned int xcb_align_to = 0;
14182 
14183 
14184     xcb_block_len += sizeof(xcb_get_pointer_mapping_reply_t);
14185     xcb_tmp += xcb_block_len;
14186     xcb_buffer_len += xcb_block_len;
14187     xcb_block_len = 0;
14188     /* map */
14189     xcb_block_len += _aux->map_len * sizeof(uint8_t);
14190     xcb_tmp += xcb_block_len;
14191     xcb_align_to = ALIGNOF(uint8_t);
14192     /* insert padding */
14193     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14194     xcb_buffer_len += xcb_block_len + xcb_pad;
14195     if (0 != xcb_pad) {
14196         xcb_tmp += xcb_pad;
14197         xcb_pad = 0;
14198     }
14199     xcb_block_len = 0;
14200 
14201     return xcb_buffer_len;
14202 }
14203 
14204 xcb_get_pointer_mapping_cookie_t
xcb_get_pointer_mapping(xcb_connection_t * c)14205 xcb_get_pointer_mapping (xcb_connection_t *c)
14206 {
14207     static const xcb_protocol_request_t xcb_req = {
14208         .count = 2,
14209         .ext = 0,
14210         .opcode = XCB_GET_POINTER_MAPPING,
14211         .isvoid = 0
14212     };
14213 
14214     struct iovec xcb_parts[4];
14215     xcb_get_pointer_mapping_cookie_t xcb_ret;
14216     xcb_get_pointer_mapping_request_t xcb_out;
14217 
14218     xcb_out.pad0 = 0;
14219 
14220     xcb_parts[2].iov_base = (char *) &xcb_out;
14221     xcb_parts[2].iov_len = sizeof(xcb_out);
14222     xcb_parts[3].iov_base = 0;
14223     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14224 
14225     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14226     return xcb_ret;
14227 }
14228 
14229 xcb_get_pointer_mapping_cookie_t
xcb_get_pointer_mapping_unchecked(xcb_connection_t * c)14230 xcb_get_pointer_mapping_unchecked (xcb_connection_t *c)
14231 {
14232     static const xcb_protocol_request_t xcb_req = {
14233         .count = 2,
14234         .ext = 0,
14235         .opcode = XCB_GET_POINTER_MAPPING,
14236         .isvoid = 0
14237     };
14238 
14239     struct iovec xcb_parts[4];
14240     xcb_get_pointer_mapping_cookie_t xcb_ret;
14241     xcb_get_pointer_mapping_request_t xcb_out;
14242 
14243     xcb_out.pad0 = 0;
14244 
14245     xcb_parts[2].iov_base = (char *) &xcb_out;
14246     xcb_parts[2].iov_len = sizeof(xcb_out);
14247     xcb_parts[3].iov_base = 0;
14248     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14249 
14250     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14251     return xcb_ret;
14252 }
14253 
14254 uint8_t *
xcb_get_pointer_mapping_map(const xcb_get_pointer_mapping_reply_t * R)14255 xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R)
14256 {
14257     return (uint8_t *) (R + 1);
14258 }
14259 
14260 int
xcb_get_pointer_mapping_map_length(const xcb_get_pointer_mapping_reply_t * R)14261 xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R)
14262 {
14263     return R->map_len;
14264 }
14265 
14266 xcb_generic_iterator_t
xcb_get_pointer_mapping_map_end(const xcb_get_pointer_mapping_reply_t * R)14267 xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R)
14268 {
14269     xcb_generic_iterator_t i;
14270     i.data = ((uint8_t *) (R + 1)) + (R->map_len);
14271     i.rem = 0;
14272     i.index = (char *) i.data - (char *) R;
14273     return i;
14274 }
14275 
14276 xcb_get_pointer_mapping_reply_t *
xcb_get_pointer_mapping_reply(xcb_connection_t * c,xcb_get_pointer_mapping_cookie_t cookie,xcb_generic_error_t ** e)14277 xcb_get_pointer_mapping_reply (xcb_connection_t                  *c,
14278                                xcb_get_pointer_mapping_cookie_t   cookie  /**< */,
14279                                xcb_generic_error_t              **e)
14280 {
14281     return (xcb_get_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
14282 }
14283 
14284 int
xcb_set_modifier_mapping_sizeof(const void * _buffer)14285 xcb_set_modifier_mapping_sizeof (const void  *_buffer)
14286 {
14287     char *xcb_tmp = (char *)_buffer;
14288     const xcb_set_modifier_mapping_request_t *_aux = (xcb_set_modifier_mapping_request_t *)_buffer;
14289     unsigned int xcb_buffer_len = 0;
14290     unsigned int xcb_block_len = 0;
14291     unsigned int xcb_pad = 0;
14292     unsigned int xcb_align_to = 0;
14293 
14294 
14295     xcb_block_len += sizeof(xcb_set_modifier_mapping_request_t);
14296     xcb_tmp += xcb_block_len;
14297     xcb_buffer_len += xcb_block_len;
14298     xcb_block_len = 0;
14299     /* keycodes */
14300     xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t);
14301     xcb_tmp += xcb_block_len;
14302     xcb_align_to = ALIGNOF(xcb_keycode_t);
14303     /* insert padding */
14304     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14305     xcb_buffer_len += xcb_block_len + xcb_pad;
14306     if (0 != xcb_pad) {
14307         xcb_tmp += xcb_pad;
14308         xcb_pad = 0;
14309     }
14310     xcb_block_len = 0;
14311 
14312     return xcb_buffer_len;
14313 }
14314 
14315 xcb_set_modifier_mapping_cookie_t
xcb_set_modifier_mapping(xcb_connection_t * c,uint8_t keycodes_per_modifier,const xcb_keycode_t * keycodes)14316 xcb_set_modifier_mapping (xcb_connection_t    *c,
14317                           uint8_t              keycodes_per_modifier,
14318                           const xcb_keycode_t *keycodes)
14319 {
14320     static const xcb_protocol_request_t xcb_req = {
14321         .count = 4,
14322         .ext = 0,
14323         .opcode = XCB_SET_MODIFIER_MAPPING,
14324         .isvoid = 0
14325     };
14326 
14327     struct iovec xcb_parts[6];
14328     xcb_set_modifier_mapping_cookie_t xcb_ret;
14329     xcb_set_modifier_mapping_request_t xcb_out;
14330 
14331     xcb_out.keycodes_per_modifier = keycodes_per_modifier;
14332 
14333     xcb_parts[2].iov_base = (char *) &xcb_out;
14334     xcb_parts[2].iov_len = sizeof(xcb_out);
14335     xcb_parts[3].iov_base = 0;
14336     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14337     /* xcb_keycode_t keycodes */
14338     xcb_parts[4].iov_base = (char *) keycodes;
14339     xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
14340     xcb_parts[5].iov_base = 0;
14341     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14342 
14343     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14344     return xcb_ret;
14345 }
14346 
14347 xcb_set_modifier_mapping_cookie_t
xcb_set_modifier_mapping_unchecked(xcb_connection_t * c,uint8_t keycodes_per_modifier,const xcb_keycode_t * keycodes)14348 xcb_set_modifier_mapping_unchecked (xcb_connection_t    *c,
14349                                     uint8_t              keycodes_per_modifier,
14350                                     const xcb_keycode_t *keycodes)
14351 {
14352     static const xcb_protocol_request_t xcb_req = {
14353         .count = 4,
14354         .ext = 0,
14355         .opcode = XCB_SET_MODIFIER_MAPPING,
14356         .isvoid = 0
14357     };
14358 
14359     struct iovec xcb_parts[6];
14360     xcb_set_modifier_mapping_cookie_t xcb_ret;
14361     xcb_set_modifier_mapping_request_t xcb_out;
14362 
14363     xcb_out.keycodes_per_modifier = keycodes_per_modifier;
14364 
14365     xcb_parts[2].iov_base = (char *) &xcb_out;
14366     xcb_parts[2].iov_len = sizeof(xcb_out);
14367     xcb_parts[3].iov_base = 0;
14368     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14369     /* xcb_keycode_t keycodes */
14370     xcb_parts[4].iov_base = (char *) keycodes;
14371     xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
14372     xcb_parts[5].iov_base = 0;
14373     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14374 
14375     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14376     return xcb_ret;
14377 }
14378 
14379 xcb_set_modifier_mapping_reply_t *
xcb_set_modifier_mapping_reply(xcb_connection_t * c,xcb_set_modifier_mapping_cookie_t cookie,xcb_generic_error_t ** e)14380 xcb_set_modifier_mapping_reply (xcb_connection_t                   *c,
14381                                 xcb_set_modifier_mapping_cookie_t   cookie  /**< */,
14382                                 xcb_generic_error_t               **e)
14383 {
14384     return (xcb_set_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
14385 }
14386 
14387 int
xcb_get_modifier_mapping_sizeof(const void * _buffer)14388 xcb_get_modifier_mapping_sizeof (const void  *_buffer)
14389 {
14390     char *xcb_tmp = (char *)_buffer;
14391     const xcb_get_modifier_mapping_reply_t *_aux = (xcb_get_modifier_mapping_reply_t *)_buffer;
14392     unsigned int xcb_buffer_len = 0;
14393     unsigned int xcb_block_len = 0;
14394     unsigned int xcb_pad = 0;
14395     unsigned int xcb_align_to = 0;
14396 
14397 
14398     xcb_block_len += sizeof(xcb_get_modifier_mapping_reply_t);
14399     xcb_tmp += xcb_block_len;
14400     xcb_buffer_len += xcb_block_len;
14401     xcb_block_len = 0;
14402     /* keycodes */
14403     xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t);
14404     xcb_tmp += xcb_block_len;
14405     xcb_align_to = ALIGNOF(xcb_keycode_t);
14406     /* insert padding */
14407     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14408     xcb_buffer_len += xcb_block_len + xcb_pad;
14409     if (0 != xcb_pad) {
14410         xcb_tmp += xcb_pad;
14411         xcb_pad = 0;
14412     }
14413     xcb_block_len = 0;
14414 
14415     return xcb_buffer_len;
14416 }
14417 
14418 xcb_get_modifier_mapping_cookie_t
xcb_get_modifier_mapping(xcb_connection_t * c)14419 xcb_get_modifier_mapping (xcb_connection_t *c)
14420 {
14421     static const xcb_protocol_request_t xcb_req = {
14422         .count = 2,
14423         .ext = 0,
14424         .opcode = XCB_GET_MODIFIER_MAPPING,
14425         .isvoid = 0
14426     };
14427 
14428     struct iovec xcb_parts[4];
14429     xcb_get_modifier_mapping_cookie_t xcb_ret;
14430     xcb_get_modifier_mapping_request_t xcb_out;
14431 
14432     xcb_out.pad0 = 0;
14433 
14434     xcb_parts[2].iov_base = (char *) &xcb_out;
14435     xcb_parts[2].iov_len = sizeof(xcb_out);
14436     xcb_parts[3].iov_base = 0;
14437     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14438 
14439     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14440     return xcb_ret;
14441 }
14442 
14443 xcb_get_modifier_mapping_cookie_t
xcb_get_modifier_mapping_unchecked(xcb_connection_t * c)14444 xcb_get_modifier_mapping_unchecked (xcb_connection_t *c)
14445 {
14446     static const xcb_protocol_request_t xcb_req = {
14447         .count = 2,
14448         .ext = 0,
14449         .opcode = XCB_GET_MODIFIER_MAPPING,
14450         .isvoid = 0
14451     };
14452 
14453     struct iovec xcb_parts[4];
14454     xcb_get_modifier_mapping_cookie_t xcb_ret;
14455     xcb_get_modifier_mapping_request_t xcb_out;
14456 
14457     xcb_out.pad0 = 0;
14458 
14459     xcb_parts[2].iov_base = (char *) &xcb_out;
14460     xcb_parts[2].iov_len = sizeof(xcb_out);
14461     xcb_parts[3].iov_base = 0;
14462     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14463 
14464     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14465     return xcb_ret;
14466 }
14467 
14468 xcb_keycode_t *
xcb_get_modifier_mapping_keycodes(const xcb_get_modifier_mapping_reply_t * R)14469 xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R)
14470 {
14471     return (xcb_keycode_t *) (R + 1);
14472 }
14473 
14474 int
xcb_get_modifier_mapping_keycodes_length(const xcb_get_modifier_mapping_reply_t * R)14475 xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R)
14476 {
14477     return (R->keycodes_per_modifier * 8);
14478 }
14479 
14480 xcb_generic_iterator_t
xcb_get_modifier_mapping_keycodes_end(const xcb_get_modifier_mapping_reply_t * R)14481 xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R)
14482 {
14483     xcb_generic_iterator_t i;
14484     i.data = ((xcb_keycode_t *) (R + 1)) + ((R->keycodes_per_modifier * 8));
14485     i.rem = 0;
14486     i.index = (char *) i.data - (char *) R;
14487     return i;
14488 }
14489 
14490 xcb_get_modifier_mapping_reply_t *
xcb_get_modifier_mapping_reply(xcb_connection_t * c,xcb_get_modifier_mapping_cookie_t cookie,xcb_generic_error_t ** e)14491 xcb_get_modifier_mapping_reply (xcb_connection_t                   *c,
14492                                 xcb_get_modifier_mapping_cookie_t   cookie  /**< */,
14493                                 xcb_generic_error_t               **e)
14494 {
14495     return (xcb_get_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
14496 }
14497 
14498 xcb_void_cookie_t
xcb_no_operation_checked(xcb_connection_t * c)14499 xcb_no_operation_checked (xcb_connection_t *c)
14500 {
14501     static const xcb_protocol_request_t xcb_req = {
14502         .count = 2,
14503         .ext = 0,
14504         .opcode = XCB_NO_OPERATION,
14505         .isvoid = 1
14506     };
14507 
14508     struct iovec xcb_parts[4];
14509     xcb_void_cookie_t xcb_ret;
14510     xcb_no_operation_request_t xcb_out;
14511 
14512     xcb_out.pad0 = 0;
14513 
14514     xcb_parts[2].iov_base = (char *) &xcb_out;
14515     xcb_parts[2].iov_len = sizeof(xcb_out);
14516     xcb_parts[3].iov_base = 0;
14517     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14518 
14519     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14520     return xcb_ret;
14521 }
14522 
14523 xcb_void_cookie_t
xcb_no_operation(xcb_connection_t * c)14524 xcb_no_operation (xcb_connection_t *c)
14525 {
14526     static const xcb_protocol_request_t xcb_req = {
14527         .count = 2,
14528         .ext = 0,
14529         .opcode = XCB_NO_OPERATION,
14530         .isvoid = 1
14531     };
14532 
14533     struct iovec xcb_parts[4];
14534     xcb_void_cookie_t xcb_ret;
14535     xcb_no_operation_request_t xcb_out;
14536 
14537     xcb_out.pad0 = 0;
14538 
14539     xcb_parts[2].iov_base = (char *) &xcb_out;
14540     xcb_parts[2].iov_len = sizeof(xcb_out);
14541     xcb_parts[3].iov_base = 0;
14542     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14543 
14544     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
14545     return xcb_ret;
14546 }
14547 
14548