1 /*
2 * This file generated automatically from xinput.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 "xinput.h"
15
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 #include "xfixes.h"
18
19 xcb_extension_t xcb_input_id = { "XInputExtension", 0 };
20
21 void
xcb_input_event_class_next(xcb_input_event_class_iterator_t * i)22 xcb_input_event_class_next (xcb_input_event_class_iterator_t *i)
23 {
24 --i->rem;
25 ++i->data;
26 i->index += sizeof(xcb_input_event_class_t);
27 }
28
29 xcb_generic_iterator_t
xcb_input_event_class_end(xcb_input_event_class_iterator_t i)30 xcb_input_event_class_end (xcb_input_event_class_iterator_t i)
31 {
32 xcb_generic_iterator_t ret;
33 ret.data = i.data + i.rem;
34 ret.index = i.index + ((char *) ret.data - (char *) i.data);
35 ret.rem = 0;
36 return ret;
37 }
38
39 void
xcb_input_key_code_next(xcb_input_key_code_iterator_t * i)40 xcb_input_key_code_next (xcb_input_key_code_iterator_t *i)
41 {
42 --i->rem;
43 ++i->data;
44 i->index += sizeof(xcb_input_key_code_t);
45 }
46
47 xcb_generic_iterator_t
xcb_input_key_code_end(xcb_input_key_code_iterator_t i)48 xcb_input_key_code_end (xcb_input_key_code_iterator_t i)
49 {
50 xcb_generic_iterator_t ret;
51 ret.data = i.data + i.rem;
52 ret.index = i.index + ((char *) ret.data - (char *) i.data);
53 ret.rem = 0;
54 return ret;
55 }
56
57 void
xcb_input_device_id_next(xcb_input_device_id_iterator_t * i)58 xcb_input_device_id_next (xcb_input_device_id_iterator_t *i)
59 {
60 --i->rem;
61 ++i->data;
62 i->index += sizeof(xcb_input_device_id_t);
63 }
64
65 xcb_generic_iterator_t
xcb_input_device_id_end(xcb_input_device_id_iterator_t i)66 xcb_input_device_id_end (xcb_input_device_id_iterator_t i)
67 {
68 xcb_generic_iterator_t ret;
69 ret.data = i.data + i.rem;
70 ret.index = i.index + ((char *) ret.data - (char *) i.data);
71 ret.rem = 0;
72 return ret;
73 }
74
75 void
xcb_input_fp1616_next(xcb_input_fp1616_iterator_t * i)76 xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i)
77 {
78 --i->rem;
79 ++i->data;
80 i->index += sizeof(xcb_input_fp1616_t);
81 }
82
83 xcb_generic_iterator_t
xcb_input_fp1616_end(xcb_input_fp1616_iterator_t i)84 xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i)
85 {
86 xcb_generic_iterator_t ret;
87 ret.data = i.data + i.rem;
88 ret.index = i.index + ((char *) ret.data - (char *) i.data);
89 ret.rem = 0;
90 return ret;
91 }
92
93 void
xcb_input_fp3232_next(xcb_input_fp3232_iterator_t * i)94 xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i)
95 {
96 --i->rem;
97 ++i->data;
98 i->index += sizeof(xcb_input_fp3232_t);
99 }
100
101 xcb_generic_iterator_t
xcb_input_fp3232_end(xcb_input_fp3232_iterator_t i)102 xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i)
103 {
104 xcb_generic_iterator_t ret;
105 ret.data = i.data + i.rem;
106 ret.index = i.index + ((char *) ret.data - (char *) i.data);
107 ret.rem = 0;
108 return ret;
109 }
110
111 int
xcb_input_get_extension_version_sizeof(const void * _buffer)112 xcb_input_get_extension_version_sizeof (const void *_buffer)
113 {
114 char *xcb_tmp = (char *)_buffer;
115 const xcb_input_get_extension_version_request_t *_aux = (xcb_input_get_extension_version_request_t *)_buffer;
116 unsigned int xcb_buffer_len = 0;
117 unsigned int xcb_block_len = 0;
118 unsigned int xcb_pad = 0;
119 unsigned int xcb_align_to = 0;
120
121
122 xcb_block_len += sizeof(xcb_input_get_extension_version_request_t);
123 xcb_tmp += xcb_block_len;
124 xcb_buffer_len += xcb_block_len;
125 xcb_block_len = 0;
126 /* name */
127 xcb_block_len += _aux->name_len * sizeof(char);
128 xcb_tmp += xcb_block_len;
129 xcb_align_to = ALIGNOF(char);
130 /* insert padding */
131 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
132 xcb_buffer_len += xcb_block_len + xcb_pad;
133 if (0 != xcb_pad) {
134 xcb_tmp += xcb_pad;
135 xcb_pad = 0;
136 }
137 xcb_block_len = 0;
138
139 return xcb_buffer_len;
140 }
141
142 xcb_input_get_extension_version_cookie_t
xcb_input_get_extension_version(xcb_connection_t * c,uint16_t name_len,const char * name)143 xcb_input_get_extension_version (xcb_connection_t *c,
144 uint16_t name_len,
145 const char *name)
146 {
147 static const xcb_protocol_request_t xcb_req = {
148 .count = 4,
149 .ext = &xcb_input_id,
150 .opcode = XCB_INPUT_GET_EXTENSION_VERSION,
151 .isvoid = 0
152 };
153
154 struct iovec xcb_parts[6];
155 xcb_input_get_extension_version_cookie_t xcb_ret;
156 xcb_input_get_extension_version_request_t xcb_out;
157
158 xcb_out.name_len = name_len;
159 memset(xcb_out.pad0, 0, 2);
160
161 xcb_parts[2].iov_base = (char *) &xcb_out;
162 xcb_parts[2].iov_len = sizeof(xcb_out);
163 xcb_parts[3].iov_base = 0;
164 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
165 /* char name */
166 xcb_parts[4].iov_base = (char *) name;
167 xcb_parts[4].iov_len = name_len * sizeof(char);
168 xcb_parts[5].iov_base = 0;
169 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
170
171 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
172 return xcb_ret;
173 }
174
175 xcb_input_get_extension_version_cookie_t
xcb_input_get_extension_version_unchecked(xcb_connection_t * c,uint16_t name_len,const char * name)176 xcb_input_get_extension_version_unchecked (xcb_connection_t *c,
177 uint16_t name_len,
178 const char *name)
179 {
180 static const xcb_protocol_request_t xcb_req = {
181 .count = 4,
182 .ext = &xcb_input_id,
183 .opcode = XCB_INPUT_GET_EXTENSION_VERSION,
184 .isvoid = 0
185 };
186
187 struct iovec xcb_parts[6];
188 xcb_input_get_extension_version_cookie_t xcb_ret;
189 xcb_input_get_extension_version_request_t xcb_out;
190
191 xcb_out.name_len = name_len;
192 memset(xcb_out.pad0, 0, 2);
193
194 xcb_parts[2].iov_base = (char *) &xcb_out;
195 xcb_parts[2].iov_len = sizeof(xcb_out);
196 xcb_parts[3].iov_base = 0;
197 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
198 /* char name */
199 xcb_parts[4].iov_base = (char *) name;
200 xcb_parts[4].iov_len = name_len * sizeof(char);
201 xcb_parts[5].iov_base = 0;
202 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
203
204 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
205 return xcb_ret;
206 }
207
208 xcb_input_get_extension_version_reply_t *
xcb_input_get_extension_version_reply(xcb_connection_t * c,xcb_input_get_extension_version_cookie_t cookie,xcb_generic_error_t ** e)209 xcb_input_get_extension_version_reply (xcb_connection_t *c,
210 xcb_input_get_extension_version_cookie_t cookie /**< */,
211 xcb_generic_error_t **e)
212 {
213 return (xcb_input_get_extension_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
214 }
215
216 void
xcb_input_device_info_next(xcb_input_device_info_iterator_t * i)217 xcb_input_device_info_next (xcb_input_device_info_iterator_t *i)
218 {
219 --i->rem;
220 ++i->data;
221 i->index += sizeof(xcb_input_device_info_t);
222 }
223
224 xcb_generic_iterator_t
xcb_input_device_info_end(xcb_input_device_info_iterator_t i)225 xcb_input_device_info_end (xcb_input_device_info_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_input_key_info_next(xcb_input_key_info_iterator_t * i)235 xcb_input_key_info_next (xcb_input_key_info_iterator_t *i)
236 {
237 --i->rem;
238 ++i->data;
239 i->index += sizeof(xcb_input_key_info_t);
240 }
241
242 xcb_generic_iterator_t
xcb_input_key_info_end(xcb_input_key_info_iterator_t i)243 xcb_input_key_info_end (xcb_input_key_info_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_input_button_info_next(xcb_input_button_info_iterator_t * i)253 xcb_input_button_info_next (xcb_input_button_info_iterator_t *i)
254 {
255 --i->rem;
256 ++i->data;
257 i->index += sizeof(xcb_input_button_info_t);
258 }
259
260 xcb_generic_iterator_t
xcb_input_button_info_end(xcb_input_button_info_iterator_t i)261 xcb_input_button_info_end (xcb_input_button_info_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_input_axis_info_next(xcb_input_axis_info_iterator_t * i)271 xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i)
272 {
273 --i->rem;
274 ++i->data;
275 i->index += sizeof(xcb_input_axis_info_t);
276 }
277
278 xcb_generic_iterator_t
xcb_input_axis_info_end(xcb_input_axis_info_iterator_t i)279 xcb_input_axis_info_end (xcb_input_axis_info_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 int
xcb_input_valuator_info_sizeof(const void * _buffer)289 xcb_input_valuator_info_sizeof (const void *_buffer)
290 {
291 char *xcb_tmp = (char *)_buffer;
292 const xcb_input_valuator_info_t *_aux = (xcb_input_valuator_info_t *)_buffer;
293 unsigned int xcb_buffer_len = 0;
294 unsigned int xcb_block_len = 0;
295 unsigned int xcb_pad = 0;
296 unsigned int xcb_align_to = 0;
297
298
299 xcb_block_len += sizeof(xcb_input_valuator_info_t);
300 xcb_tmp += xcb_block_len;
301 xcb_buffer_len += xcb_block_len;
302 xcb_block_len = 0;
303 /* axes */
304 xcb_block_len += _aux->axes_len * sizeof(xcb_input_axis_info_t);
305 xcb_tmp += xcb_block_len;
306 xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
307 /* insert padding */
308 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
309 xcb_buffer_len += xcb_block_len + xcb_pad;
310 if (0 != xcb_pad) {
311 xcb_tmp += xcb_pad;
312 xcb_pad = 0;
313 }
314 xcb_block_len = 0;
315
316 return xcb_buffer_len;
317 }
318
319 xcb_input_axis_info_t *
xcb_input_valuator_info_axes(const xcb_input_valuator_info_t * R)320 xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R)
321 {
322 return (xcb_input_axis_info_t *) (R + 1);
323 }
324
325 int
xcb_input_valuator_info_axes_length(const xcb_input_valuator_info_t * R)326 xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R)
327 {
328 return R->axes_len;
329 }
330
331 xcb_input_axis_info_iterator_t
xcb_input_valuator_info_axes_iterator(const xcb_input_valuator_info_t * R)332 xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R)
333 {
334 xcb_input_axis_info_iterator_t i;
335 i.data = (xcb_input_axis_info_t *) (R + 1);
336 i.rem = R->axes_len;
337 i.index = (char *) i.data - (char *) R;
338 return i;
339 }
340
341 void
xcb_input_valuator_info_next(xcb_input_valuator_info_iterator_t * i)342 xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i)
343 {
344 xcb_input_valuator_info_t *R = i->data;
345 xcb_generic_iterator_t child;
346 child.data = (xcb_input_valuator_info_t *)(((char *)R) + xcb_input_valuator_info_sizeof(R));
347 i->index = (char *) child.data - (char *) i->data;
348 --i->rem;
349 i->data = (xcb_input_valuator_info_t *) child.data;
350 }
351
352 xcb_generic_iterator_t
xcb_input_valuator_info_end(xcb_input_valuator_info_iterator_t i)353 xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i)
354 {
355 xcb_generic_iterator_t ret;
356 while(i.rem > 0)
357 xcb_input_valuator_info_next(&i);
358 ret.data = i.data;
359 ret.rem = i.rem;
360 ret.index = i.index;
361 return ret;
362 }
363
364 xcb_input_axis_info_t *
xcb_input_input_info_info_valuator_axes(const xcb_input_input_info_info_t * S)365 xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S)
366 {
367 return S->valuator.axes;
368 }
369
370 int
xcb_input_input_info_info_valuator_axes_length(const xcb_input_input_info_t * R,const xcb_input_input_info_info_t * S)371 xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R,
372 const xcb_input_input_info_info_t *S)
373 {
374 return S->valuator.axes_len;
375 }
376
377 xcb_input_axis_info_iterator_t
xcb_input_input_info_info_valuator_axes_iterator(const xcb_input_input_info_t * R,const xcb_input_input_info_info_t * S)378 xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R,
379 const xcb_input_input_info_info_t *S)
380 {
381 xcb_input_axis_info_iterator_t i;
382 i.data = S->valuator.axes;
383 i.rem = S->valuator.axes_len;
384 i.index = (char *) i.data - (char *) S;
385 return i;
386 }
387
388 int
xcb_input_input_info_info_serialize(void ** _buffer,uint8_t class_id,const xcb_input_input_info_info_t * _aux)389 xcb_input_input_info_info_serialize (void **_buffer,
390 uint8_t class_id,
391 const xcb_input_input_info_info_t *_aux)
392 {
393 char *xcb_out = *_buffer;
394 unsigned int xcb_buffer_len = 0;
395 unsigned int xcb_align_to = 0;
396 unsigned int xcb_padding_offset = 2;
397
398 unsigned int xcb_pad = 0;
399 char xcb_pad0[3] = {0, 0, 0};
400 struct iovec xcb_parts[11];
401 unsigned int xcb_parts_idx = 0;
402 unsigned int xcb_block_len = 0;
403 unsigned int i;
404 char *xcb_tmp;
405
406 if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
407 /* xcb_input_input_info_info_t.key.min_keycode */
408 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.min_keycode;
409 xcb_block_len += sizeof(xcb_input_key_code_t);
410 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
411 xcb_parts_idx++;
412 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
413 /* xcb_input_input_info_info_t.key.max_keycode */
414 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.max_keycode;
415 xcb_block_len += sizeof(xcb_input_key_code_t);
416 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
417 xcb_parts_idx++;
418 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
419 /* xcb_input_input_info_info_t.key.num_keys */
420 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
421 xcb_block_len += sizeof(uint16_t);
422 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
423 xcb_parts_idx++;
424 xcb_align_to = ALIGNOF(uint16_t);
425 /* xcb_input_input_info_info_t.key.pad0 */
426 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
427 xcb_block_len += sizeof(uint8_t)*2;
428 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
429 xcb_parts_idx++;
430 xcb_align_to = ALIGNOF(uint8_t);
431 }
432 if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
433 /* xcb_input_input_info_info_t.button.num_buttons */
434 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
435 xcb_block_len += sizeof(uint16_t);
436 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
437 xcb_parts_idx++;
438 xcb_align_to = ALIGNOF(uint16_t);
439 }
440 if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
441 /* xcb_input_input_info_info_t.valuator.axes_len */
442 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.axes_len;
443 xcb_block_len += sizeof(uint8_t);
444 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
445 xcb_parts_idx++;
446 xcb_align_to = ALIGNOF(uint8_t);
447 /* xcb_input_input_info_info_t.valuator.mode */
448 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
449 xcb_block_len += sizeof(uint8_t);
450 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
451 xcb_parts_idx++;
452 xcb_align_to = ALIGNOF(uint8_t);
453 /* xcb_input_input_info_info_t.valuator.motion_size */
454 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.motion_size;
455 xcb_block_len += sizeof(uint32_t);
456 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
457 xcb_parts_idx++;
458 xcb_align_to = ALIGNOF(uint32_t);
459 /* insert padding */
460 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
461 xcb_buffer_len += xcb_block_len + xcb_pad;
462 if (0 != xcb_pad) {
463 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
464 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
465 xcb_parts_idx++;
466 xcb_pad = 0;
467 }
468 xcb_block_len = 0;
469 xcb_padding_offset = 0;
470 /* axes */
471 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.axes;
472 xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
473 xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
474 xcb_parts_idx++;
475 xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
476 }
477 /* insert padding */
478 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
479 xcb_buffer_len += xcb_block_len + xcb_pad;
480 if (0 != xcb_pad) {
481 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
482 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
483 xcb_parts_idx++;
484 xcb_pad = 0;
485 }
486 xcb_block_len = 0;
487 xcb_padding_offset = 0;
488
489 if (NULL == xcb_out) {
490 /* allocate memory */
491 xcb_out = malloc(xcb_buffer_len);
492 *_buffer = xcb_out;
493 }
494
495 xcb_tmp = xcb_out;
496 for(i=0; i<xcb_parts_idx; i++) {
497 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
498 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
499 if (0 != xcb_parts[i].iov_len)
500 xcb_tmp += xcb_parts[i].iov_len;
501 }
502
503 return xcb_buffer_len;
504 }
505
506 int
xcb_input_input_info_info_unpack(const void * _buffer,uint8_t class_id,xcb_input_input_info_info_t * _aux)507 xcb_input_input_info_info_unpack (const void *_buffer,
508 uint8_t class_id,
509 xcb_input_input_info_info_t *_aux)
510 {
511 char *xcb_tmp = (char *)_buffer;
512 unsigned int xcb_buffer_len = 0;
513 unsigned int xcb_block_len = 0;
514 unsigned int xcb_pad = 0;
515 unsigned int xcb_align_to = 0;
516 unsigned int xcb_padding_offset = 2;
517
518
519 if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
520 /* xcb_input_input_info_info_t.key.min_keycode */
521 _aux->key.min_keycode = *(xcb_input_key_code_t *)xcb_tmp;
522 xcb_block_len += sizeof(xcb_input_key_code_t);
523 xcb_tmp += sizeof(xcb_input_key_code_t);
524 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
525 /* xcb_input_input_info_info_t.key.max_keycode */
526 _aux->key.max_keycode = *(xcb_input_key_code_t *)xcb_tmp;
527 xcb_block_len += sizeof(xcb_input_key_code_t);
528 xcb_tmp += sizeof(xcb_input_key_code_t);
529 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
530 /* xcb_input_input_info_info_t.key.num_keys */
531 _aux->key.num_keys = *(uint16_t *)xcb_tmp;
532 xcb_block_len += sizeof(uint16_t);
533 xcb_tmp += sizeof(uint16_t);
534 xcb_align_to = ALIGNOF(uint16_t);
535 /* xcb_input_input_info_info_t.key.pad0 */
536 _aux->key.pad0[0] = *(uint8_t *)xcb_tmp;
537 _aux->key.pad0[1] = *(uint8_t *)xcb_tmp;
538 xcb_block_len += sizeof(uint8_t) * 2;
539 xcb_tmp += sizeof(uint8_t) * 2;
540 xcb_align_to = ALIGNOF(uint8_t);
541 }
542 if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
543 /* xcb_input_input_info_info_t.button.num_buttons */
544 _aux->button.num_buttons = *(uint16_t *)xcb_tmp;
545 xcb_block_len += sizeof(uint16_t);
546 xcb_tmp += sizeof(uint16_t);
547 xcb_align_to = ALIGNOF(uint16_t);
548 }
549 if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
550 /* xcb_input_input_info_info_t.valuator.axes_len */
551 _aux->valuator.axes_len = *(uint8_t *)xcb_tmp;
552 xcb_block_len += sizeof(uint8_t);
553 xcb_tmp += sizeof(uint8_t);
554 xcb_align_to = ALIGNOF(uint8_t);
555 /* xcb_input_input_info_info_t.valuator.mode */
556 _aux->valuator.mode = *(uint8_t *)xcb_tmp;
557 xcb_block_len += sizeof(uint8_t);
558 xcb_tmp += sizeof(uint8_t);
559 xcb_align_to = ALIGNOF(uint8_t);
560 /* xcb_input_input_info_info_t.valuator.motion_size */
561 _aux->valuator.motion_size = *(uint32_t *)xcb_tmp;
562 xcb_block_len += sizeof(uint32_t);
563 xcb_tmp += sizeof(uint32_t);
564 xcb_align_to = ALIGNOF(uint32_t);
565 /* insert padding */
566 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
567 xcb_buffer_len += xcb_block_len + xcb_pad;
568 if (0 != xcb_pad) {
569 xcb_tmp += xcb_pad;
570 xcb_pad = 0;
571 }
572 xcb_block_len = 0;
573 xcb_padding_offset = 0;
574 /* axes */
575 _aux->valuator.axes = (xcb_input_axis_info_t *)xcb_tmp;
576 xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
577 xcb_tmp += xcb_block_len;
578 xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
579 }
580 /* insert padding */
581 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
582 xcb_buffer_len += xcb_block_len + xcb_pad;
583 if (0 != xcb_pad) {
584 xcb_tmp += xcb_pad;
585 xcb_pad = 0;
586 }
587 xcb_block_len = 0;
588 xcb_padding_offset = 0;
589
590 return xcb_buffer_len;
591 }
592
593 int
xcb_input_input_info_info_sizeof(const void * _buffer,uint8_t class_id)594 xcb_input_input_info_info_sizeof (const void *_buffer,
595 uint8_t class_id)
596 {
597 xcb_input_input_info_info_t _aux;
598 return xcb_input_input_info_info_unpack(_buffer, class_id, &_aux);
599 }
600
601 int
xcb_input_input_info_sizeof(const void * _buffer)602 xcb_input_input_info_sizeof (const void *_buffer)
603 {
604 char *xcb_tmp = (char *)_buffer;
605 const xcb_input_input_info_t *_aux = (xcb_input_input_info_t *)_buffer;
606 unsigned int xcb_buffer_len = 0;
607 unsigned int xcb_block_len = 0;
608 unsigned int xcb_pad = 0;
609 unsigned int xcb_align_to = 0;
610
611
612 xcb_block_len += sizeof(xcb_input_input_info_t);
613 xcb_tmp += xcb_block_len;
614 xcb_buffer_len += xcb_block_len;
615 xcb_block_len = 0;
616 /* info */
617 xcb_block_len += xcb_input_input_info_info_sizeof(xcb_tmp, _aux->class_id);
618 xcb_tmp += xcb_block_len;
619 xcb_align_to = ALIGNOF(char);
620 /* insert padding */
621 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
622 xcb_buffer_len += xcb_block_len + xcb_pad;
623 if (0 != xcb_pad) {
624 xcb_tmp += xcb_pad;
625 xcb_pad = 0;
626 }
627 xcb_block_len = 0;
628
629 return xcb_buffer_len;
630 }
631
632 void *
xcb_input_input_info_info(const xcb_input_input_info_t * R)633 xcb_input_input_info_info (const xcb_input_input_info_t *R)
634 {
635 return (void *) (R + 1);
636 }
637
638 void
xcb_input_input_info_next(xcb_input_input_info_iterator_t * i)639 xcb_input_input_info_next (xcb_input_input_info_iterator_t *i)
640 {
641 xcb_input_input_info_t *R = i->data;
642 xcb_generic_iterator_t child;
643 child.data = (xcb_input_input_info_t *)(((char *)R) + xcb_input_input_info_sizeof(R));
644 i->index = (char *) child.data - (char *) i->data;
645 --i->rem;
646 i->data = (xcb_input_input_info_t *) child.data;
647 }
648
649 xcb_generic_iterator_t
xcb_input_input_info_end(xcb_input_input_info_iterator_t i)650 xcb_input_input_info_end (xcb_input_input_info_iterator_t i)
651 {
652 xcb_generic_iterator_t ret;
653 while(i.rem > 0)
654 xcb_input_input_info_next(&i);
655 ret.data = i.data;
656 ret.rem = i.rem;
657 ret.index = i.index;
658 return ret;
659 }
660
661 int
xcb_input_device_name_sizeof(const void * _buffer)662 xcb_input_device_name_sizeof (const void *_buffer)
663 {
664 char *xcb_tmp = (char *)_buffer;
665 const xcb_input_device_name_t *_aux = (xcb_input_device_name_t *)_buffer;
666 unsigned int xcb_buffer_len = 0;
667 unsigned int xcb_block_len = 0;
668 unsigned int xcb_pad = 0;
669 unsigned int xcb_align_to = 0;
670
671
672 xcb_block_len += sizeof(xcb_input_device_name_t);
673 xcb_tmp += xcb_block_len;
674 xcb_buffer_len += xcb_block_len;
675 xcb_block_len = 0;
676 /* string */
677 xcb_block_len += _aux->len * sizeof(char);
678 xcb_tmp += xcb_block_len;
679 xcb_align_to = ALIGNOF(char);
680 /* insert padding */
681 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
682 xcb_buffer_len += xcb_block_len + xcb_pad;
683 if (0 != xcb_pad) {
684 xcb_tmp += xcb_pad;
685 xcb_pad = 0;
686 }
687 xcb_block_len = 0;
688
689 return xcb_buffer_len;
690 }
691
692 char *
xcb_input_device_name_string(const xcb_input_device_name_t * R)693 xcb_input_device_name_string (const xcb_input_device_name_t *R)
694 {
695 return (char *) (R + 1);
696 }
697
698 int
xcb_input_device_name_string_length(const xcb_input_device_name_t * R)699 xcb_input_device_name_string_length (const xcb_input_device_name_t *R)
700 {
701 return R->len;
702 }
703
704 xcb_generic_iterator_t
xcb_input_device_name_string_end(const xcb_input_device_name_t * R)705 xcb_input_device_name_string_end (const xcb_input_device_name_t *R)
706 {
707 xcb_generic_iterator_t i;
708 i.data = ((char *) (R + 1)) + (R->len);
709 i.rem = 0;
710 i.index = (char *) i.data - (char *) R;
711 return i;
712 }
713
714 void
xcb_input_device_name_next(xcb_input_device_name_iterator_t * i)715 xcb_input_device_name_next (xcb_input_device_name_iterator_t *i)
716 {
717 xcb_input_device_name_t *R = i->data;
718 xcb_generic_iterator_t child;
719 child.data = (xcb_input_device_name_t *)(((char *)R) + xcb_input_device_name_sizeof(R));
720 i->index = (char *) child.data - (char *) i->data;
721 --i->rem;
722 i->data = (xcb_input_device_name_t *) child.data;
723 }
724
725 xcb_generic_iterator_t
xcb_input_device_name_end(xcb_input_device_name_iterator_t i)726 xcb_input_device_name_end (xcb_input_device_name_iterator_t i)
727 {
728 xcb_generic_iterator_t ret;
729 while(i.rem > 0)
730 xcb_input_device_name_next(&i);
731 ret.data = i.data;
732 ret.rem = i.rem;
733 ret.index = i.index;
734 return ret;
735 }
736
737 int
xcb_input_list_input_devices_sizeof(const void * _buffer)738 xcb_input_list_input_devices_sizeof (const void *_buffer)
739 {
740 char *xcb_tmp = (char *)_buffer;
741 const xcb_input_list_input_devices_reply_t *_aux = (xcb_input_list_input_devices_reply_t *)_buffer;
742 unsigned int xcb_buffer_len = 0;
743 unsigned int xcb_block_len = 0;
744 unsigned int xcb_pad = 0;
745 unsigned int xcb_align_to = 0;
746
747 int xcb_pre_tmp_1; /* sumof length */
748 int xcb_pre_tmp_2; /* sumof loop counter */
749 int64_t xcb_pre_tmp_3; /* sumof sum */
750 const xcb_input_device_info_t* xcb_pre_tmp_4; /* sumof list ptr */
751 unsigned int i;
752 unsigned int xcb_tmp_len;
753
754 xcb_block_len += sizeof(xcb_input_list_input_devices_reply_t);
755 xcb_tmp += xcb_block_len;
756 xcb_buffer_len += xcb_block_len;
757 xcb_block_len = 0;
758 /* devices */
759 xcb_block_len += _aux->devices_len * sizeof(xcb_input_device_info_t);
760 xcb_tmp += xcb_block_len;
761 xcb_align_to = ALIGNOF(xcb_input_device_info_t);
762 /* insert padding */
763 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
764 xcb_buffer_len += xcb_block_len + xcb_pad;
765 if (0 != xcb_pad) {
766 xcb_tmp += xcb_pad;
767 xcb_pad = 0;
768 }
769 xcb_block_len = 0;
770 /* infos */
771 /* sumof start */
772 xcb_pre_tmp_1 = _aux->devices_len;
773 xcb_pre_tmp_3 = 0;
774 xcb_pre_tmp_4 = xcb_input_list_input_devices_devices(_aux);
775 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
776 xcb_pre_tmp_3 += xcb_pre_tmp_4->num_class_info;
777 xcb_pre_tmp_4++;
778 }
779 /* sumof end. Result is in xcb_pre_tmp_3 */
780 for(i=0; i<xcb_pre_tmp_3; i++) {
781 xcb_tmp_len = xcb_input_input_info_sizeof(xcb_tmp);
782 xcb_block_len += xcb_tmp_len;
783 xcb_tmp += xcb_tmp_len;
784 }
785 xcb_align_to = ALIGNOF(xcb_input_input_info_t);
786 /* insert padding */
787 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
788 xcb_buffer_len += xcb_block_len + xcb_pad;
789 if (0 != xcb_pad) {
790 xcb_tmp += xcb_pad;
791 xcb_pad = 0;
792 }
793 xcb_block_len = 0;
794 /* names */
795 for(i=0; i<_aux->devices_len; i++) {
796 xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
797 xcb_block_len += xcb_tmp_len;
798 xcb_tmp += xcb_tmp_len;
799 }
800 xcb_align_to = ALIGNOF(xcb_str_t);
801 xcb_align_to = 4;
802 /* insert padding */
803 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
804 xcb_buffer_len += xcb_block_len + xcb_pad;
805 if (0 != xcb_pad) {
806 xcb_tmp += xcb_pad;
807 xcb_pad = 0;
808 }
809 xcb_block_len = 0;
810 /* insert padding */
811 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
812 xcb_buffer_len += xcb_block_len + xcb_pad;
813 if (0 != xcb_pad) {
814 xcb_tmp += xcb_pad;
815 xcb_pad = 0;
816 }
817 xcb_block_len = 0;
818
819 return xcb_buffer_len;
820 }
821
822 xcb_input_list_input_devices_cookie_t
xcb_input_list_input_devices(xcb_connection_t * c)823 xcb_input_list_input_devices (xcb_connection_t *c)
824 {
825 static const xcb_protocol_request_t xcb_req = {
826 .count = 2,
827 .ext = &xcb_input_id,
828 .opcode = XCB_INPUT_LIST_INPUT_DEVICES,
829 .isvoid = 0
830 };
831
832 struct iovec xcb_parts[4];
833 xcb_input_list_input_devices_cookie_t xcb_ret;
834 xcb_input_list_input_devices_request_t xcb_out;
835
836
837 xcb_parts[2].iov_base = (char *) &xcb_out;
838 xcb_parts[2].iov_len = sizeof(xcb_out);
839 xcb_parts[3].iov_base = 0;
840 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
841
842 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
843 return xcb_ret;
844 }
845
846 xcb_input_list_input_devices_cookie_t
xcb_input_list_input_devices_unchecked(xcb_connection_t * c)847 xcb_input_list_input_devices_unchecked (xcb_connection_t *c)
848 {
849 static const xcb_protocol_request_t xcb_req = {
850 .count = 2,
851 .ext = &xcb_input_id,
852 .opcode = XCB_INPUT_LIST_INPUT_DEVICES,
853 .isvoid = 0
854 };
855
856 struct iovec xcb_parts[4];
857 xcb_input_list_input_devices_cookie_t xcb_ret;
858 xcb_input_list_input_devices_request_t xcb_out;
859
860
861 xcb_parts[2].iov_base = (char *) &xcb_out;
862 xcb_parts[2].iov_len = sizeof(xcb_out);
863 xcb_parts[3].iov_base = 0;
864 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
865
866 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
867 return xcb_ret;
868 }
869
870 xcb_input_device_info_t *
xcb_input_list_input_devices_devices(const xcb_input_list_input_devices_reply_t * R)871 xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R)
872 {
873 return (xcb_input_device_info_t *) (R + 1);
874 }
875
876 int
xcb_input_list_input_devices_devices_length(const xcb_input_list_input_devices_reply_t * R)877 xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R)
878 {
879 return R->devices_len;
880 }
881
882 xcb_input_device_info_iterator_t
xcb_input_list_input_devices_devices_iterator(const xcb_input_list_input_devices_reply_t * R)883 xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R)
884 {
885 xcb_input_device_info_iterator_t i;
886 i.data = (xcb_input_device_info_t *) (R + 1);
887 i.rem = R->devices_len;
888 i.index = (char *) i.data - (char *) R;
889 return i;
890 }
891
892 int
xcb_input_list_input_devices_infos_length(const xcb_input_list_input_devices_reply_t * R)893 xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R)
894 {
895 int xcb_pre_tmp_5; /* sumof length */
896 int xcb_pre_tmp_6; /* sumof loop counter */
897 int64_t xcb_pre_tmp_7; /* sumof sum */
898 const xcb_input_device_info_t* xcb_pre_tmp_8; /* sumof list ptr */
899 /* sumof start */
900 xcb_pre_tmp_5 = R->devices_len;
901 xcb_pre_tmp_7 = 0;
902 xcb_pre_tmp_8 = xcb_input_list_input_devices_devices(R);
903 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
904 xcb_pre_tmp_7 += xcb_pre_tmp_8->num_class_info;
905 xcb_pre_tmp_8++;
906 }
907 /* sumof end. Result is in xcb_pre_tmp_7 */
908 return xcb_pre_tmp_7;
909 }
910
911 xcb_input_input_info_iterator_t
xcb_input_list_input_devices_infos_iterator(const xcb_input_list_input_devices_reply_t * R)912 xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R)
913 {
914 xcb_input_input_info_iterator_t i;
915 xcb_generic_iterator_t prev = xcb_input_device_info_end(xcb_input_list_input_devices_devices_iterator(R));
916 int xcb_pre_tmp_9; /* sumof length */
917 int xcb_pre_tmp_10; /* sumof loop counter */
918 int64_t xcb_pre_tmp_11; /* sumof sum */
919 const xcb_input_device_info_t* xcb_pre_tmp_12; /* sumof list ptr */
920 /* sumof start */
921 xcb_pre_tmp_9 = R->devices_len;
922 xcb_pre_tmp_11 = 0;
923 xcb_pre_tmp_12 = xcb_input_list_input_devices_devices(R);
924 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
925 xcb_pre_tmp_11 += xcb_pre_tmp_12->num_class_info;
926 xcb_pre_tmp_12++;
927 }
928 /* sumof end. Result is in xcb_pre_tmp_11 */
929 i.data = (xcb_input_input_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_input_info_t, prev.index));
930 i.rem = xcb_pre_tmp_11;
931 i.index = (char *) i.data - (char *) R;
932 return i;
933 }
934
935 int
xcb_input_list_input_devices_names_length(const xcb_input_list_input_devices_reply_t * R)936 xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R)
937 {
938 return R->devices_len;
939 }
940
941 xcb_str_iterator_t
xcb_input_list_input_devices_names_iterator(const xcb_input_list_input_devices_reply_t * R)942 xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R)
943 {
944 xcb_str_iterator_t i;
945 xcb_generic_iterator_t prev = xcb_input_input_info_end(xcb_input_list_input_devices_infos_iterator(R));
946 i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index));
947 i.rem = R->devices_len;
948 i.index = (char *) i.data - (char *) R;
949 return i;
950 }
951
952 xcb_input_list_input_devices_reply_t *
xcb_input_list_input_devices_reply(xcb_connection_t * c,xcb_input_list_input_devices_cookie_t cookie,xcb_generic_error_t ** e)953 xcb_input_list_input_devices_reply (xcb_connection_t *c,
954 xcb_input_list_input_devices_cookie_t cookie /**< */,
955 xcb_generic_error_t **e)
956 {
957 return (xcb_input_list_input_devices_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
958 }
959
960 void
xcb_input_event_type_base_next(xcb_input_event_type_base_iterator_t * i)961 xcb_input_event_type_base_next (xcb_input_event_type_base_iterator_t *i)
962 {
963 --i->rem;
964 ++i->data;
965 i->index += sizeof(xcb_input_event_type_base_t);
966 }
967
968 xcb_generic_iterator_t
xcb_input_event_type_base_end(xcb_input_event_type_base_iterator_t i)969 xcb_input_event_type_base_end (xcb_input_event_type_base_iterator_t i)
970 {
971 xcb_generic_iterator_t ret;
972 ret.data = i.data + i.rem;
973 ret.index = i.index + ((char *) ret.data - (char *) i.data);
974 ret.rem = 0;
975 return ret;
976 }
977
978 void
xcb_input_input_class_info_next(xcb_input_input_class_info_iterator_t * i)979 xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i)
980 {
981 --i->rem;
982 ++i->data;
983 i->index += sizeof(xcb_input_input_class_info_t);
984 }
985
986 xcb_generic_iterator_t
xcb_input_input_class_info_end(xcb_input_input_class_info_iterator_t i)987 xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i)
988 {
989 xcb_generic_iterator_t ret;
990 ret.data = i.data + i.rem;
991 ret.index = i.index + ((char *) ret.data - (char *) i.data);
992 ret.rem = 0;
993 return ret;
994 }
995
996 int
xcb_input_open_device_sizeof(const void * _buffer)997 xcb_input_open_device_sizeof (const void *_buffer)
998 {
999 char *xcb_tmp = (char *)_buffer;
1000 const xcb_input_open_device_reply_t *_aux = (xcb_input_open_device_reply_t *)_buffer;
1001 unsigned int xcb_buffer_len = 0;
1002 unsigned int xcb_block_len = 0;
1003 unsigned int xcb_pad = 0;
1004 unsigned int xcb_align_to = 0;
1005
1006
1007 xcb_block_len += sizeof(xcb_input_open_device_reply_t);
1008 xcb_tmp += xcb_block_len;
1009 xcb_buffer_len += xcb_block_len;
1010 xcb_block_len = 0;
1011 /* class_info */
1012 xcb_block_len += _aux->num_classes * sizeof(xcb_input_input_class_info_t);
1013 xcb_tmp += xcb_block_len;
1014 xcb_align_to = ALIGNOF(xcb_input_input_class_info_t);
1015 xcb_align_to = 4;
1016 /* insert padding */
1017 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1018 xcb_buffer_len += xcb_block_len + xcb_pad;
1019 if (0 != xcb_pad) {
1020 xcb_tmp += xcb_pad;
1021 xcb_pad = 0;
1022 }
1023 xcb_block_len = 0;
1024 /* insert padding */
1025 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1026 xcb_buffer_len += xcb_block_len + xcb_pad;
1027 if (0 != xcb_pad) {
1028 xcb_tmp += xcb_pad;
1029 xcb_pad = 0;
1030 }
1031 xcb_block_len = 0;
1032
1033 return xcb_buffer_len;
1034 }
1035
1036 xcb_input_open_device_cookie_t
xcb_input_open_device(xcb_connection_t * c,uint8_t device_id)1037 xcb_input_open_device (xcb_connection_t *c,
1038 uint8_t device_id)
1039 {
1040 static const xcb_protocol_request_t xcb_req = {
1041 .count = 2,
1042 .ext = &xcb_input_id,
1043 .opcode = XCB_INPUT_OPEN_DEVICE,
1044 .isvoid = 0
1045 };
1046
1047 struct iovec xcb_parts[4];
1048 xcb_input_open_device_cookie_t xcb_ret;
1049 xcb_input_open_device_request_t xcb_out;
1050
1051 xcb_out.device_id = device_id;
1052 memset(xcb_out.pad0, 0, 3);
1053
1054 xcb_parts[2].iov_base = (char *) &xcb_out;
1055 xcb_parts[2].iov_len = sizeof(xcb_out);
1056 xcb_parts[3].iov_base = 0;
1057 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1058
1059 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1060 return xcb_ret;
1061 }
1062
1063 xcb_input_open_device_cookie_t
xcb_input_open_device_unchecked(xcb_connection_t * c,uint8_t device_id)1064 xcb_input_open_device_unchecked (xcb_connection_t *c,
1065 uint8_t device_id)
1066 {
1067 static const xcb_protocol_request_t xcb_req = {
1068 .count = 2,
1069 .ext = &xcb_input_id,
1070 .opcode = XCB_INPUT_OPEN_DEVICE,
1071 .isvoid = 0
1072 };
1073
1074 struct iovec xcb_parts[4];
1075 xcb_input_open_device_cookie_t xcb_ret;
1076 xcb_input_open_device_request_t xcb_out;
1077
1078 xcb_out.device_id = device_id;
1079 memset(xcb_out.pad0, 0, 3);
1080
1081 xcb_parts[2].iov_base = (char *) &xcb_out;
1082 xcb_parts[2].iov_len = sizeof(xcb_out);
1083 xcb_parts[3].iov_base = 0;
1084 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1085
1086 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1087 return xcb_ret;
1088 }
1089
1090 xcb_input_input_class_info_t *
xcb_input_open_device_class_info(const xcb_input_open_device_reply_t * R)1091 xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R)
1092 {
1093 return (xcb_input_input_class_info_t *) (R + 1);
1094 }
1095
1096 int
xcb_input_open_device_class_info_length(const xcb_input_open_device_reply_t * R)1097 xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R)
1098 {
1099 return R->num_classes;
1100 }
1101
1102 xcb_input_input_class_info_iterator_t
xcb_input_open_device_class_info_iterator(const xcb_input_open_device_reply_t * R)1103 xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R)
1104 {
1105 xcb_input_input_class_info_iterator_t i;
1106 i.data = (xcb_input_input_class_info_t *) (R + 1);
1107 i.rem = R->num_classes;
1108 i.index = (char *) i.data - (char *) R;
1109 return i;
1110 }
1111
1112 xcb_input_open_device_reply_t *
xcb_input_open_device_reply(xcb_connection_t * c,xcb_input_open_device_cookie_t cookie,xcb_generic_error_t ** e)1113 xcb_input_open_device_reply (xcb_connection_t *c,
1114 xcb_input_open_device_cookie_t cookie /**< */,
1115 xcb_generic_error_t **e)
1116 {
1117 return (xcb_input_open_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1118 }
1119
1120 xcb_void_cookie_t
xcb_input_close_device_checked(xcb_connection_t * c,uint8_t device_id)1121 xcb_input_close_device_checked (xcb_connection_t *c,
1122 uint8_t device_id)
1123 {
1124 static const xcb_protocol_request_t xcb_req = {
1125 .count = 2,
1126 .ext = &xcb_input_id,
1127 .opcode = XCB_INPUT_CLOSE_DEVICE,
1128 .isvoid = 1
1129 };
1130
1131 struct iovec xcb_parts[4];
1132 xcb_void_cookie_t xcb_ret;
1133 xcb_input_close_device_request_t xcb_out;
1134
1135 xcb_out.device_id = device_id;
1136 memset(xcb_out.pad0, 0, 3);
1137
1138 xcb_parts[2].iov_base = (char *) &xcb_out;
1139 xcb_parts[2].iov_len = sizeof(xcb_out);
1140 xcb_parts[3].iov_base = 0;
1141 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1142
1143 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1144 return xcb_ret;
1145 }
1146
1147 xcb_void_cookie_t
xcb_input_close_device(xcb_connection_t * c,uint8_t device_id)1148 xcb_input_close_device (xcb_connection_t *c,
1149 uint8_t device_id)
1150 {
1151 static const xcb_protocol_request_t xcb_req = {
1152 .count = 2,
1153 .ext = &xcb_input_id,
1154 .opcode = XCB_INPUT_CLOSE_DEVICE,
1155 .isvoid = 1
1156 };
1157
1158 struct iovec xcb_parts[4];
1159 xcb_void_cookie_t xcb_ret;
1160 xcb_input_close_device_request_t xcb_out;
1161
1162 xcb_out.device_id = device_id;
1163 memset(xcb_out.pad0, 0, 3);
1164
1165 xcb_parts[2].iov_base = (char *) &xcb_out;
1166 xcb_parts[2].iov_len = sizeof(xcb_out);
1167 xcb_parts[3].iov_base = 0;
1168 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1169
1170 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1171 return xcb_ret;
1172 }
1173
1174 xcb_input_set_device_mode_cookie_t
xcb_input_set_device_mode(xcb_connection_t * c,uint8_t device_id,uint8_t mode)1175 xcb_input_set_device_mode (xcb_connection_t *c,
1176 uint8_t device_id,
1177 uint8_t mode)
1178 {
1179 static const xcb_protocol_request_t xcb_req = {
1180 .count = 2,
1181 .ext = &xcb_input_id,
1182 .opcode = XCB_INPUT_SET_DEVICE_MODE,
1183 .isvoid = 0
1184 };
1185
1186 struct iovec xcb_parts[4];
1187 xcb_input_set_device_mode_cookie_t xcb_ret;
1188 xcb_input_set_device_mode_request_t xcb_out;
1189
1190 xcb_out.device_id = device_id;
1191 xcb_out.mode = mode;
1192 memset(xcb_out.pad0, 0, 2);
1193
1194 xcb_parts[2].iov_base = (char *) &xcb_out;
1195 xcb_parts[2].iov_len = sizeof(xcb_out);
1196 xcb_parts[3].iov_base = 0;
1197 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1198
1199 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1200 return xcb_ret;
1201 }
1202
1203 xcb_input_set_device_mode_cookie_t
xcb_input_set_device_mode_unchecked(xcb_connection_t * c,uint8_t device_id,uint8_t mode)1204 xcb_input_set_device_mode_unchecked (xcb_connection_t *c,
1205 uint8_t device_id,
1206 uint8_t mode)
1207 {
1208 static const xcb_protocol_request_t xcb_req = {
1209 .count = 2,
1210 .ext = &xcb_input_id,
1211 .opcode = XCB_INPUT_SET_DEVICE_MODE,
1212 .isvoid = 0
1213 };
1214
1215 struct iovec xcb_parts[4];
1216 xcb_input_set_device_mode_cookie_t xcb_ret;
1217 xcb_input_set_device_mode_request_t xcb_out;
1218
1219 xcb_out.device_id = device_id;
1220 xcb_out.mode = mode;
1221 memset(xcb_out.pad0, 0, 2);
1222
1223 xcb_parts[2].iov_base = (char *) &xcb_out;
1224 xcb_parts[2].iov_len = sizeof(xcb_out);
1225 xcb_parts[3].iov_base = 0;
1226 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1227
1228 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1229 return xcb_ret;
1230 }
1231
1232 xcb_input_set_device_mode_reply_t *
xcb_input_set_device_mode_reply(xcb_connection_t * c,xcb_input_set_device_mode_cookie_t cookie,xcb_generic_error_t ** e)1233 xcb_input_set_device_mode_reply (xcb_connection_t *c,
1234 xcb_input_set_device_mode_cookie_t cookie /**< */,
1235 xcb_generic_error_t **e)
1236 {
1237 return (xcb_input_set_device_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1238 }
1239
1240 int
xcb_input_select_extension_event_sizeof(const void * _buffer)1241 xcb_input_select_extension_event_sizeof (const void *_buffer)
1242 {
1243 char *xcb_tmp = (char *)_buffer;
1244 const xcb_input_select_extension_event_request_t *_aux = (xcb_input_select_extension_event_request_t *)_buffer;
1245 unsigned int xcb_buffer_len = 0;
1246 unsigned int xcb_block_len = 0;
1247 unsigned int xcb_pad = 0;
1248 unsigned int xcb_align_to = 0;
1249
1250
1251 xcb_block_len += sizeof(xcb_input_select_extension_event_request_t);
1252 xcb_tmp += xcb_block_len;
1253 xcb_buffer_len += xcb_block_len;
1254 xcb_block_len = 0;
1255 /* classes */
1256 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
1257 xcb_tmp += xcb_block_len;
1258 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
1259 /* insert padding */
1260 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1261 xcb_buffer_len += xcb_block_len + xcb_pad;
1262 if (0 != xcb_pad) {
1263 xcb_tmp += xcb_pad;
1264 xcb_pad = 0;
1265 }
1266 xcb_block_len = 0;
1267
1268 return xcb_buffer_len;
1269 }
1270
1271 xcb_void_cookie_t
xcb_input_select_extension_event_checked(xcb_connection_t * c,xcb_window_t window,uint16_t num_classes,const xcb_input_event_class_t * classes)1272 xcb_input_select_extension_event_checked (xcb_connection_t *c,
1273 xcb_window_t window,
1274 uint16_t num_classes,
1275 const xcb_input_event_class_t *classes)
1276 {
1277 static const xcb_protocol_request_t xcb_req = {
1278 .count = 4,
1279 .ext = &xcb_input_id,
1280 .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT,
1281 .isvoid = 1
1282 };
1283
1284 struct iovec xcb_parts[6];
1285 xcb_void_cookie_t xcb_ret;
1286 xcb_input_select_extension_event_request_t xcb_out;
1287
1288 xcb_out.window = window;
1289 xcb_out.num_classes = num_classes;
1290 memset(xcb_out.pad0, 0, 2);
1291
1292 xcb_parts[2].iov_base = (char *) &xcb_out;
1293 xcb_parts[2].iov_len = sizeof(xcb_out);
1294 xcb_parts[3].iov_base = 0;
1295 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1296 /* xcb_input_event_class_t classes */
1297 xcb_parts[4].iov_base = (char *) classes;
1298 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
1299 xcb_parts[5].iov_base = 0;
1300 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1301
1302 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1303 return xcb_ret;
1304 }
1305
1306 xcb_void_cookie_t
xcb_input_select_extension_event(xcb_connection_t * c,xcb_window_t window,uint16_t num_classes,const xcb_input_event_class_t * classes)1307 xcb_input_select_extension_event (xcb_connection_t *c,
1308 xcb_window_t window,
1309 uint16_t num_classes,
1310 const xcb_input_event_class_t *classes)
1311 {
1312 static const xcb_protocol_request_t xcb_req = {
1313 .count = 4,
1314 .ext = &xcb_input_id,
1315 .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT,
1316 .isvoid = 1
1317 };
1318
1319 struct iovec xcb_parts[6];
1320 xcb_void_cookie_t xcb_ret;
1321 xcb_input_select_extension_event_request_t xcb_out;
1322
1323 xcb_out.window = window;
1324 xcb_out.num_classes = num_classes;
1325 memset(xcb_out.pad0, 0, 2);
1326
1327 xcb_parts[2].iov_base = (char *) &xcb_out;
1328 xcb_parts[2].iov_len = sizeof(xcb_out);
1329 xcb_parts[3].iov_base = 0;
1330 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1331 /* xcb_input_event_class_t classes */
1332 xcb_parts[4].iov_base = (char *) classes;
1333 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
1334 xcb_parts[5].iov_base = 0;
1335 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1336
1337 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1338 return xcb_ret;
1339 }
1340
1341 xcb_input_event_class_t *
xcb_input_select_extension_event_classes(const xcb_input_select_extension_event_request_t * R)1342 xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R)
1343 {
1344 return (xcb_input_event_class_t *) (R + 1);
1345 }
1346
1347 int
xcb_input_select_extension_event_classes_length(const xcb_input_select_extension_event_request_t * R)1348 xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R)
1349 {
1350 return R->num_classes;
1351 }
1352
1353 xcb_generic_iterator_t
xcb_input_select_extension_event_classes_end(const xcb_input_select_extension_event_request_t * R)1354 xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R)
1355 {
1356 xcb_generic_iterator_t i;
1357 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
1358 i.rem = 0;
1359 i.index = (char *) i.data - (char *) R;
1360 return i;
1361 }
1362
1363 int
xcb_input_get_selected_extension_events_sizeof(const void * _buffer)1364 xcb_input_get_selected_extension_events_sizeof (const void *_buffer)
1365 {
1366 char *xcb_tmp = (char *)_buffer;
1367 const xcb_input_get_selected_extension_events_reply_t *_aux = (xcb_input_get_selected_extension_events_reply_t *)_buffer;
1368 unsigned int xcb_buffer_len = 0;
1369 unsigned int xcb_block_len = 0;
1370 unsigned int xcb_pad = 0;
1371 unsigned int xcb_align_to = 0;
1372
1373
1374 xcb_block_len += sizeof(xcb_input_get_selected_extension_events_reply_t);
1375 xcb_tmp += xcb_block_len;
1376 xcb_buffer_len += xcb_block_len;
1377 xcb_block_len = 0;
1378 /* this_classes */
1379 xcb_block_len += _aux->num_this_classes * sizeof(xcb_input_event_class_t);
1380 xcb_tmp += xcb_block_len;
1381 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
1382 /* insert padding */
1383 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1384 xcb_buffer_len += xcb_block_len + xcb_pad;
1385 if (0 != xcb_pad) {
1386 xcb_tmp += xcb_pad;
1387 xcb_pad = 0;
1388 }
1389 xcb_block_len = 0;
1390 /* all_classes */
1391 xcb_block_len += _aux->num_all_classes * sizeof(xcb_input_event_class_t);
1392 xcb_tmp += xcb_block_len;
1393 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
1394 /* insert padding */
1395 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1396 xcb_buffer_len += xcb_block_len + xcb_pad;
1397 if (0 != xcb_pad) {
1398 xcb_tmp += xcb_pad;
1399 xcb_pad = 0;
1400 }
1401 xcb_block_len = 0;
1402
1403 return xcb_buffer_len;
1404 }
1405
1406 xcb_input_get_selected_extension_events_cookie_t
xcb_input_get_selected_extension_events(xcb_connection_t * c,xcb_window_t window)1407 xcb_input_get_selected_extension_events (xcb_connection_t *c,
1408 xcb_window_t window)
1409 {
1410 static const xcb_protocol_request_t xcb_req = {
1411 .count = 2,
1412 .ext = &xcb_input_id,
1413 .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS,
1414 .isvoid = 0
1415 };
1416
1417 struct iovec xcb_parts[4];
1418 xcb_input_get_selected_extension_events_cookie_t xcb_ret;
1419 xcb_input_get_selected_extension_events_request_t xcb_out;
1420
1421 xcb_out.window = window;
1422
1423 xcb_parts[2].iov_base = (char *) &xcb_out;
1424 xcb_parts[2].iov_len = sizeof(xcb_out);
1425 xcb_parts[3].iov_base = 0;
1426 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1427
1428 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1429 return xcb_ret;
1430 }
1431
1432 xcb_input_get_selected_extension_events_cookie_t
xcb_input_get_selected_extension_events_unchecked(xcb_connection_t * c,xcb_window_t window)1433 xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c,
1434 xcb_window_t window)
1435 {
1436 static const xcb_protocol_request_t xcb_req = {
1437 .count = 2,
1438 .ext = &xcb_input_id,
1439 .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS,
1440 .isvoid = 0
1441 };
1442
1443 struct iovec xcb_parts[4];
1444 xcb_input_get_selected_extension_events_cookie_t xcb_ret;
1445 xcb_input_get_selected_extension_events_request_t xcb_out;
1446
1447 xcb_out.window = window;
1448
1449 xcb_parts[2].iov_base = (char *) &xcb_out;
1450 xcb_parts[2].iov_len = sizeof(xcb_out);
1451 xcb_parts[3].iov_base = 0;
1452 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1453
1454 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1455 return xcb_ret;
1456 }
1457
1458 xcb_input_event_class_t *
xcb_input_get_selected_extension_events_this_classes(const xcb_input_get_selected_extension_events_reply_t * R)1459 xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R)
1460 {
1461 return (xcb_input_event_class_t *) (R + 1);
1462 }
1463
1464 int
xcb_input_get_selected_extension_events_this_classes_length(const xcb_input_get_selected_extension_events_reply_t * R)1465 xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R)
1466 {
1467 return R->num_this_classes;
1468 }
1469
1470 xcb_generic_iterator_t
xcb_input_get_selected_extension_events_this_classes_end(const xcb_input_get_selected_extension_events_reply_t * R)1471 xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R)
1472 {
1473 xcb_generic_iterator_t i;
1474 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_this_classes);
1475 i.rem = 0;
1476 i.index = (char *) i.data - (char *) R;
1477 return i;
1478 }
1479
1480 xcb_input_event_class_t *
xcb_input_get_selected_extension_events_all_classes(const xcb_input_get_selected_extension_events_reply_t * R)1481 xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R)
1482 {
1483 xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R);
1484 return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0);
1485 }
1486
1487 int
xcb_input_get_selected_extension_events_all_classes_length(const xcb_input_get_selected_extension_events_reply_t * R)1488 xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R)
1489 {
1490 return R->num_all_classes;
1491 }
1492
1493 xcb_generic_iterator_t
xcb_input_get_selected_extension_events_all_classes_end(const xcb_input_get_selected_extension_events_reply_t * R)1494 xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R)
1495 {
1496 xcb_generic_iterator_t i;
1497 xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R);
1498 i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_all_classes);
1499 i.rem = 0;
1500 i.index = (char *) i.data - (char *) R;
1501 return i;
1502 }
1503
1504 xcb_input_get_selected_extension_events_reply_t *
xcb_input_get_selected_extension_events_reply(xcb_connection_t * c,xcb_input_get_selected_extension_events_cookie_t cookie,xcb_generic_error_t ** e)1505 xcb_input_get_selected_extension_events_reply (xcb_connection_t *c,
1506 xcb_input_get_selected_extension_events_cookie_t cookie /**< */,
1507 xcb_generic_error_t **e)
1508 {
1509 return (xcb_input_get_selected_extension_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1510 }
1511
1512 int
xcb_input_change_device_dont_propagate_list_sizeof(const void * _buffer)1513 xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer)
1514 {
1515 char *xcb_tmp = (char *)_buffer;
1516 const xcb_input_change_device_dont_propagate_list_request_t *_aux = (xcb_input_change_device_dont_propagate_list_request_t *)_buffer;
1517 unsigned int xcb_buffer_len = 0;
1518 unsigned int xcb_block_len = 0;
1519 unsigned int xcb_pad = 0;
1520 unsigned int xcb_align_to = 0;
1521
1522
1523 xcb_block_len += sizeof(xcb_input_change_device_dont_propagate_list_request_t);
1524 xcb_tmp += xcb_block_len;
1525 xcb_buffer_len += xcb_block_len;
1526 xcb_block_len = 0;
1527 /* classes */
1528 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
1529 xcb_tmp += xcb_block_len;
1530 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
1531 /* insert padding */
1532 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1533 xcb_buffer_len += xcb_block_len + xcb_pad;
1534 if (0 != xcb_pad) {
1535 xcb_tmp += xcb_pad;
1536 xcb_pad = 0;
1537 }
1538 xcb_block_len = 0;
1539
1540 return xcb_buffer_len;
1541 }
1542
1543 xcb_void_cookie_t
xcb_input_change_device_dont_propagate_list_checked(xcb_connection_t * c,xcb_window_t window,uint16_t num_classes,uint8_t mode,const xcb_input_event_class_t * classes)1544 xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c,
1545 xcb_window_t window,
1546 uint16_t num_classes,
1547 uint8_t mode,
1548 const xcb_input_event_class_t *classes)
1549 {
1550 static const xcb_protocol_request_t xcb_req = {
1551 .count = 4,
1552 .ext = &xcb_input_id,
1553 .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST,
1554 .isvoid = 1
1555 };
1556
1557 struct iovec xcb_parts[6];
1558 xcb_void_cookie_t xcb_ret;
1559 xcb_input_change_device_dont_propagate_list_request_t xcb_out;
1560
1561 xcb_out.window = window;
1562 xcb_out.num_classes = num_classes;
1563 xcb_out.mode = mode;
1564 xcb_out.pad0 = 0;
1565
1566 xcb_parts[2].iov_base = (char *) &xcb_out;
1567 xcb_parts[2].iov_len = sizeof(xcb_out);
1568 xcb_parts[3].iov_base = 0;
1569 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1570 /* xcb_input_event_class_t classes */
1571 xcb_parts[4].iov_base = (char *) classes;
1572 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
1573 xcb_parts[5].iov_base = 0;
1574 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1575
1576 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1577 return xcb_ret;
1578 }
1579
1580 xcb_void_cookie_t
xcb_input_change_device_dont_propagate_list(xcb_connection_t * c,xcb_window_t window,uint16_t num_classes,uint8_t mode,const xcb_input_event_class_t * classes)1581 xcb_input_change_device_dont_propagate_list (xcb_connection_t *c,
1582 xcb_window_t window,
1583 uint16_t num_classes,
1584 uint8_t mode,
1585 const xcb_input_event_class_t *classes)
1586 {
1587 static const xcb_protocol_request_t xcb_req = {
1588 .count = 4,
1589 .ext = &xcb_input_id,
1590 .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST,
1591 .isvoid = 1
1592 };
1593
1594 struct iovec xcb_parts[6];
1595 xcb_void_cookie_t xcb_ret;
1596 xcb_input_change_device_dont_propagate_list_request_t xcb_out;
1597
1598 xcb_out.window = window;
1599 xcb_out.num_classes = num_classes;
1600 xcb_out.mode = mode;
1601 xcb_out.pad0 = 0;
1602
1603 xcb_parts[2].iov_base = (char *) &xcb_out;
1604 xcb_parts[2].iov_len = sizeof(xcb_out);
1605 xcb_parts[3].iov_base = 0;
1606 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1607 /* xcb_input_event_class_t classes */
1608 xcb_parts[4].iov_base = (char *) classes;
1609 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
1610 xcb_parts[5].iov_base = 0;
1611 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
1612
1613 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1614 return xcb_ret;
1615 }
1616
1617 xcb_input_event_class_t *
xcb_input_change_device_dont_propagate_list_classes(const xcb_input_change_device_dont_propagate_list_request_t * R)1618 xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R)
1619 {
1620 return (xcb_input_event_class_t *) (R + 1);
1621 }
1622
1623 int
xcb_input_change_device_dont_propagate_list_classes_length(const xcb_input_change_device_dont_propagate_list_request_t * R)1624 xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R)
1625 {
1626 return R->num_classes;
1627 }
1628
1629 xcb_generic_iterator_t
xcb_input_change_device_dont_propagate_list_classes_end(const xcb_input_change_device_dont_propagate_list_request_t * R)1630 xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R)
1631 {
1632 xcb_generic_iterator_t i;
1633 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
1634 i.rem = 0;
1635 i.index = (char *) i.data - (char *) R;
1636 return i;
1637 }
1638
1639 int
xcb_input_get_device_dont_propagate_list_sizeof(const void * _buffer)1640 xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer)
1641 {
1642 char *xcb_tmp = (char *)_buffer;
1643 const xcb_input_get_device_dont_propagate_list_reply_t *_aux = (xcb_input_get_device_dont_propagate_list_reply_t *)_buffer;
1644 unsigned int xcb_buffer_len = 0;
1645 unsigned int xcb_block_len = 0;
1646 unsigned int xcb_pad = 0;
1647 unsigned int xcb_align_to = 0;
1648
1649
1650 xcb_block_len += sizeof(xcb_input_get_device_dont_propagate_list_reply_t);
1651 xcb_tmp += xcb_block_len;
1652 xcb_buffer_len += xcb_block_len;
1653 xcb_block_len = 0;
1654 /* classes */
1655 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
1656 xcb_tmp += xcb_block_len;
1657 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
1658 /* insert padding */
1659 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1660 xcb_buffer_len += xcb_block_len + xcb_pad;
1661 if (0 != xcb_pad) {
1662 xcb_tmp += xcb_pad;
1663 xcb_pad = 0;
1664 }
1665 xcb_block_len = 0;
1666
1667 return xcb_buffer_len;
1668 }
1669
1670 xcb_input_get_device_dont_propagate_list_cookie_t
xcb_input_get_device_dont_propagate_list(xcb_connection_t * c,xcb_window_t window)1671 xcb_input_get_device_dont_propagate_list (xcb_connection_t *c,
1672 xcb_window_t window)
1673 {
1674 static const xcb_protocol_request_t xcb_req = {
1675 .count = 2,
1676 .ext = &xcb_input_id,
1677 .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST,
1678 .isvoid = 0
1679 };
1680
1681 struct iovec xcb_parts[4];
1682 xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret;
1683 xcb_input_get_device_dont_propagate_list_request_t xcb_out;
1684
1685 xcb_out.window = window;
1686
1687 xcb_parts[2].iov_base = (char *) &xcb_out;
1688 xcb_parts[2].iov_len = sizeof(xcb_out);
1689 xcb_parts[3].iov_base = 0;
1690 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1691
1692 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1693 return xcb_ret;
1694 }
1695
1696 xcb_input_get_device_dont_propagate_list_cookie_t
xcb_input_get_device_dont_propagate_list_unchecked(xcb_connection_t * c,xcb_window_t window)1697 xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c,
1698 xcb_window_t window)
1699 {
1700 static const xcb_protocol_request_t xcb_req = {
1701 .count = 2,
1702 .ext = &xcb_input_id,
1703 .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST,
1704 .isvoid = 0
1705 };
1706
1707 struct iovec xcb_parts[4];
1708 xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret;
1709 xcb_input_get_device_dont_propagate_list_request_t xcb_out;
1710
1711 xcb_out.window = window;
1712
1713 xcb_parts[2].iov_base = (char *) &xcb_out;
1714 xcb_parts[2].iov_len = sizeof(xcb_out);
1715 xcb_parts[3].iov_base = 0;
1716 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1717
1718 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1719 return xcb_ret;
1720 }
1721
1722 xcb_input_event_class_t *
xcb_input_get_device_dont_propagate_list_classes(const xcb_input_get_device_dont_propagate_list_reply_t * R)1723 xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R)
1724 {
1725 return (xcb_input_event_class_t *) (R + 1);
1726 }
1727
1728 int
xcb_input_get_device_dont_propagate_list_classes_length(const xcb_input_get_device_dont_propagate_list_reply_t * R)1729 xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R)
1730 {
1731 return R->num_classes;
1732 }
1733
1734 xcb_generic_iterator_t
xcb_input_get_device_dont_propagate_list_classes_end(const xcb_input_get_device_dont_propagate_list_reply_t * R)1735 xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R)
1736 {
1737 xcb_generic_iterator_t i;
1738 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
1739 i.rem = 0;
1740 i.index = (char *) i.data - (char *) R;
1741 return i;
1742 }
1743
1744 xcb_input_get_device_dont_propagate_list_reply_t *
xcb_input_get_device_dont_propagate_list_reply(xcb_connection_t * c,xcb_input_get_device_dont_propagate_list_cookie_t cookie,xcb_generic_error_t ** e)1745 xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t *c,
1746 xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */,
1747 xcb_generic_error_t **e)
1748 {
1749 return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1750 }
1751
1752 int
xcb_input_device_time_coord_sizeof(const void * _buffer,uint8_t num_axes)1753 xcb_input_device_time_coord_sizeof (const void *_buffer,
1754 uint8_t num_axes)
1755 {
1756 char *xcb_tmp = (char *)_buffer;
1757 unsigned int xcb_buffer_len = 0;
1758 unsigned int xcb_block_len = 0;
1759 unsigned int xcb_pad = 0;
1760 unsigned int xcb_align_to = 0;
1761
1762
1763 xcb_block_len += sizeof(xcb_input_device_time_coord_t);
1764 xcb_tmp += xcb_block_len;
1765 xcb_buffer_len += xcb_block_len;
1766 xcb_block_len = 0;
1767 /* axisvalues */
1768 xcb_block_len += num_axes * sizeof(int32_t);
1769 xcb_tmp += xcb_block_len;
1770 xcb_align_to = ALIGNOF(int32_t);
1771 /* insert padding */
1772 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1773 xcb_buffer_len += xcb_block_len + xcb_pad;
1774 if (0 != xcb_pad) {
1775 xcb_tmp += xcb_pad;
1776 xcb_pad = 0;
1777 }
1778 xcb_block_len = 0;
1779
1780 return xcb_buffer_len;
1781 }
1782
1783 int32_t *
xcb_input_device_time_coord_axisvalues(const xcb_input_device_time_coord_t * R)1784 xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R)
1785 {
1786 return (int32_t *) (R + 1);
1787 }
1788
1789 int
xcb_input_device_time_coord_axisvalues_length(const xcb_input_device_time_coord_t * R,uint8_t num_axes)1790 xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R,
1791 uint8_t num_axes)
1792 {
1793 return num_axes;
1794 }
1795
1796 xcb_generic_iterator_t
xcb_input_device_time_coord_axisvalues_end(const xcb_input_device_time_coord_t * R,uint8_t num_axes)1797 xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R,
1798 uint8_t num_axes)
1799 {
1800 xcb_generic_iterator_t i;
1801 i.data = ((int32_t *) (R + 1)) + (num_axes);
1802 i.rem = 0;
1803 i.index = (char *) i.data - (char *) R;
1804 return i;
1805 }
1806
1807 void
xcb_input_device_time_coord_next(xcb_input_device_time_coord_iterator_t * i)1808 xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i)
1809 {
1810 xcb_input_device_time_coord_t *R = i->data;
1811 xcb_generic_iterator_t child;
1812 child.data = (xcb_input_device_time_coord_t *)(((char *)R) + xcb_input_device_time_coord_sizeof(R, i->num_axes));
1813 i->index = (char *) child.data - (char *) i->data;
1814 --i->rem;
1815 i->data = (xcb_input_device_time_coord_t *) child.data;
1816 }
1817
1818 xcb_generic_iterator_t
xcb_input_device_time_coord_end(xcb_input_device_time_coord_iterator_t i)1819 xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i)
1820 {
1821 xcb_generic_iterator_t ret;
1822 while(i.rem > 0)
1823 xcb_input_device_time_coord_next(&i);
1824 ret.data = i.data;
1825 ret.rem = i.rem;
1826 ret.index = i.index;
1827 return ret;
1828 }
1829
1830 int
xcb_input_get_device_motion_events_sizeof(const void * _buffer)1831 xcb_input_get_device_motion_events_sizeof (const void *_buffer)
1832 {
1833 char *xcb_tmp = (char *)_buffer;
1834 const xcb_input_get_device_motion_events_reply_t *_aux = (xcb_input_get_device_motion_events_reply_t *)_buffer;
1835 unsigned int xcb_buffer_len = 0;
1836 unsigned int xcb_block_len = 0;
1837 unsigned int xcb_pad = 0;
1838 unsigned int xcb_align_to = 0;
1839
1840 unsigned int i;
1841 unsigned int xcb_tmp_len;
1842
1843 xcb_block_len += sizeof(xcb_input_get_device_motion_events_reply_t);
1844 xcb_tmp += xcb_block_len;
1845 xcb_buffer_len += xcb_block_len;
1846 xcb_block_len = 0;
1847 /* events */
1848 for(i=0; i<_aux->num_events; i++) {
1849 xcb_tmp_len = xcb_input_device_time_coord_sizeof(xcb_tmp, _aux->num_axes);
1850 xcb_block_len += xcb_tmp_len;
1851 xcb_tmp += xcb_tmp_len;
1852 }
1853 xcb_align_to = ALIGNOF(xcb_input_device_time_coord_t);
1854 /* insert padding */
1855 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1856 xcb_buffer_len += xcb_block_len + xcb_pad;
1857 if (0 != xcb_pad) {
1858 xcb_tmp += xcb_pad;
1859 xcb_pad = 0;
1860 }
1861 xcb_block_len = 0;
1862
1863 return xcb_buffer_len;
1864 }
1865
1866 xcb_input_get_device_motion_events_cookie_t
xcb_input_get_device_motion_events(xcb_connection_t * c,xcb_timestamp_t start,xcb_timestamp_t stop,uint8_t device_id)1867 xcb_input_get_device_motion_events (xcb_connection_t *c,
1868 xcb_timestamp_t start,
1869 xcb_timestamp_t stop,
1870 uint8_t device_id)
1871 {
1872 static const xcb_protocol_request_t xcb_req = {
1873 .count = 2,
1874 .ext = &xcb_input_id,
1875 .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS,
1876 .isvoid = 0
1877 };
1878
1879 struct iovec xcb_parts[4];
1880 xcb_input_get_device_motion_events_cookie_t xcb_ret;
1881 xcb_input_get_device_motion_events_request_t xcb_out;
1882
1883 xcb_out.start = start;
1884 xcb_out.stop = stop;
1885 xcb_out.device_id = device_id;
1886 memset(xcb_out.pad0, 0, 3);
1887
1888 xcb_parts[2].iov_base = (char *) &xcb_out;
1889 xcb_parts[2].iov_len = sizeof(xcb_out);
1890 xcb_parts[3].iov_base = 0;
1891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1892
1893 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1894 return xcb_ret;
1895 }
1896
1897 xcb_input_get_device_motion_events_cookie_t
xcb_input_get_device_motion_events_unchecked(xcb_connection_t * c,xcb_timestamp_t start,xcb_timestamp_t stop,uint8_t device_id)1898 xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c,
1899 xcb_timestamp_t start,
1900 xcb_timestamp_t stop,
1901 uint8_t device_id)
1902 {
1903 static const xcb_protocol_request_t xcb_req = {
1904 .count = 2,
1905 .ext = &xcb_input_id,
1906 .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS,
1907 .isvoid = 0
1908 };
1909
1910 struct iovec xcb_parts[4];
1911 xcb_input_get_device_motion_events_cookie_t xcb_ret;
1912 xcb_input_get_device_motion_events_request_t xcb_out;
1913
1914 xcb_out.start = start;
1915 xcb_out.stop = stop;
1916 xcb_out.device_id = device_id;
1917 memset(xcb_out.pad0, 0, 3);
1918
1919 xcb_parts[2].iov_base = (char *) &xcb_out;
1920 xcb_parts[2].iov_len = sizeof(xcb_out);
1921 xcb_parts[3].iov_base = 0;
1922 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1923
1924 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1925 return xcb_ret;
1926 }
1927
1928 int
xcb_input_get_device_motion_events_events_length(const xcb_input_get_device_motion_events_reply_t * R)1929 xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R)
1930 {
1931 return R->num_events;
1932 }
1933
1934 xcb_input_device_time_coord_iterator_t
xcb_input_get_device_motion_events_events_iterator(const xcb_input_get_device_motion_events_reply_t * R)1935 xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R)
1936 {
1937 xcb_input_device_time_coord_iterator_t i;
1938 i.data = (xcb_input_device_time_coord_t *) (R + 1);
1939 i.rem = R->num_events;
1940 i.index = (char *) i.data - (char *) R;
1941 i.num_axes = R->num_axes;
1942 return i;
1943 }
1944
1945 xcb_input_get_device_motion_events_reply_t *
xcb_input_get_device_motion_events_reply(xcb_connection_t * c,xcb_input_get_device_motion_events_cookie_t cookie,xcb_generic_error_t ** e)1946 xcb_input_get_device_motion_events_reply (xcb_connection_t *c,
1947 xcb_input_get_device_motion_events_cookie_t cookie /**< */,
1948 xcb_generic_error_t **e)
1949 {
1950 return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1951 }
1952
1953 xcb_input_change_keyboard_device_cookie_t
xcb_input_change_keyboard_device(xcb_connection_t * c,uint8_t device_id)1954 xcb_input_change_keyboard_device (xcb_connection_t *c,
1955 uint8_t device_id)
1956 {
1957 static const xcb_protocol_request_t xcb_req = {
1958 .count = 2,
1959 .ext = &xcb_input_id,
1960 .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE,
1961 .isvoid = 0
1962 };
1963
1964 struct iovec xcb_parts[4];
1965 xcb_input_change_keyboard_device_cookie_t xcb_ret;
1966 xcb_input_change_keyboard_device_request_t xcb_out;
1967
1968 xcb_out.device_id = device_id;
1969 memset(xcb_out.pad0, 0, 3);
1970
1971 xcb_parts[2].iov_base = (char *) &xcb_out;
1972 xcb_parts[2].iov_len = sizeof(xcb_out);
1973 xcb_parts[3].iov_base = 0;
1974 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1975
1976 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1977 return xcb_ret;
1978 }
1979
1980 xcb_input_change_keyboard_device_cookie_t
xcb_input_change_keyboard_device_unchecked(xcb_connection_t * c,uint8_t device_id)1981 xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c,
1982 uint8_t device_id)
1983 {
1984 static const xcb_protocol_request_t xcb_req = {
1985 .count = 2,
1986 .ext = &xcb_input_id,
1987 .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE,
1988 .isvoid = 0
1989 };
1990
1991 struct iovec xcb_parts[4];
1992 xcb_input_change_keyboard_device_cookie_t xcb_ret;
1993 xcb_input_change_keyboard_device_request_t xcb_out;
1994
1995 xcb_out.device_id = device_id;
1996 memset(xcb_out.pad0, 0, 3);
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
2003 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2004 return xcb_ret;
2005 }
2006
2007 xcb_input_change_keyboard_device_reply_t *
xcb_input_change_keyboard_device_reply(xcb_connection_t * c,xcb_input_change_keyboard_device_cookie_t cookie,xcb_generic_error_t ** e)2008 xcb_input_change_keyboard_device_reply (xcb_connection_t *c,
2009 xcb_input_change_keyboard_device_cookie_t cookie /**< */,
2010 xcb_generic_error_t **e)
2011 {
2012 return (xcb_input_change_keyboard_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2013 }
2014
2015 xcb_input_change_pointer_device_cookie_t
xcb_input_change_pointer_device(xcb_connection_t * c,uint8_t x_axis,uint8_t y_axis,uint8_t device_id)2016 xcb_input_change_pointer_device (xcb_connection_t *c,
2017 uint8_t x_axis,
2018 uint8_t y_axis,
2019 uint8_t device_id)
2020 {
2021 static const xcb_protocol_request_t xcb_req = {
2022 .count = 2,
2023 .ext = &xcb_input_id,
2024 .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE,
2025 .isvoid = 0
2026 };
2027
2028 struct iovec xcb_parts[4];
2029 xcb_input_change_pointer_device_cookie_t xcb_ret;
2030 xcb_input_change_pointer_device_request_t xcb_out;
2031
2032 xcb_out.x_axis = x_axis;
2033 xcb_out.y_axis = y_axis;
2034 xcb_out.device_id = device_id;
2035 xcb_out.pad0 = 0;
2036
2037 xcb_parts[2].iov_base = (char *) &xcb_out;
2038 xcb_parts[2].iov_len = sizeof(xcb_out);
2039 xcb_parts[3].iov_base = 0;
2040 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2041
2042 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2043 return xcb_ret;
2044 }
2045
2046 xcb_input_change_pointer_device_cookie_t
xcb_input_change_pointer_device_unchecked(xcb_connection_t * c,uint8_t x_axis,uint8_t y_axis,uint8_t device_id)2047 xcb_input_change_pointer_device_unchecked (xcb_connection_t *c,
2048 uint8_t x_axis,
2049 uint8_t y_axis,
2050 uint8_t device_id)
2051 {
2052 static const xcb_protocol_request_t xcb_req = {
2053 .count = 2,
2054 .ext = &xcb_input_id,
2055 .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE,
2056 .isvoid = 0
2057 };
2058
2059 struct iovec xcb_parts[4];
2060 xcb_input_change_pointer_device_cookie_t xcb_ret;
2061 xcb_input_change_pointer_device_request_t xcb_out;
2062
2063 xcb_out.x_axis = x_axis;
2064 xcb_out.y_axis = y_axis;
2065 xcb_out.device_id = device_id;
2066 xcb_out.pad0 = 0;
2067
2068 xcb_parts[2].iov_base = (char *) &xcb_out;
2069 xcb_parts[2].iov_len = sizeof(xcb_out);
2070 xcb_parts[3].iov_base = 0;
2071 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2072
2073 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2074 return xcb_ret;
2075 }
2076
2077 xcb_input_change_pointer_device_reply_t *
xcb_input_change_pointer_device_reply(xcb_connection_t * c,xcb_input_change_pointer_device_cookie_t cookie,xcb_generic_error_t ** e)2078 xcb_input_change_pointer_device_reply (xcb_connection_t *c,
2079 xcb_input_change_pointer_device_cookie_t cookie /**< */,
2080 xcb_generic_error_t **e)
2081 {
2082 return (xcb_input_change_pointer_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2083 }
2084
2085 int
xcb_input_grab_device_sizeof(const void * _buffer)2086 xcb_input_grab_device_sizeof (const void *_buffer)
2087 {
2088 char *xcb_tmp = (char *)_buffer;
2089 const xcb_input_grab_device_request_t *_aux = (xcb_input_grab_device_request_t *)_buffer;
2090 unsigned int xcb_buffer_len = 0;
2091 unsigned int xcb_block_len = 0;
2092 unsigned int xcb_pad = 0;
2093 unsigned int xcb_align_to = 0;
2094
2095
2096 xcb_block_len += sizeof(xcb_input_grab_device_request_t);
2097 xcb_tmp += xcb_block_len;
2098 xcb_buffer_len += xcb_block_len;
2099 xcb_block_len = 0;
2100 /* classes */
2101 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
2102 xcb_tmp += xcb_block_len;
2103 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
2104 /* insert padding */
2105 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2106 xcb_buffer_len += xcb_block_len + xcb_pad;
2107 if (0 != xcb_pad) {
2108 xcb_tmp += xcb_pad;
2109 xcb_pad = 0;
2110 }
2111 xcb_block_len = 0;
2112
2113 return xcb_buffer_len;
2114 }
2115
2116 xcb_input_grab_device_cookie_t
xcb_input_grab_device(xcb_connection_t * c,xcb_window_t grab_window,xcb_timestamp_t time,uint16_t num_classes,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t owner_events,uint8_t device_id,const xcb_input_event_class_t * classes)2117 xcb_input_grab_device (xcb_connection_t *c,
2118 xcb_window_t grab_window,
2119 xcb_timestamp_t time,
2120 uint16_t num_classes,
2121 uint8_t this_device_mode,
2122 uint8_t other_device_mode,
2123 uint8_t owner_events,
2124 uint8_t device_id,
2125 const xcb_input_event_class_t *classes)
2126 {
2127 static const xcb_protocol_request_t xcb_req = {
2128 .count = 4,
2129 .ext = &xcb_input_id,
2130 .opcode = XCB_INPUT_GRAB_DEVICE,
2131 .isvoid = 0
2132 };
2133
2134 struct iovec xcb_parts[6];
2135 xcb_input_grab_device_cookie_t xcb_ret;
2136 xcb_input_grab_device_request_t xcb_out;
2137
2138 xcb_out.grab_window = grab_window;
2139 xcb_out.time = time;
2140 xcb_out.num_classes = num_classes;
2141 xcb_out.this_device_mode = this_device_mode;
2142 xcb_out.other_device_mode = other_device_mode;
2143 xcb_out.owner_events = owner_events;
2144 xcb_out.device_id = device_id;
2145 memset(xcb_out.pad0, 0, 2);
2146
2147 xcb_parts[2].iov_base = (char *) &xcb_out;
2148 xcb_parts[2].iov_len = sizeof(xcb_out);
2149 xcb_parts[3].iov_base = 0;
2150 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2151 /* xcb_input_event_class_t classes */
2152 xcb_parts[4].iov_base = (char *) classes;
2153 xcb_parts[4].iov_len = num_classes * sizeof(uint32_t);
2154 xcb_parts[5].iov_base = 0;
2155 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2156
2157 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2158 return xcb_ret;
2159 }
2160
2161 xcb_input_grab_device_cookie_t
xcb_input_grab_device_unchecked(xcb_connection_t * c,xcb_window_t grab_window,xcb_timestamp_t time,uint16_t num_classes,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t owner_events,uint8_t device_id,const xcb_input_event_class_t * classes)2162 xcb_input_grab_device_unchecked (xcb_connection_t *c,
2163 xcb_window_t grab_window,
2164 xcb_timestamp_t time,
2165 uint16_t num_classes,
2166 uint8_t this_device_mode,
2167 uint8_t other_device_mode,
2168 uint8_t owner_events,
2169 uint8_t device_id,
2170 const xcb_input_event_class_t *classes)
2171 {
2172 static const xcb_protocol_request_t xcb_req = {
2173 .count = 4,
2174 .ext = &xcb_input_id,
2175 .opcode = XCB_INPUT_GRAB_DEVICE,
2176 .isvoid = 0
2177 };
2178
2179 struct iovec xcb_parts[6];
2180 xcb_input_grab_device_cookie_t xcb_ret;
2181 xcb_input_grab_device_request_t xcb_out;
2182
2183 xcb_out.grab_window = grab_window;
2184 xcb_out.time = time;
2185 xcb_out.num_classes = num_classes;
2186 xcb_out.this_device_mode = this_device_mode;
2187 xcb_out.other_device_mode = other_device_mode;
2188 xcb_out.owner_events = owner_events;
2189 xcb_out.device_id = device_id;
2190 memset(xcb_out.pad0, 0, 2);
2191
2192 xcb_parts[2].iov_base = (char *) &xcb_out;
2193 xcb_parts[2].iov_len = sizeof(xcb_out);
2194 xcb_parts[3].iov_base = 0;
2195 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2196 /* xcb_input_event_class_t classes */
2197 xcb_parts[4].iov_base = (char *) classes;
2198 xcb_parts[4].iov_len = num_classes * sizeof(uint32_t);
2199 xcb_parts[5].iov_base = 0;
2200 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2201
2202 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2203 return xcb_ret;
2204 }
2205
2206 xcb_input_grab_device_reply_t *
xcb_input_grab_device_reply(xcb_connection_t * c,xcb_input_grab_device_cookie_t cookie,xcb_generic_error_t ** e)2207 xcb_input_grab_device_reply (xcb_connection_t *c,
2208 xcb_input_grab_device_cookie_t cookie /**< */,
2209 xcb_generic_error_t **e)
2210 {
2211 return (xcb_input_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2212 }
2213
2214 xcb_void_cookie_t
xcb_input_ungrab_device_checked(xcb_connection_t * c,xcb_timestamp_t time,uint8_t device_id)2215 xcb_input_ungrab_device_checked (xcb_connection_t *c,
2216 xcb_timestamp_t time,
2217 uint8_t device_id)
2218 {
2219 static const xcb_protocol_request_t xcb_req = {
2220 .count = 2,
2221 .ext = &xcb_input_id,
2222 .opcode = XCB_INPUT_UNGRAB_DEVICE,
2223 .isvoid = 1
2224 };
2225
2226 struct iovec xcb_parts[4];
2227 xcb_void_cookie_t xcb_ret;
2228 xcb_input_ungrab_device_request_t xcb_out;
2229
2230 xcb_out.time = time;
2231 xcb_out.device_id = device_id;
2232 memset(xcb_out.pad0, 0, 3);
2233
2234 xcb_parts[2].iov_base = (char *) &xcb_out;
2235 xcb_parts[2].iov_len = sizeof(xcb_out);
2236 xcb_parts[3].iov_base = 0;
2237 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2238
2239 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2240 return xcb_ret;
2241 }
2242
2243 xcb_void_cookie_t
xcb_input_ungrab_device(xcb_connection_t * c,xcb_timestamp_t time,uint8_t device_id)2244 xcb_input_ungrab_device (xcb_connection_t *c,
2245 xcb_timestamp_t time,
2246 uint8_t device_id)
2247 {
2248 static const xcb_protocol_request_t xcb_req = {
2249 .count = 2,
2250 .ext = &xcb_input_id,
2251 .opcode = XCB_INPUT_UNGRAB_DEVICE,
2252 .isvoid = 1
2253 };
2254
2255 struct iovec xcb_parts[4];
2256 xcb_void_cookie_t xcb_ret;
2257 xcb_input_ungrab_device_request_t xcb_out;
2258
2259 xcb_out.time = time;
2260 xcb_out.device_id = device_id;
2261 memset(xcb_out.pad0, 0, 3);
2262
2263 xcb_parts[2].iov_base = (char *) &xcb_out;
2264 xcb_parts[2].iov_len = sizeof(xcb_out);
2265 xcb_parts[3].iov_base = 0;
2266 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2267
2268 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2269 return xcb_ret;
2270 }
2271
2272 int
xcb_input_grab_device_key_sizeof(const void * _buffer)2273 xcb_input_grab_device_key_sizeof (const void *_buffer)
2274 {
2275 char *xcb_tmp = (char *)_buffer;
2276 const xcb_input_grab_device_key_request_t *_aux = (xcb_input_grab_device_key_request_t *)_buffer;
2277 unsigned int xcb_buffer_len = 0;
2278 unsigned int xcb_block_len = 0;
2279 unsigned int xcb_pad = 0;
2280 unsigned int xcb_align_to = 0;
2281
2282
2283 xcb_block_len += sizeof(xcb_input_grab_device_key_request_t);
2284 xcb_tmp += xcb_block_len;
2285 xcb_buffer_len += xcb_block_len;
2286 xcb_block_len = 0;
2287 /* classes */
2288 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
2289 xcb_tmp += xcb_block_len;
2290 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
2291 /* insert padding */
2292 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2293 xcb_buffer_len += xcb_block_len + xcb_pad;
2294 if (0 != xcb_pad) {
2295 xcb_tmp += xcb_pad;
2296 xcb_pad = 0;
2297 }
2298 xcb_block_len = 0;
2299
2300 return xcb_buffer_len;
2301 }
2302
2303 xcb_void_cookie_t
xcb_input_grab_device_key_checked(xcb_connection_t * c,xcb_window_t grab_window,uint16_t num_classes,uint16_t modifiers,uint8_t modifier_device,uint8_t grabbed_device,uint8_t key,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t owner_events,const xcb_input_event_class_t * classes)2304 xcb_input_grab_device_key_checked (xcb_connection_t *c,
2305 xcb_window_t grab_window,
2306 uint16_t num_classes,
2307 uint16_t modifiers,
2308 uint8_t modifier_device,
2309 uint8_t grabbed_device,
2310 uint8_t key,
2311 uint8_t this_device_mode,
2312 uint8_t other_device_mode,
2313 uint8_t owner_events,
2314 const xcb_input_event_class_t *classes)
2315 {
2316 static const xcb_protocol_request_t xcb_req = {
2317 .count = 4,
2318 .ext = &xcb_input_id,
2319 .opcode = XCB_INPUT_GRAB_DEVICE_KEY,
2320 .isvoid = 1
2321 };
2322
2323 struct iovec xcb_parts[6];
2324 xcb_void_cookie_t xcb_ret;
2325 xcb_input_grab_device_key_request_t xcb_out;
2326
2327 xcb_out.grab_window = grab_window;
2328 xcb_out.num_classes = num_classes;
2329 xcb_out.modifiers = modifiers;
2330 xcb_out.modifier_device = modifier_device;
2331 xcb_out.grabbed_device = grabbed_device;
2332 xcb_out.key = key;
2333 xcb_out.this_device_mode = this_device_mode;
2334 xcb_out.other_device_mode = other_device_mode;
2335 xcb_out.owner_events = owner_events;
2336 memset(xcb_out.pad0, 0, 2);
2337
2338 xcb_parts[2].iov_base = (char *) &xcb_out;
2339 xcb_parts[2].iov_len = sizeof(xcb_out);
2340 xcb_parts[3].iov_base = 0;
2341 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2342 /* xcb_input_event_class_t classes */
2343 xcb_parts[4].iov_base = (char *) classes;
2344 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
2345 xcb_parts[5].iov_base = 0;
2346 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2347
2348 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2349 return xcb_ret;
2350 }
2351
2352 xcb_void_cookie_t
xcb_input_grab_device_key(xcb_connection_t * c,xcb_window_t grab_window,uint16_t num_classes,uint16_t modifiers,uint8_t modifier_device,uint8_t grabbed_device,uint8_t key,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t owner_events,const xcb_input_event_class_t * classes)2353 xcb_input_grab_device_key (xcb_connection_t *c,
2354 xcb_window_t grab_window,
2355 uint16_t num_classes,
2356 uint16_t modifiers,
2357 uint8_t modifier_device,
2358 uint8_t grabbed_device,
2359 uint8_t key,
2360 uint8_t this_device_mode,
2361 uint8_t other_device_mode,
2362 uint8_t owner_events,
2363 const xcb_input_event_class_t *classes)
2364 {
2365 static const xcb_protocol_request_t xcb_req = {
2366 .count = 4,
2367 .ext = &xcb_input_id,
2368 .opcode = XCB_INPUT_GRAB_DEVICE_KEY,
2369 .isvoid = 1
2370 };
2371
2372 struct iovec xcb_parts[6];
2373 xcb_void_cookie_t xcb_ret;
2374 xcb_input_grab_device_key_request_t xcb_out;
2375
2376 xcb_out.grab_window = grab_window;
2377 xcb_out.num_classes = num_classes;
2378 xcb_out.modifiers = modifiers;
2379 xcb_out.modifier_device = modifier_device;
2380 xcb_out.grabbed_device = grabbed_device;
2381 xcb_out.key = key;
2382 xcb_out.this_device_mode = this_device_mode;
2383 xcb_out.other_device_mode = other_device_mode;
2384 xcb_out.owner_events = owner_events;
2385 memset(xcb_out.pad0, 0, 2);
2386
2387 xcb_parts[2].iov_base = (char *) &xcb_out;
2388 xcb_parts[2].iov_len = sizeof(xcb_out);
2389 xcb_parts[3].iov_base = 0;
2390 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2391 /* xcb_input_event_class_t classes */
2392 xcb_parts[4].iov_base = (char *) classes;
2393 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
2394 xcb_parts[5].iov_base = 0;
2395 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2396
2397 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2398 return xcb_ret;
2399 }
2400
2401 xcb_input_event_class_t *
xcb_input_grab_device_key_classes(const xcb_input_grab_device_key_request_t * R)2402 xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R)
2403 {
2404 return (xcb_input_event_class_t *) (R + 1);
2405 }
2406
2407 int
xcb_input_grab_device_key_classes_length(const xcb_input_grab_device_key_request_t * R)2408 xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R)
2409 {
2410 return R->num_classes;
2411 }
2412
2413 xcb_generic_iterator_t
xcb_input_grab_device_key_classes_end(const xcb_input_grab_device_key_request_t * R)2414 xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R)
2415 {
2416 xcb_generic_iterator_t i;
2417 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
2418 i.rem = 0;
2419 i.index = (char *) i.data - (char *) R;
2420 return i;
2421 }
2422
2423 xcb_void_cookie_t
xcb_input_ungrab_device_key_checked(xcb_connection_t * c,xcb_window_t grabWindow,uint16_t modifiers,uint8_t modifier_device,uint8_t key,uint8_t grabbed_device)2424 xcb_input_ungrab_device_key_checked (xcb_connection_t *c,
2425 xcb_window_t grabWindow,
2426 uint16_t modifiers,
2427 uint8_t modifier_device,
2428 uint8_t key,
2429 uint8_t grabbed_device)
2430 {
2431 static const xcb_protocol_request_t xcb_req = {
2432 .count = 2,
2433 .ext = &xcb_input_id,
2434 .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY,
2435 .isvoid = 1
2436 };
2437
2438 struct iovec xcb_parts[4];
2439 xcb_void_cookie_t xcb_ret;
2440 xcb_input_ungrab_device_key_request_t xcb_out;
2441
2442 xcb_out.grabWindow = grabWindow;
2443 xcb_out.modifiers = modifiers;
2444 xcb_out.modifier_device = modifier_device;
2445 xcb_out.key = key;
2446 xcb_out.grabbed_device = grabbed_device;
2447
2448 xcb_parts[2].iov_base = (char *) &xcb_out;
2449 xcb_parts[2].iov_len = sizeof(xcb_out);
2450 xcb_parts[3].iov_base = 0;
2451 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2452
2453 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2454 return xcb_ret;
2455 }
2456
2457 xcb_void_cookie_t
xcb_input_ungrab_device_key(xcb_connection_t * c,xcb_window_t grabWindow,uint16_t modifiers,uint8_t modifier_device,uint8_t key,uint8_t grabbed_device)2458 xcb_input_ungrab_device_key (xcb_connection_t *c,
2459 xcb_window_t grabWindow,
2460 uint16_t modifiers,
2461 uint8_t modifier_device,
2462 uint8_t key,
2463 uint8_t grabbed_device)
2464 {
2465 static const xcb_protocol_request_t xcb_req = {
2466 .count = 2,
2467 .ext = &xcb_input_id,
2468 .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY,
2469 .isvoid = 1
2470 };
2471
2472 struct iovec xcb_parts[4];
2473 xcb_void_cookie_t xcb_ret;
2474 xcb_input_ungrab_device_key_request_t xcb_out;
2475
2476 xcb_out.grabWindow = grabWindow;
2477 xcb_out.modifiers = modifiers;
2478 xcb_out.modifier_device = modifier_device;
2479 xcb_out.key = key;
2480 xcb_out.grabbed_device = grabbed_device;
2481
2482 xcb_parts[2].iov_base = (char *) &xcb_out;
2483 xcb_parts[2].iov_len = sizeof(xcb_out);
2484 xcb_parts[3].iov_base = 0;
2485 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2486
2487 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2488 return xcb_ret;
2489 }
2490
2491 int
xcb_input_grab_device_button_sizeof(const void * _buffer)2492 xcb_input_grab_device_button_sizeof (const void *_buffer)
2493 {
2494 char *xcb_tmp = (char *)_buffer;
2495 const xcb_input_grab_device_button_request_t *_aux = (xcb_input_grab_device_button_request_t *)_buffer;
2496 unsigned int xcb_buffer_len = 0;
2497 unsigned int xcb_block_len = 0;
2498 unsigned int xcb_pad = 0;
2499 unsigned int xcb_align_to = 0;
2500
2501
2502 xcb_block_len += sizeof(xcb_input_grab_device_button_request_t);
2503 xcb_tmp += xcb_block_len;
2504 xcb_buffer_len += xcb_block_len;
2505 xcb_block_len = 0;
2506 /* classes */
2507 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
2508 xcb_tmp += xcb_block_len;
2509 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
2510 /* insert padding */
2511 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2512 xcb_buffer_len += xcb_block_len + xcb_pad;
2513 if (0 != xcb_pad) {
2514 xcb_tmp += xcb_pad;
2515 xcb_pad = 0;
2516 }
2517 xcb_block_len = 0;
2518
2519 return xcb_buffer_len;
2520 }
2521
2522 xcb_void_cookie_t
xcb_input_grab_device_button_checked(xcb_connection_t * c,xcb_window_t grab_window,uint8_t grabbed_device,uint8_t modifier_device,uint16_t num_classes,uint16_t modifiers,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t button,uint8_t owner_events,const xcb_input_event_class_t * classes)2523 xcb_input_grab_device_button_checked (xcb_connection_t *c,
2524 xcb_window_t grab_window,
2525 uint8_t grabbed_device,
2526 uint8_t modifier_device,
2527 uint16_t num_classes,
2528 uint16_t modifiers,
2529 uint8_t this_device_mode,
2530 uint8_t other_device_mode,
2531 uint8_t button,
2532 uint8_t owner_events,
2533 const xcb_input_event_class_t *classes)
2534 {
2535 static const xcb_protocol_request_t xcb_req = {
2536 .count = 4,
2537 .ext = &xcb_input_id,
2538 .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON,
2539 .isvoid = 1
2540 };
2541
2542 struct iovec xcb_parts[6];
2543 xcb_void_cookie_t xcb_ret;
2544 xcb_input_grab_device_button_request_t xcb_out;
2545
2546 xcb_out.grab_window = grab_window;
2547 xcb_out.grabbed_device = grabbed_device;
2548 xcb_out.modifier_device = modifier_device;
2549 xcb_out.num_classes = num_classes;
2550 xcb_out.modifiers = modifiers;
2551 xcb_out.this_device_mode = this_device_mode;
2552 xcb_out.other_device_mode = other_device_mode;
2553 xcb_out.button = button;
2554 xcb_out.owner_events = owner_events;
2555 memset(xcb_out.pad0, 0, 2);
2556
2557 xcb_parts[2].iov_base = (char *) &xcb_out;
2558 xcb_parts[2].iov_len = sizeof(xcb_out);
2559 xcb_parts[3].iov_base = 0;
2560 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2561 /* xcb_input_event_class_t classes */
2562 xcb_parts[4].iov_base = (char *) classes;
2563 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
2564 xcb_parts[5].iov_base = 0;
2565 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2566
2567 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2568 return xcb_ret;
2569 }
2570
2571 xcb_void_cookie_t
xcb_input_grab_device_button(xcb_connection_t * c,xcb_window_t grab_window,uint8_t grabbed_device,uint8_t modifier_device,uint16_t num_classes,uint16_t modifiers,uint8_t this_device_mode,uint8_t other_device_mode,uint8_t button,uint8_t owner_events,const xcb_input_event_class_t * classes)2572 xcb_input_grab_device_button (xcb_connection_t *c,
2573 xcb_window_t grab_window,
2574 uint8_t grabbed_device,
2575 uint8_t modifier_device,
2576 uint16_t num_classes,
2577 uint16_t modifiers,
2578 uint8_t this_device_mode,
2579 uint8_t other_device_mode,
2580 uint8_t button,
2581 uint8_t owner_events,
2582 const xcb_input_event_class_t *classes)
2583 {
2584 static const xcb_protocol_request_t xcb_req = {
2585 .count = 4,
2586 .ext = &xcb_input_id,
2587 .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON,
2588 .isvoid = 1
2589 };
2590
2591 struct iovec xcb_parts[6];
2592 xcb_void_cookie_t xcb_ret;
2593 xcb_input_grab_device_button_request_t xcb_out;
2594
2595 xcb_out.grab_window = grab_window;
2596 xcb_out.grabbed_device = grabbed_device;
2597 xcb_out.modifier_device = modifier_device;
2598 xcb_out.num_classes = num_classes;
2599 xcb_out.modifiers = modifiers;
2600 xcb_out.this_device_mode = this_device_mode;
2601 xcb_out.other_device_mode = other_device_mode;
2602 xcb_out.button = button;
2603 xcb_out.owner_events = owner_events;
2604 memset(xcb_out.pad0, 0, 2);
2605
2606 xcb_parts[2].iov_base = (char *) &xcb_out;
2607 xcb_parts[2].iov_len = sizeof(xcb_out);
2608 xcb_parts[3].iov_base = 0;
2609 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2610 /* xcb_input_event_class_t classes */
2611 xcb_parts[4].iov_base = (char *) classes;
2612 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
2613 xcb_parts[5].iov_base = 0;
2614 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2615
2616 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2617 return xcb_ret;
2618 }
2619
2620 xcb_input_event_class_t *
xcb_input_grab_device_button_classes(const xcb_input_grab_device_button_request_t * R)2621 xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R)
2622 {
2623 return (xcb_input_event_class_t *) (R + 1);
2624 }
2625
2626 int
xcb_input_grab_device_button_classes_length(const xcb_input_grab_device_button_request_t * R)2627 xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R)
2628 {
2629 return R->num_classes;
2630 }
2631
2632 xcb_generic_iterator_t
xcb_input_grab_device_button_classes_end(const xcb_input_grab_device_button_request_t * R)2633 xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R)
2634 {
2635 xcb_generic_iterator_t i;
2636 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
2637 i.rem = 0;
2638 i.index = (char *) i.data - (char *) R;
2639 return i;
2640 }
2641
2642 xcb_void_cookie_t
xcb_input_ungrab_device_button_checked(xcb_connection_t * c,xcb_window_t grab_window,uint16_t modifiers,uint8_t modifier_device,uint8_t button,uint8_t grabbed_device)2643 xcb_input_ungrab_device_button_checked (xcb_connection_t *c,
2644 xcb_window_t grab_window,
2645 uint16_t modifiers,
2646 uint8_t modifier_device,
2647 uint8_t button,
2648 uint8_t grabbed_device)
2649 {
2650 static const xcb_protocol_request_t xcb_req = {
2651 .count = 2,
2652 .ext = &xcb_input_id,
2653 .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON,
2654 .isvoid = 1
2655 };
2656
2657 struct iovec xcb_parts[4];
2658 xcb_void_cookie_t xcb_ret;
2659 xcb_input_ungrab_device_button_request_t xcb_out;
2660
2661 xcb_out.grab_window = grab_window;
2662 xcb_out.modifiers = modifiers;
2663 xcb_out.modifier_device = modifier_device;
2664 xcb_out.button = button;
2665 xcb_out.grabbed_device = grabbed_device;
2666 memset(xcb_out.pad0, 0, 3);
2667
2668 xcb_parts[2].iov_base = (char *) &xcb_out;
2669 xcb_parts[2].iov_len = sizeof(xcb_out);
2670 xcb_parts[3].iov_base = 0;
2671 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2672
2673 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2674 return xcb_ret;
2675 }
2676
2677 xcb_void_cookie_t
xcb_input_ungrab_device_button(xcb_connection_t * c,xcb_window_t grab_window,uint16_t modifiers,uint8_t modifier_device,uint8_t button,uint8_t grabbed_device)2678 xcb_input_ungrab_device_button (xcb_connection_t *c,
2679 xcb_window_t grab_window,
2680 uint16_t modifiers,
2681 uint8_t modifier_device,
2682 uint8_t button,
2683 uint8_t grabbed_device)
2684 {
2685 static const xcb_protocol_request_t xcb_req = {
2686 .count = 2,
2687 .ext = &xcb_input_id,
2688 .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON,
2689 .isvoid = 1
2690 };
2691
2692 struct iovec xcb_parts[4];
2693 xcb_void_cookie_t xcb_ret;
2694 xcb_input_ungrab_device_button_request_t xcb_out;
2695
2696 xcb_out.grab_window = grab_window;
2697 xcb_out.modifiers = modifiers;
2698 xcb_out.modifier_device = modifier_device;
2699 xcb_out.button = button;
2700 xcb_out.grabbed_device = grabbed_device;
2701 memset(xcb_out.pad0, 0, 3);
2702
2703 xcb_parts[2].iov_base = (char *) &xcb_out;
2704 xcb_parts[2].iov_len = sizeof(xcb_out);
2705 xcb_parts[3].iov_base = 0;
2706 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2707
2708 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2709 return xcb_ret;
2710 }
2711
2712 xcb_void_cookie_t
xcb_input_allow_device_events_checked(xcb_connection_t * c,xcb_timestamp_t time,uint8_t mode,uint8_t device_id)2713 xcb_input_allow_device_events_checked (xcb_connection_t *c,
2714 xcb_timestamp_t time,
2715 uint8_t mode,
2716 uint8_t device_id)
2717 {
2718 static const xcb_protocol_request_t xcb_req = {
2719 .count = 2,
2720 .ext = &xcb_input_id,
2721 .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS,
2722 .isvoid = 1
2723 };
2724
2725 struct iovec xcb_parts[4];
2726 xcb_void_cookie_t xcb_ret;
2727 xcb_input_allow_device_events_request_t xcb_out;
2728
2729 xcb_out.time = time;
2730 xcb_out.mode = mode;
2731 xcb_out.device_id = device_id;
2732 memset(xcb_out.pad0, 0, 2);
2733
2734 xcb_parts[2].iov_base = (char *) &xcb_out;
2735 xcb_parts[2].iov_len = sizeof(xcb_out);
2736 xcb_parts[3].iov_base = 0;
2737 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2738
2739 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2740 return xcb_ret;
2741 }
2742
2743 xcb_void_cookie_t
xcb_input_allow_device_events(xcb_connection_t * c,xcb_timestamp_t time,uint8_t mode,uint8_t device_id)2744 xcb_input_allow_device_events (xcb_connection_t *c,
2745 xcb_timestamp_t time,
2746 uint8_t mode,
2747 uint8_t device_id)
2748 {
2749 static const xcb_protocol_request_t xcb_req = {
2750 .count = 2,
2751 .ext = &xcb_input_id,
2752 .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS,
2753 .isvoid = 1
2754 };
2755
2756 struct iovec xcb_parts[4];
2757 xcb_void_cookie_t xcb_ret;
2758 xcb_input_allow_device_events_request_t xcb_out;
2759
2760 xcb_out.time = time;
2761 xcb_out.mode = mode;
2762 xcb_out.device_id = device_id;
2763 memset(xcb_out.pad0, 0, 2);
2764
2765 xcb_parts[2].iov_base = (char *) &xcb_out;
2766 xcb_parts[2].iov_len = sizeof(xcb_out);
2767 xcb_parts[3].iov_base = 0;
2768 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2769
2770 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2771 return xcb_ret;
2772 }
2773
2774 xcb_input_get_device_focus_cookie_t
xcb_input_get_device_focus(xcb_connection_t * c,uint8_t device_id)2775 xcb_input_get_device_focus (xcb_connection_t *c,
2776 uint8_t device_id)
2777 {
2778 static const xcb_protocol_request_t xcb_req = {
2779 .count = 2,
2780 .ext = &xcb_input_id,
2781 .opcode = XCB_INPUT_GET_DEVICE_FOCUS,
2782 .isvoid = 0
2783 };
2784
2785 struct iovec xcb_parts[4];
2786 xcb_input_get_device_focus_cookie_t xcb_ret;
2787 xcb_input_get_device_focus_request_t xcb_out;
2788
2789 xcb_out.device_id = device_id;
2790 memset(xcb_out.pad0, 0, 3);
2791
2792 xcb_parts[2].iov_base = (char *) &xcb_out;
2793 xcb_parts[2].iov_len = sizeof(xcb_out);
2794 xcb_parts[3].iov_base = 0;
2795 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2796
2797 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2798 return xcb_ret;
2799 }
2800
2801 xcb_input_get_device_focus_cookie_t
xcb_input_get_device_focus_unchecked(xcb_connection_t * c,uint8_t device_id)2802 xcb_input_get_device_focus_unchecked (xcb_connection_t *c,
2803 uint8_t device_id)
2804 {
2805 static const xcb_protocol_request_t xcb_req = {
2806 .count = 2,
2807 .ext = &xcb_input_id,
2808 .opcode = XCB_INPUT_GET_DEVICE_FOCUS,
2809 .isvoid = 0
2810 };
2811
2812 struct iovec xcb_parts[4];
2813 xcb_input_get_device_focus_cookie_t xcb_ret;
2814 xcb_input_get_device_focus_request_t xcb_out;
2815
2816 xcb_out.device_id = device_id;
2817 memset(xcb_out.pad0, 0, 3);
2818
2819 xcb_parts[2].iov_base = (char *) &xcb_out;
2820 xcb_parts[2].iov_len = sizeof(xcb_out);
2821 xcb_parts[3].iov_base = 0;
2822 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2823
2824 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2825 return xcb_ret;
2826 }
2827
2828 xcb_input_get_device_focus_reply_t *
xcb_input_get_device_focus_reply(xcb_connection_t * c,xcb_input_get_device_focus_cookie_t cookie,xcb_generic_error_t ** e)2829 xcb_input_get_device_focus_reply (xcb_connection_t *c,
2830 xcb_input_get_device_focus_cookie_t cookie /**< */,
2831 xcb_generic_error_t **e)
2832 {
2833 return (xcb_input_get_device_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2834 }
2835
2836 xcb_void_cookie_t
xcb_input_set_device_focus_checked(xcb_connection_t * c,xcb_window_t focus,xcb_timestamp_t time,uint8_t revert_to,uint8_t device_id)2837 xcb_input_set_device_focus_checked (xcb_connection_t *c,
2838 xcb_window_t focus,
2839 xcb_timestamp_t time,
2840 uint8_t revert_to,
2841 uint8_t device_id)
2842 {
2843 static const xcb_protocol_request_t xcb_req = {
2844 .count = 2,
2845 .ext = &xcb_input_id,
2846 .opcode = XCB_INPUT_SET_DEVICE_FOCUS,
2847 .isvoid = 1
2848 };
2849
2850 struct iovec xcb_parts[4];
2851 xcb_void_cookie_t xcb_ret;
2852 xcb_input_set_device_focus_request_t xcb_out;
2853
2854 xcb_out.focus = focus;
2855 xcb_out.time = time;
2856 xcb_out.revert_to = revert_to;
2857 xcb_out.device_id = device_id;
2858 memset(xcb_out.pad0, 0, 2);
2859
2860 xcb_parts[2].iov_base = (char *) &xcb_out;
2861 xcb_parts[2].iov_len = sizeof(xcb_out);
2862 xcb_parts[3].iov_base = 0;
2863 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2864
2865 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2866 return xcb_ret;
2867 }
2868
2869 xcb_void_cookie_t
xcb_input_set_device_focus(xcb_connection_t * c,xcb_window_t focus,xcb_timestamp_t time,uint8_t revert_to,uint8_t device_id)2870 xcb_input_set_device_focus (xcb_connection_t *c,
2871 xcb_window_t focus,
2872 xcb_timestamp_t time,
2873 uint8_t revert_to,
2874 uint8_t device_id)
2875 {
2876 static const xcb_protocol_request_t xcb_req = {
2877 .count = 2,
2878 .ext = &xcb_input_id,
2879 .opcode = XCB_INPUT_SET_DEVICE_FOCUS,
2880 .isvoid = 1
2881 };
2882
2883 struct iovec xcb_parts[4];
2884 xcb_void_cookie_t xcb_ret;
2885 xcb_input_set_device_focus_request_t xcb_out;
2886
2887 xcb_out.focus = focus;
2888 xcb_out.time = time;
2889 xcb_out.revert_to = revert_to;
2890 xcb_out.device_id = device_id;
2891 memset(xcb_out.pad0, 0, 2);
2892
2893 xcb_parts[2].iov_base = (char *) &xcb_out;
2894 xcb_parts[2].iov_len = sizeof(xcb_out);
2895 xcb_parts[3].iov_base = 0;
2896 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2897
2898 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2899 return xcb_ret;
2900 }
2901
2902 void
xcb_input_kbd_feedback_state_next(xcb_input_kbd_feedback_state_iterator_t * i)2903 xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i)
2904 {
2905 --i->rem;
2906 ++i->data;
2907 i->index += sizeof(xcb_input_kbd_feedback_state_t);
2908 }
2909
2910 xcb_generic_iterator_t
xcb_input_kbd_feedback_state_end(xcb_input_kbd_feedback_state_iterator_t i)2911 xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i)
2912 {
2913 xcb_generic_iterator_t ret;
2914 ret.data = i.data + i.rem;
2915 ret.index = i.index + ((char *) ret.data - (char *) i.data);
2916 ret.rem = 0;
2917 return ret;
2918 }
2919
2920 void
xcb_input_ptr_feedback_state_next(xcb_input_ptr_feedback_state_iterator_t * i)2921 xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i)
2922 {
2923 --i->rem;
2924 ++i->data;
2925 i->index += sizeof(xcb_input_ptr_feedback_state_t);
2926 }
2927
2928 xcb_generic_iterator_t
xcb_input_ptr_feedback_state_end(xcb_input_ptr_feedback_state_iterator_t i)2929 xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i)
2930 {
2931 xcb_generic_iterator_t ret;
2932 ret.data = i.data + i.rem;
2933 ret.index = i.index + ((char *) ret.data - (char *) i.data);
2934 ret.rem = 0;
2935 return ret;
2936 }
2937
2938 void
xcb_input_integer_feedback_state_next(xcb_input_integer_feedback_state_iterator_t * i)2939 xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i)
2940 {
2941 --i->rem;
2942 ++i->data;
2943 i->index += sizeof(xcb_input_integer_feedback_state_t);
2944 }
2945
2946 xcb_generic_iterator_t
xcb_input_integer_feedback_state_end(xcb_input_integer_feedback_state_iterator_t i)2947 xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i)
2948 {
2949 xcb_generic_iterator_t ret;
2950 ret.data = i.data + i.rem;
2951 ret.index = i.index + ((char *) ret.data - (char *) i.data);
2952 ret.rem = 0;
2953 return ret;
2954 }
2955
2956 int
xcb_input_string_feedback_state_sizeof(const void * _buffer)2957 xcb_input_string_feedback_state_sizeof (const void *_buffer)
2958 {
2959 char *xcb_tmp = (char *)_buffer;
2960 const xcb_input_string_feedback_state_t *_aux = (xcb_input_string_feedback_state_t *)_buffer;
2961 unsigned int xcb_buffer_len = 0;
2962 unsigned int xcb_block_len = 0;
2963 unsigned int xcb_pad = 0;
2964 unsigned int xcb_align_to = 0;
2965
2966
2967 xcb_block_len += sizeof(xcb_input_string_feedback_state_t);
2968 xcb_tmp += xcb_block_len;
2969 xcb_buffer_len += xcb_block_len;
2970 xcb_block_len = 0;
2971 /* keysyms */
2972 xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t);
2973 xcb_tmp += xcb_block_len;
2974 xcb_align_to = ALIGNOF(xcb_keysym_t);
2975 /* insert padding */
2976 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2977 xcb_buffer_len += xcb_block_len + xcb_pad;
2978 if (0 != xcb_pad) {
2979 xcb_tmp += xcb_pad;
2980 xcb_pad = 0;
2981 }
2982 xcb_block_len = 0;
2983
2984 return xcb_buffer_len;
2985 }
2986
2987 xcb_keysym_t *
xcb_input_string_feedback_state_keysyms(const xcb_input_string_feedback_state_t * R)2988 xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R)
2989 {
2990 return (xcb_keysym_t *) (R + 1);
2991 }
2992
2993 int
xcb_input_string_feedback_state_keysyms_length(const xcb_input_string_feedback_state_t * R)2994 xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R)
2995 {
2996 return R->num_keysyms;
2997 }
2998
2999 xcb_generic_iterator_t
xcb_input_string_feedback_state_keysyms_end(const xcb_input_string_feedback_state_t * R)3000 xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R)
3001 {
3002 xcb_generic_iterator_t i;
3003 i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms);
3004 i.rem = 0;
3005 i.index = (char *) i.data - (char *) R;
3006 return i;
3007 }
3008
3009 void
xcb_input_string_feedback_state_next(xcb_input_string_feedback_state_iterator_t * i)3010 xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i)
3011 {
3012 xcb_input_string_feedback_state_t *R = i->data;
3013 xcb_generic_iterator_t child;
3014 child.data = (xcb_input_string_feedback_state_t *)(((char *)R) + xcb_input_string_feedback_state_sizeof(R));
3015 i->index = (char *) child.data - (char *) i->data;
3016 --i->rem;
3017 i->data = (xcb_input_string_feedback_state_t *) child.data;
3018 }
3019
3020 xcb_generic_iterator_t
xcb_input_string_feedback_state_end(xcb_input_string_feedback_state_iterator_t i)3021 xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i)
3022 {
3023 xcb_generic_iterator_t ret;
3024 while(i.rem > 0)
3025 xcb_input_string_feedback_state_next(&i);
3026 ret.data = i.data;
3027 ret.rem = i.rem;
3028 ret.index = i.index;
3029 return ret;
3030 }
3031
3032 void
xcb_input_bell_feedback_state_next(xcb_input_bell_feedback_state_iterator_t * i)3033 xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i)
3034 {
3035 --i->rem;
3036 ++i->data;
3037 i->index += sizeof(xcb_input_bell_feedback_state_t);
3038 }
3039
3040 xcb_generic_iterator_t
xcb_input_bell_feedback_state_end(xcb_input_bell_feedback_state_iterator_t i)3041 xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i)
3042 {
3043 xcb_generic_iterator_t ret;
3044 ret.data = i.data + i.rem;
3045 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3046 ret.rem = 0;
3047 return ret;
3048 }
3049
3050 void
xcb_input_led_feedback_state_next(xcb_input_led_feedback_state_iterator_t * i)3051 xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i)
3052 {
3053 --i->rem;
3054 ++i->data;
3055 i->index += sizeof(xcb_input_led_feedback_state_t);
3056 }
3057
3058 xcb_generic_iterator_t
xcb_input_led_feedback_state_end(xcb_input_led_feedback_state_iterator_t i)3059 xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i)
3060 {
3061 xcb_generic_iterator_t ret;
3062 ret.data = i.data + i.rem;
3063 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3064 ret.rem = 0;
3065 return ret;
3066 }
3067
3068 xcb_keysym_t *
xcb_input_feedback_state_data_string_keysyms(const xcb_input_feedback_state_data_t * S)3069 xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S)
3070 {
3071 return S->string.keysyms;
3072 }
3073
3074 int
xcb_input_feedback_state_data_string_keysyms_length(const xcb_input_feedback_state_t * R,const xcb_input_feedback_state_data_t * S)3075 xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R,
3076 const xcb_input_feedback_state_data_t *S)
3077 {
3078 return S->string.num_keysyms;
3079 }
3080
3081 xcb_generic_iterator_t
xcb_input_feedback_state_data_string_keysyms_end(const xcb_input_feedback_state_t * R,const xcb_input_feedback_state_data_t * S)3082 xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R,
3083 const xcb_input_feedback_state_data_t *S)
3084 {
3085 xcb_generic_iterator_t i;
3086 i.data = S->string.keysyms + S->string.num_keysyms;
3087 i.rem = 0;
3088 i.index = (char *) i.data - (char *) S;
3089 return i;
3090 }
3091
3092 int
xcb_input_feedback_state_data_serialize(void ** _buffer,uint8_t class_id,const xcb_input_feedback_state_data_t * _aux)3093 xcb_input_feedback_state_data_serialize (void **_buffer,
3094 uint8_t class_id,
3095 const xcb_input_feedback_state_data_t *_aux)
3096 {
3097 char *xcb_out = *_buffer;
3098 unsigned int xcb_buffer_len = 0;
3099 unsigned int xcb_align_to = 0;
3100 unsigned int xcb_padding_offset = 0;
3101
3102 unsigned int xcb_pad = 0;
3103 char xcb_pad0[3] = {0, 0, 0};
3104 struct iovec xcb_parts[27];
3105 unsigned int xcb_parts_idx = 0;
3106 unsigned int xcb_block_len = 0;
3107 unsigned int i;
3108 char *xcb_tmp;
3109
3110 if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
3111 /* xcb_input_feedback_state_data_t.keyboard.pitch */
3112 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.pitch;
3113 xcb_block_len += sizeof(uint16_t);
3114 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3115 xcb_parts_idx++;
3116 xcb_align_to = ALIGNOF(uint16_t);
3117 /* xcb_input_feedback_state_data_t.keyboard.duration */
3118 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.duration;
3119 xcb_block_len += sizeof(uint16_t);
3120 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3121 xcb_parts_idx++;
3122 xcb_align_to = ALIGNOF(uint16_t);
3123 /* xcb_input_feedback_state_data_t.keyboard.led_mask */
3124 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask;
3125 xcb_block_len += sizeof(uint32_t);
3126 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3127 xcb_parts_idx++;
3128 xcb_align_to = ALIGNOF(uint32_t);
3129 /* xcb_input_feedback_state_data_t.keyboard.led_values */
3130 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values;
3131 xcb_block_len += sizeof(uint32_t);
3132 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3133 xcb_parts_idx++;
3134 xcb_align_to = ALIGNOF(uint32_t);
3135 /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */
3136 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.global_auto_repeat;
3137 xcb_block_len += sizeof(uint8_t);
3138 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3139 xcb_parts_idx++;
3140 xcb_align_to = ALIGNOF(uint8_t);
3141 /* xcb_input_feedback_state_data_t.keyboard.click */
3142 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.click;
3143 xcb_block_len += sizeof(uint8_t);
3144 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3145 xcb_parts_idx++;
3146 xcb_align_to = ALIGNOF(uint8_t);
3147 /* xcb_input_feedback_state_data_t.keyboard.percent */
3148 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.percent;
3149 xcb_block_len += sizeof(uint8_t);
3150 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3151 xcb_parts_idx++;
3152 xcb_align_to = ALIGNOF(uint8_t);
3153 /* xcb_input_feedback_state_data_t.keyboard.pad0 */
3154 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
3155 xcb_block_len += sizeof(uint8_t);
3156 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3157 xcb_parts_idx++;
3158 xcb_align_to = ALIGNOF(uint8_t);
3159 /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */
3160 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyboard.auto_repeats;
3161 xcb_block_len += 32;
3162 xcb_parts[xcb_parts_idx].iov_len = 32;
3163 xcb_parts_idx++;
3164 xcb_align_to = ALIGNOF(uint8_t);
3165 }
3166 if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
3167 /* xcb_input_feedback_state_data_t.pointer.pad1 */
3168 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3169 xcb_block_len += sizeof(uint8_t)*2;
3170 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
3171 xcb_parts_idx++;
3172 xcb_align_to = ALIGNOF(uint8_t);
3173 /* xcb_input_feedback_state_data_t.pointer.accel_num */
3174 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_num;
3175 xcb_block_len += sizeof(uint16_t);
3176 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3177 xcb_parts_idx++;
3178 xcb_align_to = ALIGNOF(uint16_t);
3179 /* xcb_input_feedback_state_data_t.pointer.accel_denom */
3180 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_denom;
3181 xcb_block_len += sizeof(uint16_t);
3182 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3183 xcb_parts_idx++;
3184 xcb_align_to = ALIGNOF(uint16_t);
3185 /* xcb_input_feedback_state_data_t.pointer.threshold */
3186 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold;
3187 xcb_block_len += sizeof(uint16_t);
3188 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3189 xcb_parts_idx++;
3190 xcb_align_to = ALIGNOF(uint16_t);
3191 }
3192 if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
3193 /* xcb_input_feedback_state_data_t.string.max_symbols */
3194 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.max_symbols;
3195 xcb_block_len += sizeof(uint16_t);
3196 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3197 xcb_parts_idx++;
3198 xcb_align_to = ALIGNOF(uint16_t);
3199 /* xcb_input_feedback_state_data_t.string.num_keysyms */
3200 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms;
3201 xcb_block_len += sizeof(uint16_t);
3202 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3203 xcb_parts_idx++;
3204 xcb_align_to = ALIGNOF(uint16_t);
3205 /* insert padding */
3206 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3207 xcb_buffer_len += xcb_block_len + xcb_pad;
3208 if (0 != xcb_pad) {
3209 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3210 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3211 xcb_parts_idx++;
3212 xcb_pad = 0;
3213 }
3214 xcb_block_len = 0;
3215 xcb_padding_offset = 0;
3216 /* keysyms */
3217 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms;
3218 xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
3219 xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t);
3220 xcb_parts_idx++;
3221 xcb_align_to = ALIGNOF(xcb_keysym_t);
3222 }
3223 if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
3224 /* xcb_input_feedback_state_data_t.integer.resolution */
3225 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.resolution;
3226 xcb_block_len += sizeof(uint32_t);
3227 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3228 xcb_parts_idx++;
3229 xcb_align_to = ALIGNOF(uint32_t);
3230 /* xcb_input_feedback_state_data_t.integer.min_value */
3231 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.min_value;
3232 xcb_block_len += sizeof(int32_t);
3233 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
3234 xcb_parts_idx++;
3235 xcb_align_to = ALIGNOF(int32_t);
3236 /* xcb_input_feedback_state_data_t.integer.max_value */
3237 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.max_value;
3238 xcb_block_len += sizeof(int32_t);
3239 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
3240 xcb_parts_idx++;
3241 xcb_align_to = ALIGNOF(int32_t);
3242 }
3243 if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
3244 /* xcb_input_feedback_state_data_t.led.led_mask */
3245 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask;
3246 xcb_block_len += sizeof(uint32_t);
3247 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3248 xcb_parts_idx++;
3249 xcb_align_to = ALIGNOF(uint32_t);
3250 /* xcb_input_feedback_state_data_t.led.led_values */
3251 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values;
3252 xcb_block_len += sizeof(uint32_t);
3253 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3254 xcb_parts_idx++;
3255 xcb_align_to = ALIGNOF(uint32_t);
3256 }
3257 if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
3258 /* xcb_input_feedback_state_data_t.bell.percent */
3259 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent;
3260 xcb_block_len += sizeof(uint8_t);
3261 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3262 xcb_parts_idx++;
3263 xcb_align_to = ALIGNOF(uint8_t);
3264 /* xcb_input_feedback_state_data_t.bell.pad2 */
3265 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3266 xcb_block_len += sizeof(uint8_t)*3;
3267 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
3268 xcb_parts_idx++;
3269 xcb_align_to = ALIGNOF(uint8_t);
3270 /* xcb_input_feedback_state_data_t.bell.pitch */
3271 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch;
3272 xcb_block_len += sizeof(uint16_t);
3273 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3274 xcb_parts_idx++;
3275 xcb_align_to = ALIGNOF(uint16_t);
3276 /* xcb_input_feedback_state_data_t.bell.duration */
3277 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration;
3278 xcb_block_len += sizeof(uint16_t);
3279 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3280 xcb_parts_idx++;
3281 xcb_align_to = ALIGNOF(uint16_t);
3282 }
3283 /* insert padding */
3284 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3285 xcb_buffer_len += xcb_block_len + xcb_pad;
3286 if (0 != xcb_pad) {
3287 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3288 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3289 xcb_parts_idx++;
3290 xcb_pad = 0;
3291 }
3292 xcb_block_len = 0;
3293 xcb_padding_offset = 0;
3294
3295 if (NULL == xcb_out) {
3296 /* allocate memory */
3297 xcb_out = malloc(xcb_buffer_len);
3298 *_buffer = xcb_out;
3299 }
3300
3301 xcb_tmp = xcb_out;
3302 for(i=0; i<xcb_parts_idx; i++) {
3303 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
3304 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
3305 if (0 != xcb_parts[i].iov_len)
3306 xcb_tmp += xcb_parts[i].iov_len;
3307 }
3308
3309 return xcb_buffer_len;
3310 }
3311
3312 int
xcb_input_feedback_state_data_unpack(const void * _buffer,uint8_t class_id,xcb_input_feedback_state_data_t * _aux)3313 xcb_input_feedback_state_data_unpack (const void *_buffer,
3314 uint8_t class_id,
3315 xcb_input_feedback_state_data_t *_aux)
3316 {
3317 char *xcb_tmp = (char *)_buffer;
3318 unsigned int xcb_buffer_len = 0;
3319 unsigned int xcb_block_len = 0;
3320 unsigned int xcb_pad = 0;
3321 unsigned int xcb_align_to = 0;
3322 unsigned int xcb_padding_offset = 0;
3323
3324
3325 if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
3326 /* xcb_input_feedback_state_data_t.keyboard.pitch */
3327 _aux->keyboard.pitch = *(uint16_t *)xcb_tmp;
3328 xcb_block_len += sizeof(uint16_t);
3329 xcb_tmp += sizeof(uint16_t);
3330 xcb_align_to = ALIGNOF(uint16_t);
3331 /* xcb_input_feedback_state_data_t.keyboard.duration */
3332 _aux->keyboard.duration = *(uint16_t *)xcb_tmp;
3333 xcb_block_len += sizeof(uint16_t);
3334 xcb_tmp += sizeof(uint16_t);
3335 xcb_align_to = ALIGNOF(uint16_t);
3336 /* xcb_input_feedback_state_data_t.keyboard.led_mask */
3337 _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp;
3338 xcb_block_len += sizeof(uint32_t);
3339 xcb_tmp += sizeof(uint32_t);
3340 xcb_align_to = ALIGNOF(uint32_t);
3341 /* xcb_input_feedback_state_data_t.keyboard.led_values */
3342 _aux->keyboard.led_values = *(uint32_t *)xcb_tmp;
3343 xcb_block_len += sizeof(uint32_t);
3344 xcb_tmp += sizeof(uint32_t);
3345 xcb_align_to = ALIGNOF(uint32_t);
3346 /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */
3347 _aux->keyboard.global_auto_repeat = *(uint8_t *)xcb_tmp;
3348 xcb_block_len += sizeof(uint8_t);
3349 xcb_tmp += sizeof(uint8_t);
3350 xcb_align_to = ALIGNOF(uint8_t);
3351 /* xcb_input_feedback_state_data_t.keyboard.click */
3352 _aux->keyboard.click = *(uint8_t *)xcb_tmp;
3353 xcb_block_len += sizeof(uint8_t);
3354 xcb_tmp += sizeof(uint8_t);
3355 xcb_align_to = ALIGNOF(uint8_t);
3356 /* xcb_input_feedback_state_data_t.keyboard.percent */
3357 _aux->keyboard.percent = *(uint8_t *)xcb_tmp;
3358 xcb_block_len += sizeof(uint8_t);
3359 xcb_tmp += sizeof(uint8_t);
3360 xcb_align_to = ALIGNOF(uint8_t);
3361 /* xcb_input_feedback_state_data_t.keyboard.pad0 */
3362 _aux->keyboard.pad0 = *(uint8_t *)xcb_tmp;
3363 xcb_block_len += sizeof(uint8_t);
3364 xcb_tmp += sizeof(uint8_t);
3365 xcb_align_to = ALIGNOF(uint8_t);
3366 /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */
3367 memcpy(_aux->keyboard.auto_repeats, xcb_tmp, sizeof(uint8_t) * 32);
3368 xcb_block_len += sizeof(uint8_t) * 32;
3369 xcb_tmp += sizeof(uint8_t) * 32;
3370 xcb_align_to = ALIGNOF(uint8_t);
3371 }
3372 if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
3373 /* xcb_input_feedback_state_data_t.pointer.pad1 */
3374 _aux->pointer.pad1[0] = *(uint8_t *)xcb_tmp;
3375 _aux->pointer.pad1[1] = *(uint8_t *)xcb_tmp;
3376 xcb_block_len += sizeof(uint8_t) * 2;
3377 xcb_tmp += sizeof(uint8_t) * 2;
3378 xcb_align_to = ALIGNOF(uint8_t);
3379 /* xcb_input_feedback_state_data_t.pointer.accel_num */
3380 _aux->pointer.accel_num = *(uint16_t *)xcb_tmp;
3381 xcb_block_len += sizeof(uint16_t);
3382 xcb_tmp += sizeof(uint16_t);
3383 xcb_align_to = ALIGNOF(uint16_t);
3384 /* xcb_input_feedback_state_data_t.pointer.accel_denom */
3385 _aux->pointer.accel_denom = *(uint16_t *)xcb_tmp;
3386 xcb_block_len += sizeof(uint16_t);
3387 xcb_tmp += sizeof(uint16_t);
3388 xcb_align_to = ALIGNOF(uint16_t);
3389 /* xcb_input_feedback_state_data_t.pointer.threshold */
3390 _aux->pointer.threshold = *(uint16_t *)xcb_tmp;
3391 xcb_block_len += sizeof(uint16_t);
3392 xcb_tmp += sizeof(uint16_t);
3393 xcb_align_to = ALIGNOF(uint16_t);
3394 }
3395 if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
3396 /* xcb_input_feedback_state_data_t.string.max_symbols */
3397 _aux->string.max_symbols = *(uint16_t *)xcb_tmp;
3398 xcb_block_len += sizeof(uint16_t);
3399 xcb_tmp += sizeof(uint16_t);
3400 xcb_align_to = ALIGNOF(uint16_t);
3401 /* xcb_input_feedback_state_data_t.string.num_keysyms */
3402 _aux->string.num_keysyms = *(uint16_t *)xcb_tmp;
3403 xcb_block_len += sizeof(uint16_t);
3404 xcb_tmp += sizeof(uint16_t);
3405 xcb_align_to = ALIGNOF(uint16_t);
3406 /* insert padding */
3407 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3408 xcb_buffer_len += xcb_block_len + xcb_pad;
3409 if (0 != xcb_pad) {
3410 xcb_tmp += xcb_pad;
3411 xcb_pad = 0;
3412 }
3413 xcb_block_len = 0;
3414 xcb_padding_offset = 0;
3415 /* keysyms */
3416 _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp;
3417 xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
3418 xcb_tmp += xcb_block_len;
3419 xcb_align_to = ALIGNOF(xcb_keysym_t);
3420 }
3421 if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
3422 /* xcb_input_feedback_state_data_t.integer.resolution */
3423 _aux->integer.resolution = *(uint32_t *)xcb_tmp;
3424 xcb_block_len += sizeof(uint32_t);
3425 xcb_tmp += sizeof(uint32_t);
3426 xcb_align_to = ALIGNOF(uint32_t);
3427 /* xcb_input_feedback_state_data_t.integer.min_value */
3428 _aux->integer.min_value = *(int32_t *)xcb_tmp;
3429 xcb_block_len += sizeof(int32_t);
3430 xcb_tmp += sizeof(int32_t);
3431 xcb_align_to = ALIGNOF(int32_t);
3432 /* xcb_input_feedback_state_data_t.integer.max_value */
3433 _aux->integer.max_value = *(int32_t *)xcb_tmp;
3434 xcb_block_len += sizeof(int32_t);
3435 xcb_tmp += sizeof(int32_t);
3436 xcb_align_to = ALIGNOF(int32_t);
3437 }
3438 if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
3439 /* xcb_input_feedback_state_data_t.led.led_mask */
3440 _aux->led.led_mask = *(uint32_t *)xcb_tmp;
3441 xcb_block_len += sizeof(uint32_t);
3442 xcb_tmp += sizeof(uint32_t);
3443 xcb_align_to = ALIGNOF(uint32_t);
3444 /* xcb_input_feedback_state_data_t.led.led_values */
3445 _aux->led.led_values = *(uint32_t *)xcb_tmp;
3446 xcb_block_len += sizeof(uint32_t);
3447 xcb_tmp += sizeof(uint32_t);
3448 xcb_align_to = ALIGNOF(uint32_t);
3449 }
3450 if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
3451 /* xcb_input_feedback_state_data_t.bell.percent */
3452 _aux->bell.percent = *(uint8_t *)xcb_tmp;
3453 xcb_block_len += sizeof(uint8_t);
3454 xcb_tmp += sizeof(uint8_t);
3455 xcb_align_to = ALIGNOF(uint8_t);
3456 /* xcb_input_feedback_state_data_t.bell.pad2 */
3457 _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp;
3458 _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp;
3459 _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp;
3460 xcb_block_len += sizeof(uint8_t) * 3;
3461 xcb_tmp += sizeof(uint8_t) * 3;
3462 xcb_align_to = ALIGNOF(uint8_t);
3463 /* xcb_input_feedback_state_data_t.bell.pitch */
3464 _aux->bell.pitch = *(uint16_t *)xcb_tmp;
3465 xcb_block_len += sizeof(uint16_t);
3466 xcb_tmp += sizeof(uint16_t);
3467 xcb_align_to = ALIGNOF(uint16_t);
3468 /* xcb_input_feedback_state_data_t.bell.duration */
3469 _aux->bell.duration = *(uint16_t *)xcb_tmp;
3470 xcb_block_len += sizeof(uint16_t);
3471 xcb_tmp += sizeof(uint16_t);
3472 xcb_align_to = ALIGNOF(uint16_t);
3473 }
3474 /* insert padding */
3475 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3476 xcb_buffer_len += xcb_block_len + xcb_pad;
3477 if (0 != xcb_pad) {
3478 xcb_tmp += xcb_pad;
3479 xcb_pad = 0;
3480 }
3481 xcb_block_len = 0;
3482 xcb_padding_offset = 0;
3483
3484 return xcb_buffer_len;
3485 }
3486
3487 int
xcb_input_feedback_state_data_sizeof(const void * _buffer,uint8_t class_id)3488 xcb_input_feedback_state_data_sizeof (const void *_buffer,
3489 uint8_t class_id)
3490 {
3491 xcb_input_feedback_state_data_t _aux;
3492 return xcb_input_feedback_state_data_unpack(_buffer, class_id, &_aux);
3493 }
3494
3495 int
xcb_input_feedback_state_sizeof(const void * _buffer)3496 xcb_input_feedback_state_sizeof (const void *_buffer)
3497 {
3498 char *xcb_tmp = (char *)_buffer;
3499 const xcb_input_feedback_state_t *_aux = (xcb_input_feedback_state_t *)_buffer;
3500 unsigned int xcb_buffer_len = 0;
3501 unsigned int xcb_block_len = 0;
3502 unsigned int xcb_pad = 0;
3503 unsigned int xcb_align_to = 0;
3504
3505
3506 xcb_block_len += sizeof(xcb_input_feedback_state_t);
3507 xcb_tmp += xcb_block_len;
3508 xcb_buffer_len += xcb_block_len;
3509 xcb_block_len = 0;
3510 /* data */
3511 xcb_block_len += xcb_input_feedback_state_data_sizeof(xcb_tmp, _aux->class_id);
3512 xcb_tmp += xcb_block_len;
3513 xcb_align_to = ALIGNOF(char);
3514 /* insert padding */
3515 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3516 xcb_buffer_len += xcb_block_len + xcb_pad;
3517 if (0 != xcb_pad) {
3518 xcb_tmp += xcb_pad;
3519 xcb_pad = 0;
3520 }
3521 xcb_block_len = 0;
3522
3523 return xcb_buffer_len;
3524 }
3525
3526 void *
xcb_input_feedback_state_data(const xcb_input_feedback_state_t * R)3527 xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R)
3528 {
3529 return (void *) (R + 1);
3530 }
3531
3532 void
xcb_input_feedback_state_next(xcb_input_feedback_state_iterator_t * i)3533 xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i)
3534 {
3535 xcb_input_feedback_state_t *R = i->data;
3536 xcb_generic_iterator_t child;
3537 child.data = (xcb_input_feedback_state_t *)(((char *)R) + xcb_input_feedback_state_sizeof(R));
3538 i->index = (char *) child.data - (char *) i->data;
3539 --i->rem;
3540 i->data = (xcb_input_feedback_state_t *) child.data;
3541 }
3542
3543 xcb_generic_iterator_t
xcb_input_feedback_state_end(xcb_input_feedback_state_iterator_t i)3544 xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i)
3545 {
3546 xcb_generic_iterator_t ret;
3547 while(i.rem > 0)
3548 xcb_input_feedback_state_next(&i);
3549 ret.data = i.data;
3550 ret.rem = i.rem;
3551 ret.index = i.index;
3552 return ret;
3553 }
3554
3555 int
xcb_input_get_feedback_control_sizeof(const void * _buffer)3556 xcb_input_get_feedback_control_sizeof (const void *_buffer)
3557 {
3558 char *xcb_tmp = (char *)_buffer;
3559 const xcb_input_get_feedback_control_reply_t *_aux = (xcb_input_get_feedback_control_reply_t *)_buffer;
3560 unsigned int xcb_buffer_len = 0;
3561 unsigned int xcb_block_len = 0;
3562 unsigned int xcb_pad = 0;
3563 unsigned int xcb_align_to = 0;
3564
3565 unsigned int i;
3566 unsigned int xcb_tmp_len;
3567
3568 xcb_block_len += sizeof(xcb_input_get_feedback_control_reply_t);
3569 xcb_tmp += xcb_block_len;
3570 xcb_buffer_len += xcb_block_len;
3571 xcb_block_len = 0;
3572 /* feedbacks */
3573 for(i=0; i<_aux->num_feedbacks; i++) {
3574 xcb_tmp_len = xcb_input_feedback_state_sizeof(xcb_tmp);
3575 xcb_block_len += xcb_tmp_len;
3576 xcb_tmp += xcb_tmp_len;
3577 }
3578 xcb_align_to = ALIGNOF(xcb_input_feedback_state_t);
3579 /* insert padding */
3580 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3581 xcb_buffer_len += xcb_block_len + xcb_pad;
3582 if (0 != xcb_pad) {
3583 xcb_tmp += xcb_pad;
3584 xcb_pad = 0;
3585 }
3586 xcb_block_len = 0;
3587
3588 return xcb_buffer_len;
3589 }
3590
3591 xcb_input_get_feedback_control_cookie_t
xcb_input_get_feedback_control(xcb_connection_t * c,uint8_t device_id)3592 xcb_input_get_feedback_control (xcb_connection_t *c,
3593 uint8_t device_id)
3594 {
3595 static const xcb_protocol_request_t xcb_req = {
3596 .count = 2,
3597 .ext = &xcb_input_id,
3598 .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL,
3599 .isvoid = 0
3600 };
3601
3602 struct iovec xcb_parts[4];
3603 xcb_input_get_feedback_control_cookie_t xcb_ret;
3604 xcb_input_get_feedback_control_request_t xcb_out;
3605
3606 xcb_out.device_id = device_id;
3607 memset(xcb_out.pad0, 0, 3);
3608
3609 xcb_parts[2].iov_base = (char *) &xcb_out;
3610 xcb_parts[2].iov_len = sizeof(xcb_out);
3611 xcb_parts[3].iov_base = 0;
3612 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3613
3614 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3615 return xcb_ret;
3616 }
3617
3618 xcb_input_get_feedback_control_cookie_t
xcb_input_get_feedback_control_unchecked(xcb_connection_t * c,uint8_t device_id)3619 xcb_input_get_feedback_control_unchecked (xcb_connection_t *c,
3620 uint8_t device_id)
3621 {
3622 static const xcb_protocol_request_t xcb_req = {
3623 .count = 2,
3624 .ext = &xcb_input_id,
3625 .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL,
3626 .isvoid = 0
3627 };
3628
3629 struct iovec xcb_parts[4];
3630 xcb_input_get_feedback_control_cookie_t xcb_ret;
3631 xcb_input_get_feedback_control_request_t xcb_out;
3632
3633 xcb_out.device_id = device_id;
3634 memset(xcb_out.pad0, 0, 3);
3635
3636 xcb_parts[2].iov_base = (char *) &xcb_out;
3637 xcb_parts[2].iov_len = sizeof(xcb_out);
3638 xcb_parts[3].iov_base = 0;
3639 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3640
3641 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3642 return xcb_ret;
3643 }
3644
3645 int
xcb_input_get_feedback_control_feedbacks_length(const xcb_input_get_feedback_control_reply_t * R)3646 xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R)
3647 {
3648 return R->num_feedbacks;
3649 }
3650
3651 xcb_input_feedback_state_iterator_t
xcb_input_get_feedback_control_feedbacks_iterator(const xcb_input_get_feedback_control_reply_t * R)3652 xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R)
3653 {
3654 xcb_input_feedback_state_iterator_t i;
3655 i.data = (xcb_input_feedback_state_t *) (R + 1);
3656 i.rem = R->num_feedbacks;
3657 i.index = (char *) i.data - (char *) R;
3658 return i;
3659 }
3660
3661 xcb_input_get_feedback_control_reply_t *
xcb_input_get_feedback_control_reply(xcb_connection_t * c,xcb_input_get_feedback_control_cookie_t cookie,xcb_generic_error_t ** e)3662 xcb_input_get_feedback_control_reply (xcb_connection_t *c,
3663 xcb_input_get_feedback_control_cookie_t cookie /**< */,
3664 xcb_generic_error_t **e)
3665 {
3666 return (xcb_input_get_feedback_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3667 }
3668
3669 void
xcb_input_kbd_feedback_ctl_next(xcb_input_kbd_feedback_ctl_iterator_t * i)3670 xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i)
3671 {
3672 --i->rem;
3673 ++i->data;
3674 i->index += sizeof(xcb_input_kbd_feedback_ctl_t);
3675 }
3676
3677 xcb_generic_iterator_t
xcb_input_kbd_feedback_ctl_end(xcb_input_kbd_feedback_ctl_iterator_t i)3678 xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i)
3679 {
3680 xcb_generic_iterator_t ret;
3681 ret.data = i.data + i.rem;
3682 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3683 ret.rem = 0;
3684 return ret;
3685 }
3686
3687 void
xcb_input_ptr_feedback_ctl_next(xcb_input_ptr_feedback_ctl_iterator_t * i)3688 xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i)
3689 {
3690 --i->rem;
3691 ++i->data;
3692 i->index += sizeof(xcb_input_ptr_feedback_ctl_t);
3693 }
3694
3695 xcb_generic_iterator_t
xcb_input_ptr_feedback_ctl_end(xcb_input_ptr_feedback_ctl_iterator_t i)3696 xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i)
3697 {
3698 xcb_generic_iterator_t ret;
3699 ret.data = i.data + i.rem;
3700 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3701 ret.rem = 0;
3702 return ret;
3703 }
3704
3705 void
xcb_input_integer_feedback_ctl_next(xcb_input_integer_feedback_ctl_iterator_t * i)3706 xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i)
3707 {
3708 --i->rem;
3709 ++i->data;
3710 i->index += sizeof(xcb_input_integer_feedback_ctl_t);
3711 }
3712
3713 xcb_generic_iterator_t
xcb_input_integer_feedback_ctl_end(xcb_input_integer_feedback_ctl_iterator_t i)3714 xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i)
3715 {
3716 xcb_generic_iterator_t ret;
3717 ret.data = i.data + i.rem;
3718 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3719 ret.rem = 0;
3720 return ret;
3721 }
3722
3723 int
xcb_input_string_feedback_ctl_sizeof(const void * _buffer)3724 xcb_input_string_feedback_ctl_sizeof (const void *_buffer)
3725 {
3726 char *xcb_tmp = (char *)_buffer;
3727 const xcb_input_string_feedback_ctl_t *_aux = (xcb_input_string_feedback_ctl_t *)_buffer;
3728 unsigned int xcb_buffer_len = 0;
3729 unsigned int xcb_block_len = 0;
3730 unsigned int xcb_pad = 0;
3731 unsigned int xcb_align_to = 0;
3732
3733
3734 xcb_block_len += sizeof(xcb_input_string_feedback_ctl_t);
3735 xcb_tmp += xcb_block_len;
3736 xcb_buffer_len += xcb_block_len;
3737 xcb_block_len = 0;
3738 /* keysyms */
3739 xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t);
3740 xcb_tmp += xcb_block_len;
3741 xcb_align_to = ALIGNOF(xcb_keysym_t);
3742 /* insert padding */
3743 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3744 xcb_buffer_len += xcb_block_len + xcb_pad;
3745 if (0 != xcb_pad) {
3746 xcb_tmp += xcb_pad;
3747 xcb_pad = 0;
3748 }
3749 xcb_block_len = 0;
3750
3751 return xcb_buffer_len;
3752 }
3753
3754 xcb_keysym_t *
xcb_input_string_feedback_ctl_keysyms(const xcb_input_string_feedback_ctl_t * R)3755 xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R)
3756 {
3757 return (xcb_keysym_t *) (R + 1);
3758 }
3759
3760 int
xcb_input_string_feedback_ctl_keysyms_length(const xcb_input_string_feedback_ctl_t * R)3761 xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R)
3762 {
3763 return R->num_keysyms;
3764 }
3765
3766 xcb_generic_iterator_t
xcb_input_string_feedback_ctl_keysyms_end(const xcb_input_string_feedback_ctl_t * R)3767 xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R)
3768 {
3769 xcb_generic_iterator_t i;
3770 i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms);
3771 i.rem = 0;
3772 i.index = (char *) i.data - (char *) R;
3773 return i;
3774 }
3775
3776 void
xcb_input_string_feedback_ctl_next(xcb_input_string_feedback_ctl_iterator_t * i)3777 xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i)
3778 {
3779 xcb_input_string_feedback_ctl_t *R = i->data;
3780 xcb_generic_iterator_t child;
3781 child.data = (xcb_input_string_feedback_ctl_t *)(((char *)R) + xcb_input_string_feedback_ctl_sizeof(R));
3782 i->index = (char *) child.data - (char *) i->data;
3783 --i->rem;
3784 i->data = (xcb_input_string_feedback_ctl_t *) child.data;
3785 }
3786
3787 xcb_generic_iterator_t
xcb_input_string_feedback_ctl_end(xcb_input_string_feedback_ctl_iterator_t i)3788 xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i)
3789 {
3790 xcb_generic_iterator_t ret;
3791 while(i.rem > 0)
3792 xcb_input_string_feedback_ctl_next(&i);
3793 ret.data = i.data;
3794 ret.rem = i.rem;
3795 ret.index = i.index;
3796 return ret;
3797 }
3798
3799 void
xcb_input_bell_feedback_ctl_next(xcb_input_bell_feedback_ctl_iterator_t * i)3800 xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i)
3801 {
3802 --i->rem;
3803 ++i->data;
3804 i->index += sizeof(xcb_input_bell_feedback_ctl_t);
3805 }
3806
3807 xcb_generic_iterator_t
xcb_input_bell_feedback_ctl_end(xcb_input_bell_feedback_ctl_iterator_t i)3808 xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i)
3809 {
3810 xcb_generic_iterator_t ret;
3811 ret.data = i.data + i.rem;
3812 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3813 ret.rem = 0;
3814 return ret;
3815 }
3816
3817 void
xcb_input_led_feedback_ctl_next(xcb_input_led_feedback_ctl_iterator_t * i)3818 xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i)
3819 {
3820 --i->rem;
3821 ++i->data;
3822 i->index += sizeof(xcb_input_led_feedback_ctl_t);
3823 }
3824
3825 xcb_generic_iterator_t
xcb_input_led_feedback_ctl_end(xcb_input_led_feedback_ctl_iterator_t i)3826 xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i)
3827 {
3828 xcb_generic_iterator_t ret;
3829 ret.data = i.data + i.rem;
3830 ret.index = i.index + ((char *) ret.data - (char *) i.data);
3831 ret.rem = 0;
3832 return ret;
3833 }
3834
3835 xcb_keysym_t *
xcb_input_feedback_ctl_data_string_keysyms(const xcb_input_feedback_ctl_data_t * S)3836 xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S)
3837 {
3838 return S->string.keysyms;
3839 }
3840
3841 int
xcb_input_feedback_ctl_data_string_keysyms_length(const xcb_input_feedback_ctl_t * R,const xcb_input_feedback_ctl_data_t * S)3842 xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R,
3843 const xcb_input_feedback_ctl_data_t *S)
3844 {
3845 return S->string.num_keysyms;
3846 }
3847
3848 xcb_generic_iterator_t
xcb_input_feedback_ctl_data_string_keysyms_end(const xcb_input_feedback_ctl_t * R,const xcb_input_feedback_ctl_data_t * S)3849 xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R,
3850 const xcb_input_feedback_ctl_data_t *S)
3851 {
3852 xcb_generic_iterator_t i;
3853 i.data = S->string.keysyms + S->string.num_keysyms;
3854 i.rem = 0;
3855 i.index = (char *) i.data - (char *) S;
3856 return i;
3857 }
3858
3859 int
xcb_input_feedback_ctl_data_serialize(void ** _buffer,uint8_t class_id,const xcb_input_feedback_ctl_data_t * _aux)3860 xcb_input_feedback_ctl_data_serialize (void **_buffer,
3861 uint8_t class_id,
3862 const xcb_input_feedback_ctl_data_t *_aux)
3863 {
3864 char *xcb_out = *_buffer;
3865 unsigned int xcb_buffer_len = 0;
3866 unsigned int xcb_align_to = 0;
3867 unsigned int xcb_padding_offset = 0;
3868
3869 unsigned int xcb_pad = 0;
3870 char xcb_pad0[3] = {0, 0, 0};
3871 struct iovec xcb_parts[24];
3872 unsigned int xcb_parts_idx = 0;
3873 unsigned int xcb_block_len = 0;
3874 unsigned int i;
3875 char *xcb_tmp;
3876
3877 if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
3878 /* xcb_input_feedback_ctl_data_t.keyboard.key */
3879 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key;
3880 xcb_block_len += sizeof(xcb_input_key_code_t);
3881 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
3882 xcb_parts_idx++;
3883 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
3884 /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */
3885 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.auto_repeat_mode;
3886 xcb_block_len += sizeof(uint8_t);
3887 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
3888 xcb_parts_idx++;
3889 xcb_align_to = ALIGNOF(uint8_t);
3890 /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */
3891 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key_click_percent;
3892 xcb_block_len += sizeof(int8_t);
3893 xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
3894 xcb_parts_idx++;
3895 xcb_align_to = ALIGNOF(int8_t);
3896 /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */
3897 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_percent;
3898 xcb_block_len += sizeof(int8_t);
3899 xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
3900 xcb_parts_idx++;
3901 xcb_align_to = ALIGNOF(int8_t);
3902 /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */
3903 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_pitch;
3904 xcb_block_len += sizeof(int16_t);
3905 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
3906 xcb_parts_idx++;
3907 xcb_align_to = ALIGNOF(int16_t);
3908 /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */
3909 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_duration;
3910 xcb_block_len += sizeof(int16_t);
3911 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
3912 xcb_parts_idx++;
3913 xcb_align_to = ALIGNOF(int16_t);
3914 /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */
3915 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask;
3916 xcb_block_len += sizeof(uint32_t);
3917 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3918 xcb_parts_idx++;
3919 xcb_align_to = ALIGNOF(uint32_t);
3920 /* xcb_input_feedback_ctl_data_t.keyboard.led_values */
3921 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values;
3922 xcb_block_len += sizeof(uint32_t);
3923 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3924 xcb_parts_idx++;
3925 xcb_align_to = ALIGNOF(uint32_t);
3926 }
3927 if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
3928 /* xcb_input_feedback_ctl_data_t.pointer.pad0 */
3929 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3930 xcb_block_len += sizeof(uint8_t)*2;
3931 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
3932 xcb_parts_idx++;
3933 xcb_align_to = ALIGNOF(uint8_t);
3934 /* xcb_input_feedback_ctl_data_t.pointer.num */
3935 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.num;
3936 xcb_block_len += sizeof(int16_t);
3937 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
3938 xcb_parts_idx++;
3939 xcb_align_to = ALIGNOF(int16_t);
3940 /* xcb_input_feedback_ctl_data_t.pointer.denom */
3941 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.denom;
3942 xcb_block_len += sizeof(int16_t);
3943 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
3944 xcb_parts_idx++;
3945 xcb_align_to = ALIGNOF(int16_t);
3946 /* xcb_input_feedback_ctl_data_t.pointer.threshold */
3947 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold;
3948 xcb_block_len += sizeof(int16_t);
3949 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
3950 xcb_parts_idx++;
3951 xcb_align_to = ALIGNOF(int16_t);
3952 }
3953 if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
3954 /* xcb_input_feedback_ctl_data_t.string.pad1 */
3955 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3956 xcb_block_len += sizeof(uint8_t)*2;
3957 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
3958 xcb_parts_idx++;
3959 xcb_align_to = ALIGNOF(uint8_t);
3960 /* xcb_input_feedback_ctl_data_t.string.num_keysyms */
3961 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms;
3962 xcb_block_len += sizeof(uint16_t);
3963 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
3964 xcb_parts_idx++;
3965 xcb_align_to = ALIGNOF(uint16_t);
3966 /* insert padding */
3967 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3968 xcb_buffer_len += xcb_block_len + xcb_pad;
3969 if (0 != xcb_pad) {
3970 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3971 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3972 xcb_parts_idx++;
3973 xcb_pad = 0;
3974 }
3975 xcb_block_len = 0;
3976 xcb_padding_offset = 0;
3977 /* keysyms */
3978 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms;
3979 xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
3980 xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t);
3981 xcb_parts_idx++;
3982 xcb_align_to = ALIGNOF(xcb_keysym_t);
3983 }
3984 if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
3985 /* xcb_input_feedback_ctl_data_t.integer.int_to_display */
3986 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.int_to_display;
3987 xcb_block_len += sizeof(int32_t);
3988 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
3989 xcb_parts_idx++;
3990 xcb_align_to = ALIGNOF(int32_t);
3991 }
3992 if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
3993 /* xcb_input_feedback_ctl_data_t.led.led_mask */
3994 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask;
3995 xcb_block_len += sizeof(uint32_t);
3996 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
3997 xcb_parts_idx++;
3998 xcb_align_to = ALIGNOF(uint32_t);
3999 /* xcb_input_feedback_ctl_data_t.led.led_values */
4000 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values;
4001 xcb_block_len += sizeof(uint32_t);
4002 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
4003 xcb_parts_idx++;
4004 xcb_align_to = ALIGNOF(uint32_t);
4005 }
4006 if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
4007 /* xcb_input_feedback_ctl_data_t.bell.percent */
4008 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent;
4009 xcb_block_len += sizeof(int8_t);
4010 xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
4011 xcb_parts_idx++;
4012 xcb_align_to = ALIGNOF(int8_t);
4013 /* xcb_input_feedback_ctl_data_t.bell.pad2 */
4014 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4015 xcb_block_len += sizeof(uint8_t)*3;
4016 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
4017 xcb_parts_idx++;
4018 xcb_align_to = ALIGNOF(uint8_t);
4019 /* xcb_input_feedback_ctl_data_t.bell.pitch */
4020 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch;
4021 xcb_block_len += sizeof(int16_t);
4022 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
4023 xcb_parts_idx++;
4024 xcb_align_to = ALIGNOF(int16_t);
4025 /* xcb_input_feedback_ctl_data_t.bell.duration */
4026 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration;
4027 xcb_block_len += sizeof(int16_t);
4028 xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
4029 xcb_parts_idx++;
4030 xcb_align_to = ALIGNOF(int16_t);
4031 }
4032 /* insert padding */
4033 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4034 xcb_buffer_len += xcb_block_len + xcb_pad;
4035 if (0 != xcb_pad) {
4036 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4037 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4038 xcb_parts_idx++;
4039 xcb_pad = 0;
4040 }
4041 xcb_block_len = 0;
4042 xcb_padding_offset = 0;
4043
4044 if (NULL == xcb_out) {
4045 /* allocate memory */
4046 xcb_out = malloc(xcb_buffer_len);
4047 *_buffer = xcb_out;
4048 }
4049
4050 xcb_tmp = xcb_out;
4051 for(i=0; i<xcb_parts_idx; i++) {
4052 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
4053 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
4054 if (0 != xcb_parts[i].iov_len)
4055 xcb_tmp += xcb_parts[i].iov_len;
4056 }
4057
4058 return xcb_buffer_len;
4059 }
4060
4061 int
xcb_input_feedback_ctl_data_unpack(const void * _buffer,uint8_t class_id,xcb_input_feedback_ctl_data_t * _aux)4062 xcb_input_feedback_ctl_data_unpack (const void *_buffer,
4063 uint8_t class_id,
4064 xcb_input_feedback_ctl_data_t *_aux)
4065 {
4066 char *xcb_tmp = (char *)_buffer;
4067 unsigned int xcb_buffer_len = 0;
4068 unsigned int xcb_block_len = 0;
4069 unsigned int xcb_pad = 0;
4070 unsigned int xcb_align_to = 0;
4071 unsigned int xcb_padding_offset = 0;
4072
4073
4074 if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
4075 /* xcb_input_feedback_ctl_data_t.keyboard.key */
4076 _aux->keyboard.key = *(xcb_input_key_code_t *)xcb_tmp;
4077 xcb_block_len += sizeof(xcb_input_key_code_t);
4078 xcb_tmp += sizeof(xcb_input_key_code_t);
4079 xcb_align_to = ALIGNOF(xcb_input_key_code_t);
4080 /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */
4081 _aux->keyboard.auto_repeat_mode = *(uint8_t *)xcb_tmp;
4082 xcb_block_len += sizeof(uint8_t);
4083 xcb_tmp += sizeof(uint8_t);
4084 xcb_align_to = ALIGNOF(uint8_t);
4085 /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */
4086 _aux->keyboard.key_click_percent = *(int8_t *)xcb_tmp;
4087 xcb_block_len += sizeof(int8_t);
4088 xcb_tmp += sizeof(int8_t);
4089 xcb_align_to = ALIGNOF(int8_t);
4090 /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */
4091 _aux->keyboard.bell_percent = *(int8_t *)xcb_tmp;
4092 xcb_block_len += sizeof(int8_t);
4093 xcb_tmp += sizeof(int8_t);
4094 xcb_align_to = ALIGNOF(int8_t);
4095 /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */
4096 _aux->keyboard.bell_pitch = *(int16_t *)xcb_tmp;
4097 xcb_block_len += sizeof(int16_t);
4098 xcb_tmp += sizeof(int16_t);
4099 xcb_align_to = ALIGNOF(int16_t);
4100 /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */
4101 _aux->keyboard.bell_duration = *(int16_t *)xcb_tmp;
4102 xcb_block_len += sizeof(int16_t);
4103 xcb_tmp += sizeof(int16_t);
4104 xcb_align_to = ALIGNOF(int16_t);
4105 /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */
4106 _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp;
4107 xcb_block_len += sizeof(uint32_t);
4108 xcb_tmp += sizeof(uint32_t);
4109 xcb_align_to = ALIGNOF(uint32_t);
4110 /* xcb_input_feedback_ctl_data_t.keyboard.led_values */
4111 _aux->keyboard.led_values = *(uint32_t *)xcb_tmp;
4112 xcb_block_len += sizeof(uint32_t);
4113 xcb_tmp += sizeof(uint32_t);
4114 xcb_align_to = ALIGNOF(uint32_t);
4115 }
4116 if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
4117 /* xcb_input_feedback_ctl_data_t.pointer.pad0 */
4118 _aux->pointer.pad0[0] = *(uint8_t *)xcb_tmp;
4119 _aux->pointer.pad0[1] = *(uint8_t *)xcb_tmp;
4120 xcb_block_len += sizeof(uint8_t) * 2;
4121 xcb_tmp += sizeof(uint8_t) * 2;
4122 xcb_align_to = ALIGNOF(uint8_t);
4123 /* xcb_input_feedback_ctl_data_t.pointer.num */
4124 _aux->pointer.num = *(int16_t *)xcb_tmp;
4125 xcb_block_len += sizeof(int16_t);
4126 xcb_tmp += sizeof(int16_t);
4127 xcb_align_to = ALIGNOF(int16_t);
4128 /* xcb_input_feedback_ctl_data_t.pointer.denom */
4129 _aux->pointer.denom = *(int16_t *)xcb_tmp;
4130 xcb_block_len += sizeof(int16_t);
4131 xcb_tmp += sizeof(int16_t);
4132 xcb_align_to = ALIGNOF(int16_t);
4133 /* xcb_input_feedback_ctl_data_t.pointer.threshold */
4134 _aux->pointer.threshold = *(int16_t *)xcb_tmp;
4135 xcb_block_len += sizeof(int16_t);
4136 xcb_tmp += sizeof(int16_t);
4137 xcb_align_to = ALIGNOF(int16_t);
4138 }
4139 if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
4140 /* xcb_input_feedback_ctl_data_t.string.pad1 */
4141 _aux->string.pad1[0] = *(uint8_t *)xcb_tmp;
4142 _aux->string.pad1[1] = *(uint8_t *)xcb_tmp;
4143 xcb_block_len += sizeof(uint8_t) * 2;
4144 xcb_tmp += sizeof(uint8_t) * 2;
4145 xcb_align_to = ALIGNOF(uint8_t);
4146 /* xcb_input_feedback_ctl_data_t.string.num_keysyms */
4147 _aux->string.num_keysyms = *(uint16_t *)xcb_tmp;
4148 xcb_block_len += sizeof(uint16_t);
4149 xcb_tmp += sizeof(uint16_t);
4150 xcb_align_to = ALIGNOF(uint16_t);
4151 /* insert padding */
4152 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4153 xcb_buffer_len += xcb_block_len + xcb_pad;
4154 if (0 != xcb_pad) {
4155 xcb_tmp += xcb_pad;
4156 xcb_pad = 0;
4157 }
4158 xcb_block_len = 0;
4159 xcb_padding_offset = 0;
4160 /* keysyms */
4161 _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp;
4162 xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
4163 xcb_tmp += xcb_block_len;
4164 xcb_align_to = ALIGNOF(xcb_keysym_t);
4165 }
4166 if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
4167 /* xcb_input_feedback_ctl_data_t.integer.int_to_display */
4168 _aux->integer.int_to_display = *(int32_t *)xcb_tmp;
4169 xcb_block_len += sizeof(int32_t);
4170 xcb_tmp += sizeof(int32_t);
4171 xcb_align_to = ALIGNOF(int32_t);
4172 }
4173 if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
4174 /* xcb_input_feedback_ctl_data_t.led.led_mask */
4175 _aux->led.led_mask = *(uint32_t *)xcb_tmp;
4176 xcb_block_len += sizeof(uint32_t);
4177 xcb_tmp += sizeof(uint32_t);
4178 xcb_align_to = ALIGNOF(uint32_t);
4179 /* xcb_input_feedback_ctl_data_t.led.led_values */
4180 _aux->led.led_values = *(uint32_t *)xcb_tmp;
4181 xcb_block_len += sizeof(uint32_t);
4182 xcb_tmp += sizeof(uint32_t);
4183 xcb_align_to = ALIGNOF(uint32_t);
4184 }
4185 if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
4186 /* xcb_input_feedback_ctl_data_t.bell.percent */
4187 _aux->bell.percent = *(int8_t *)xcb_tmp;
4188 xcb_block_len += sizeof(int8_t);
4189 xcb_tmp += sizeof(int8_t);
4190 xcb_align_to = ALIGNOF(int8_t);
4191 /* xcb_input_feedback_ctl_data_t.bell.pad2 */
4192 _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp;
4193 _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp;
4194 _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp;
4195 xcb_block_len += sizeof(uint8_t) * 3;
4196 xcb_tmp += sizeof(uint8_t) * 3;
4197 xcb_align_to = ALIGNOF(uint8_t);
4198 /* xcb_input_feedback_ctl_data_t.bell.pitch */
4199 _aux->bell.pitch = *(int16_t *)xcb_tmp;
4200 xcb_block_len += sizeof(int16_t);
4201 xcb_tmp += sizeof(int16_t);
4202 xcb_align_to = ALIGNOF(int16_t);
4203 /* xcb_input_feedback_ctl_data_t.bell.duration */
4204 _aux->bell.duration = *(int16_t *)xcb_tmp;
4205 xcb_block_len += sizeof(int16_t);
4206 xcb_tmp += sizeof(int16_t);
4207 xcb_align_to = ALIGNOF(int16_t);
4208 }
4209 /* insert padding */
4210 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4211 xcb_buffer_len += xcb_block_len + xcb_pad;
4212 if (0 != xcb_pad) {
4213 xcb_tmp += xcb_pad;
4214 xcb_pad = 0;
4215 }
4216 xcb_block_len = 0;
4217 xcb_padding_offset = 0;
4218
4219 return xcb_buffer_len;
4220 }
4221
4222 int
xcb_input_feedback_ctl_data_sizeof(const void * _buffer,uint8_t class_id)4223 xcb_input_feedback_ctl_data_sizeof (const void *_buffer,
4224 uint8_t class_id)
4225 {
4226 xcb_input_feedback_ctl_data_t _aux;
4227 return xcb_input_feedback_ctl_data_unpack(_buffer, class_id, &_aux);
4228 }
4229
4230 int
xcb_input_feedback_ctl_sizeof(const void * _buffer)4231 xcb_input_feedback_ctl_sizeof (const void *_buffer)
4232 {
4233 char *xcb_tmp = (char *)_buffer;
4234 const xcb_input_feedback_ctl_t *_aux = (xcb_input_feedback_ctl_t *)_buffer;
4235 unsigned int xcb_buffer_len = 0;
4236 unsigned int xcb_block_len = 0;
4237 unsigned int xcb_pad = 0;
4238 unsigned int xcb_align_to = 0;
4239
4240
4241 xcb_block_len += sizeof(xcb_input_feedback_ctl_t);
4242 xcb_tmp += xcb_block_len;
4243 xcb_buffer_len += xcb_block_len;
4244 xcb_block_len = 0;
4245 /* data */
4246 xcb_block_len += xcb_input_feedback_ctl_data_sizeof(xcb_tmp, _aux->class_id);
4247 xcb_tmp += xcb_block_len;
4248 xcb_align_to = ALIGNOF(char);
4249 /* insert padding */
4250 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4251 xcb_buffer_len += xcb_block_len + xcb_pad;
4252 if (0 != xcb_pad) {
4253 xcb_tmp += xcb_pad;
4254 xcb_pad = 0;
4255 }
4256 xcb_block_len = 0;
4257
4258 return xcb_buffer_len;
4259 }
4260
4261 void *
xcb_input_feedback_ctl_data(const xcb_input_feedback_ctl_t * R)4262 xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R)
4263 {
4264 return (void *) (R + 1);
4265 }
4266
4267 void
xcb_input_feedback_ctl_next(xcb_input_feedback_ctl_iterator_t * i)4268 xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i)
4269 {
4270 xcb_input_feedback_ctl_t *R = i->data;
4271 xcb_generic_iterator_t child;
4272 child.data = (xcb_input_feedback_ctl_t *)(((char *)R) + xcb_input_feedback_ctl_sizeof(R));
4273 i->index = (char *) child.data - (char *) i->data;
4274 --i->rem;
4275 i->data = (xcb_input_feedback_ctl_t *) child.data;
4276 }
4277
4278 xcb_generic_iterator_t
xcb_input_feedback_ctl_end(xcb_input_feedback_ctl_iterator_t i)4279 xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i)
4280 {
4281 xcb_generic_iterator_t ret;
4282 while(i.rem > 0)
4283 xcb_input_feedback_ctl_next(&i);
4284 ret.data = i.data;
4285 ret.rem = i.rem;
4286 ret.index = i.index;
4287 return ret;
4288 }
4289
4290 int
xcb_input_change_feedback_control_sizeof(const void * _buffer)4291 xcb_input_change_feedback_control_sizeof (const void *_buffer)
4292 {
4293 char *xcb_tmp = (char *)_buffer;
4294 unsigned int xcb_buffer_len = 0;
4295 unsigned int xcb_block_len = 0;
4296 unsigned int xcb_pad = 0;
4297 unsigned int xcb_align_to = 0;
4298
4299
4300 xcb_block_len += sizeof(xcb_input_change_feedback_control_request_t);
4301 xcb_tmp += xcb_block_len;
4302 xcb_buffer_len += xcb_block_len;
4303 xcb_block_len = 0;
4304 /* feedback */
4305 xcb_block_len += xcb_input_feedback_ctl_sizeof(xcb_tmp);
4306 xcb_tmp += xcb_block_len;
4307 xcb_align_to = ALIGNOF(xcb_input_feedback_ctl_t);
4308 /* insert padding */
4309 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4310 xcb_buffer_len += xcb_block_len + xcb_pad;
4311 if (0 != xcb_pad) {
4312 xcb_tmp += xcb_pad;
4313 xcb_pad = 0;
4314 }
4315 xcb_block_len = 0;
4316
4317 return xcb_buffer_len;
4318 }
4319
4320 xcb_void_cookie_t
xcb_input_change_feedback_control_checked(xcb_connection_t * c,uint32_t mask,uint8_t device_id,uint8_t feedback_id,xcb_input_feedback_ctl_t * feedback)4321 xcb_input_change_feedback_control_checked (xcb_connection_t *c,
4322 uint32_t mask,
4323 uint8_t device_id,
4324 uint8_t feedback_id,
4325 xcb_input_feedback_ctl_t *feedback)
4326 {
4327 static const xcb_protocol_request_t xcb_req = {
4328 .count = 4,
4329 .ext = &xcb_input_id,
4330 .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL,
4331 .isvoid = 1
4332 };
4333
4334 struct iovec xcb_parts[6];
4335 xcb_void_cookie_t xcb_ret;
4336 xcb_input_change_feedback_control_request_t xcb_out;
4337
4338 xcb_out.mask = mask;
4339 xcb_out.device_id = device_id;
4340 xcb_out.feedback_id = feedback_id;
4341 memset(xcb_out.pad0, 0, 2);
4342
4343 xcb_parts[2].iov_base = (char *) &xcb_out;
4344 xcb_parts[2].iov_len = sizeof(xcb_out);
4345 xcb_parts[3].iov_base = 0;
4346 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4347 /* xcb_input_feedback_ctl_t feedback */
4348 xcb_parts[4].iov_base = (char *) feedback;
4349 xcb_parts[4].iov_len =
4350 xcb_input_feedback_ctl_sizeof (feedback);
4351
4352 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4353 return xcb_ret;
4354 }
4355
4356 xcb_void_cookie_t
xcb_input_change_feedback_control(xcb_connection_t * c,uint32_t mask,uint8_t device_id,uint8_t feedback_id,xcb_input_feedback_ctl_t * feedback)4357 xcb_input_change_feedback_control (xcb_connection_t *c,
4358 uint32_t mask,
4359 uint8_t device_id,
4360 uint8_t feedback_id,
4361 xcb_input_feedback_ctl_t *feedback)
4362 {
4363 static const xcb_protocol_request_t xcb_req = {
4364 .count = 4,
4365 .ext = &xcb_input_id,
4366 .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL,
4367 .isvoid = 1
4368 };
4369
4370 struct iovec xcb_parts[6];
4371 xcb_void_cookie_t xcb_ret;
4372 xcb_input_change_feedback_control_request_t xcb_out;
4373
4374 xcb_out.mask = mask;
4375 xcb_out.device_id = device_id;
4376 xcb_out.feedback_id = feedback_id;
4377 memset(xcb_out.pad0, 0, 2);
4378
4379 xcb_parts[2].iov_base = (char *) &xcb_out;
4380 xcb_parts[2].iov_len = sizeof(xcb_out);
4381 xcb_parts[3].iov_base = 0;
4382 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4383 /* xcb_input_feedback_ctl_t feedback */
4384 xcb_parts[4].iov_base = (char *) feedback;
4385 xcb_parts[4].iov_len =
4386 xcb_input_feedback_ctl_sizeof (feedback);
4387
4388 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4389 return xcb_ret;
4390 }
4391
4392 xcb_input_feedback_ctl_t *
xcb_input_change_feedback_control_feedback(const xcb_input_change_feedback_control_request_t * R)4393 xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R)
4394 {
4395 return (xcb_input_feedback_ctl_t *) (R + 1);
4396 }
4397
4398 int
xcb_input_get_device_key_mapping_sizeof(const void * _buffer)4399 xcb_input_get_device_key_mapping_sizeof (const void *_buffer)
4400 {
4401 char *xcb_tmp = (char *)_buffer;
4402 const xcb_input_get_device_key_mapping_reply_t *_aux = (xcb_input_get_device_key_mapping_reply_t *)_buffer;
4403 unsigned int xcb_buffer_len = 0;
4404 unsigned int xcb_block_len = 0;
4405 unsigned int xcb_pad = 0;
4406 unsigned int xcb_align_to = 0;
4407
4408
4409 xcb_block_len += sizeof(xcb_input_get_device_key_mapping_reply_t);
4410 xcb_tmp += xcb_block_len;
4411 xcb_buffer_len += xcb_block_len;
4412 xcb_block_len = 0;
4413 /* keysyms */
4414 xcb_block_len += _aux->length * sizeof(xcb_keysym_t);
4415 xcb_tmp += xcb_block_len;
4416 xcb_align_to = ALIGNOF(xcb_keysym_t);
4417 /* insert padding */
4418 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4419 xcb_buffer_len += xcb_block_len + xcb_pad;
4420 if (0 != xcb_pad) {
4421 xcb_tmp += xcb_pad;
4422 xcb_pad = 0;
4423 }
4424 xcb_block_len = 0;
4425
4426 return xcb_buffer_len;
4427 }
4428
4429 xcb_input_get_device_key_mapping_cookie_t
xcb_input_get_device_key_mapping(xcb_connection_t * c,uint8_t device_id,xcb_input_key_code_t first_keycode,uint8_t count)4430 xcb_input_get_device_key_mapping (xcb_connection_t *c,
4431 uint8_t device_id,
4432 xcb_input_key_code_t first_keycode,
4433 uint8_t count)
4434 {
4435 static const xcb_protocol_request_t xcb_req = {
4436 .count = 2,
4437 .ext = &xcb_input_id,
4438 .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING,
4439 .isvoid = 0
4440 };
4441
4442 struct iovec xcb_parts[4];
4443 xcb_input_get_device_key_mapping_cookie_t xcb_ret;
4444 xcb_input_get_device_key_mapping_request_t xcb_out;
4445
4446 xcb_out.device_id = device_id;
4447 xcb_out.first_keycode = first_keycode;
4448 xcb_out.count = count;
4449 xcb_out.pad0 = 0;
4450
4451 xcb_parts[2].iov_base = (char *) &xcb_out;
4452 xcb_parts[2].iov_len = sizeof(xcb_out);
4453 xcb_parts[3].iov_base = 0;
4454 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4455
4456 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4457 return xcb_ret;
4458 }
4459
4460 xcb_input_get_device_key_mapping_cookie_t
xcb_input_get_device_key_mapping_unchecked(xcb_connection_t * c,uint8_t device_id,xcb_input_key_code_t first_keycode,uint8_t count)4461 xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c,
4462 uint8_t device_id,
4463 xcb_input_key_code_t first_keycode,
4464 uint8_t count)
4465 {
4466 static const xcb_protocol_request_t xcb_req = {
4467 .count = 2,
4468 .ext = &xcb_input_id,
4469 .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING,
4470 .isvoid = 0
4471 };
4472
4473 struct iovec xcb_parts[4];
4474 xcb_input_get_device_key_mapping_cookie_t xcb_ret;
4475 xcb_input_get_device_key_mapping_request_t xcb_out;
4476
4477 xcb_out.device_id = device_id;
4478 xcb_out.first_keycode = first_keycode;
4479 xcb_out.count = count;
4480 xcb_out.pad0 = 0;
4481
4482 xcb_parts[2].iov_base = (char *) &xcb_out;
4483 xcb_parts[2].iov_len = sizeof(xcb_out);
4484 xcb_parts[3].iov_base = 0;
4485 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4486
4487 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4488 return xcb_ret;
4489 }
4490
4491 xcb_keysym_t *
xcb_input_get_device_key_mapping_keysyms(const xcb_input_get_device_key_mapping_reply_t * R)4492 xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R)
4493 {
4494 return (xcb_keysym_t *) (R + 1);
4495 }
4496
4497 int
xcb_input_get_device_key_mapping_keysyms_length(const xcb_input_get_device_key_mapping_reply_t * R)4498 xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R)
4499 {
4500 return R->length;
4501 }
4502
4503 xcb_generic_iterator_t
xcb_input_get_device_key_mapping_keysyms_end(const xcb_input_get_device_key_mapping_reply_t * R)4504 xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R)
4505 {
4506 xcb_generic_iterator_t i;
4507 i.data = ((xcb_keysym_t *) (R + 1)) + (R->length);
4508 i.rem = 0;
4509 i.index = (char *) i.data - (char *) R;
4510 return i;
4511 }
4512
4513 xcb_input_get_device_key_mapping_reply_t *
xcb_input_get_device_key_mapping_reply(xcb_connection_t * c,xcb_input_get_device_key_mapping_cookie_t cookie,xcb_generic_error_t ** e)4514 xcb_input_get_device_key_mapping_reply (xcb_connection_t *c,
4515 xcb_input_get_device_key_mapping_cookie_t cookie /**< */,
4516 xcb_generic_error_t **e)
4517 {
4518 return (xcb_input_get_device_key_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4519 }
4520
4521 int
xcb_input_change_device_key_mapping_sizeof(const void * _buffer)4522 xcb_input_change_device_key_mapping_sizeof (const void *_buffer)
4523 {
4524 char *xcb_tmp = (char *)_buffer;
4525 const xcb_input_change_device_key_mapping_request_t *_aux = (xcb_input_change_device_key_mapping_request_t *)_buffer;
4526 unsigned int xcb_buffer_len = 0;
4527 unsigned int xcb_block_len = 0;
4528 unsigned int xcb_pad = 0;
4529 unsigned int xcb_align_to = 0;
4530
4531
4532 xcb_block_len += sizeof(xcb_input_change_device_key_mapping_request_t);
4533 xcb_tmp += xcb_block_len;
4534 xcb_buffer_len += xcb_block_len;
4535 xcb_block_len = 0;
4536 /* keysyms */
4537 xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t);
4538 xcb_tmp += xcb_block_len;
4539 xcb_align_to = ALIGNOF(xcb_keysym_t);
4540 /* insert padding */
4541 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4542 xcb_buffer_len += xcb_block_len + xcb_pad;
4543 if (0 != xcb_pad) {
4544 xcb_tmp += xcb_pad;
4545 xcb_pad = 0;
4546 }
4547 xcb_block_len = 0;
4548
4549 return xcb_buffer_len;
4550 }
4551
4552 xcb_void_cookie_t
xcb_input_change_device_key_mapping_checked(xcb_connection_t * c,uint8_t device_id,xcb_input_key_code_t first_keycode,uint8_t keysyms_per_keycode,uint8_t keycode_count,const xcb_keysym_t * keysyms)4553 xcb_input_change_device_key_mapping_checked (xcb_connection_t *c,
4554 uint8_t device_id,
4555 xcb_input_key_code_t first_keycode,
4556 uint8_t keysyms_per_keycode,
4557 uint8_t keycode_count,
4558 const xcb_keysym_t *keysyms)
4559 {
4560 static const xcb_protocol_request_t xcb_req = {
4561 .count = 4,
4562 .ext = &xcb_input_id,
4563 .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING,
4564 .isvoid = 1
4565 };
4566
4567 struct iovec xcb_parts[6];
4568 xcb_void_cookie_t xcb_ret;
4569 xcb_input_change_device_key_mapping_request_t xcb_out;
4570
4571 xcb_out.device_id = device_id;
4572 xcb_out.first_keycode = first_keycode;
4573 xcb_out.keysyms_per_keycode = keysyms_per_keycode;
4574 xcb_out.keycode_count = keycode_count;
4575
4576 xcb_parts[2].iov_base = (char *) &xcb_out;
4577 xcb_parts[2].iov_len = sizeof(xcb_out);
4578 xcb_parts[3].iov_base = 0;
4579 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4580 /* xcb_keysym_t keysyms */
4581 xcb_parts[4].iov_base = (char *) keysyms;
4582 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
4583 xcb_parts[5].iov_base = 0;
4584 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4585
4586 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4587 return xcb_ret;
4588 }
4589
4590 xcb_void_cookie_t
xcb_input_change_device_key_mapping(xcb_connection_t * c,uint8_t device_id,xcb_input_key_code_t first_keycode,uint8_t keysyms_per_keycode,uint8_t keycode_count,const xcb_keysym_t * keysyms)4591 xcb_input_change_device_key_mapping (xcb_connection_t *c,
4592 uint8_t device_id,
4593 xcb_input_key_code_t first_keycode,
4594 uint8_t keysyms_per_keycode,
4595 uint8_t keycode_count,
4596 const xcb_keysym_t *keysyms)
4597 {
4598 static const xcb_protocol_request_t xcb_req = {
4599 .count = 4,
4600 .ext = &xcb_input_id,
4601 .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING,
4602 .isvoid = 1
4603 };
4604
4605 struct iovec xcb_parts[6];
4606 xcb_void_cookie_t xcb_ret;
4607 xcb_input_change_device_key_mapping_request_t xcb_out;
4608
4609 xcb_out.device_id = device_id;
4610 xcb_out.first_keycode = first_keycode;
4611 xcb_out.keysyms_per_keycode = keysyms_per_keycode;
4612 xcb_out.keycode_count = keycode_count;
4613
4614 xcb_parts[2].iov_base = (char *) &xcb_out;
4615 xcb_parts[2].iov_len = sizeof(xcb_out);
4616 xcb_parts[3].iov_base = 0;
4617 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4618 /* xcb_keysym_t keysyms */
4619 xcb_parts[4].iov_base = (char *) keysyms;
4620 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
4621 xcb_parts[5].iov_base = 0;
4622 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4623
4624 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4625 return xcb_ret;
4626 }
4627
4628 xcb_keysym_t *
xcb_input_change_device_key_mapping_keysyms(const xcb_input_change_device_key_mapping_request_t * R)4629 xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R)
4630 {
4631 return (xcb_keysym_t *) (R + 1);
4632 }
4633
4634 int
xcb_input_change_device_key_mapping_keysyms_length(const xcb_input_change_device_key_mapping_request_t * R)4635 xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R)
4636 {
4637 return (R->keycode_count * R->keysyms_per_keycode);
4638 }
4639
4640 xcb_generic_iterator_t
xcb_input_change_device_key_mapping_keysyms_end(const xcb_input_change_device_key_mapping_request_t * R)4641 xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R)
4642 {
4643 xcb_generic_iterator_t i;
4644 i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode));
4645 i.rem = 0;
4646 i.index = (char *) i.data - (char *) R;
4647 return i;
4648 }
4649
4650 int
xcb_input_get_device_modifier_mapping_sizeof(const void * _buffer)4651 xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer)
4652 {
4653 char *xcb_tmp = (char *)_buffer;
4654 const xcb_input_get_device_modifier_mapping_reply_t *_aux = (xcb_input_get_device_modifier_mapping_reply_t *)_buffer;
4655 unsigned int xcb_buffer_len = 0;
4656 unsigned int xcb_block_len = 0;
4657 unsigned int xcb_pad = 0;
4658 unsigned int xcb_align_to = 0;
4659
4660
4661 xcb_block_len += sizeof(xcb_input_get_device_modifier_mapping_reply_t);
4662 xcb_tmp += xcb_block_len;
4663 xcb_buffer_len += xcb_block_len;
4664 xcb_block_len = 0;
4665 /* keymaps */
4666 xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t);
4667 xcb_tmp += xcb_block_len;
4668 xcb_align_to = ALIGNOF(uint8_t);
4669 /* insert padding */
4670 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4671 xcb_buffer_len += xcb_block_len + xcb_pad;
4672 if (0 != xcb_pad) {
4673 xcb_tmp += xcb_pad;
4674 xcb_pad = 0;
4675 }
4676 xcb_block_len = 0;
4677
4678 return xcb_buffer_len;
4679 }
4680
4681 xcb_input_get_device_modifier_mapping_cookie_t
xcb_input_get_device_modifier_mapping(xcb_connection_t * c,uint8_t device_id)4682 xcb_input_get_device_modifier_mapping (xcb_connection_t *c,
4683 uint8_t device_id)
4684 {
4685 static const xcb_protocol_request_t xcb_req = {
4686 .count = 2,
4687 .ext = &xcb_input_id,
4688 .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING,
4689 .isvoid = 0
4690 };
4691
4692 struct iovec xcb_parts[4];
4693 xcb_input_get_device_modifier_mapping_cookie_t xcb_ret;
4694 xcb_input_get_device_modifier_mapping_request_t xcb_out;
4695
4696 xcb_out.device_id = device_id;
4697 memset(xcb_out.pad0, 0, 3);
4698
4699 xcb_parts[2].iov_base = (char *) &xcb_out;
4700 xcb_parts[2].iov_len = sizeof(xcb_out);
4701 xcb_parts[3].iov_base = 0;
4702 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4703
4704 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4705 return xcb_ret;
4706 }
4707
4708 xcb_input_get_device_modifier_mapping_cookie_t
xcb_input_get_device_modifier_mapping_unchecked(xcb_connection_t * c,uint8_t device_id)4709 xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c,
4710 uint8_t device_id)
4711 {
4712 static const xcb_protocol_request_t xcb_req = {
4713 .count = 2,
4714 .ext = &xcb_input_id,
4715 .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING,
4716 .isvoid = 0
4717 };
4718
4719 struct iovec xcb_parts[4];
4720 xcb_input_get_device_modifier_mapping_cookie_t xcb_ret;
4721 xcb_input_get_device_modifier_mapping_request_t xcb_out;
4722
4723 xcb_out.device_id = device_id;
4724 memset(xcb_out.pad0, 0, 3);
4725
4726 xcb_parts[2].iov_base = (char *) &xcb_out;
4727 xcb_parts[2].iov_len = sizeof(xcb_out);
4728 xcb_parts[3].iov_base = 0;
4729 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4730
4731 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4732 return xcb_ret;
4733 }
4734
4735 uint8_t *
xcb_input_get_device_modifier_mapping_keymaps(const xcb_input_get_device_modifier_mapping_reply_t * R)4736 xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R)
4737 {
4738 return (uint8_t *) (R + 1);
4739 }
4740
4741 int
xcb_input_get_device_modifier_mapping_keymaps_length(const xcb_input_get_device_modifier_mapping_reply_t * R)4742 xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R)
4743 {
4744 return (R->keycodes_per_modifier * 8);
4745 }
4746
4747 xcb_generic_iterator_t
xcb_input_get_device_modifier_mapping_keymaps_end(const xcb_input_get_device_modifier_mapping_reply_t * R)4748 xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R)
4749 {
4750 xcb_generic_iterator_t i;
4751 i.data = ((uint8_t *) (R + 1)) + ((R->keycodes_per_modifier * 8));
4752 i.rem = 0;
4753 i.index = (char *) i.data - (char *) R;
4754 return i;
4755 }
4756
4757 xcb_input_get_device_modifier_mapping_reply_t *
xcb_input_get_device_modifier_mapping_reply(xcb_connection_t * c,xcb_input_get_device_modifier_mapping_cookie_t cookie,xcb_generic_error_t ** e)4758 xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c,
4759 xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */,
4760 xcb_generic_error_t **e)
4761 {
4762 return (xcb_input_get_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4763 }
4764
4765 int
xcb_input_set_device_modifier_mapping_sizeof(const void * _buffer)4766 xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer)
4767 {
4768 char *xcb_tmp = (char *)_buffer;
4769 const xcb_input_set_device_modifier_mapping_request_t *_aux = (xcb_input_set_device_modifier_mapping_request_t *)_buffer;
4770 unsigned int xcb_buffer_len = 0;
4771 unsigned int xcb_block_len = 0;
4772 unsigned int xcb_pad = 0;
4773 unsigned int xcb_align_to = 0;
4774
4775
4776 xcb_block_len += sizeof(xcb_input_set_device_modifier_mapping_request_t);
4777 xcb_tmp += xcb_block_len;
4778 xcb_buffer_len += xcb_block_len;
4779 xcb_block_len = 0;
4780 /* keymaps */
4781 xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t);
4782 xcb_tmp += xcb_block_len;
4783 xcb_align_to = ALIGNOF(uint8_t);
4784 /* insert padding */
4785 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4786 xcb_buffer_len += xcb_block_len + xcb_pad;
4787 if (0 != xcb_pad) {
4788 xcb_tmp += xcb_pad;
4789 xcb_pad = 0;
4790 }
4791 xcb_block_len = 0;
4792
4793 return xcb_buffer_len;
4794 }
4795
4796 xcb_input_set_device_modifier_mapping_cookie_t
xcb_input_set_device_modifier_mapping(xcb_connection_t * c,uint8_t device_id,uint8_t keycodes_per_modifier,const uint8_t * keymaps)4797 xcb_input_set_device_modifier_mapping (xcb_connection_t *c,
4798 uint8_t device_id,
4799 uint8_t keycodes_per_modifier,
4800 const uint8_t *keymaps)
4801 {
4802 static const xcb_protocol_request_t xcb_req = {
4803 .count = 4,
4804 .ext = &xcb_input_id,
4805 .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING,
4806 .isvoid = 0
4807 };
4808
4809 struct iovec xcb_parts[6];
4810 xcb_input_set_device_modifier_mapping_cookie_t xcb_ret;
4811 xcb_input_set_device_modifier_mapping_request_t xcb_out;
4812
4813 xcb_out.device_id = device_id;
4814 xcb_out.keycodes_per_modifier = keycodes_per_modifier;
4815 memset(xcb_out.pad0, 0, 2);
4816
4817 xcb_parts[2].iov_base = (char *) &xcb_out;
4818 xcb_parts[2].iov_len = sizeof(xcb_out);
4819 xcb_parts[3].iov_base = 0;
4820 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4821 /* uint8_t keymaps */
4822 xcb_parts[4].iov_base = (char *) keymaps;
4823 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
4824 xcb_parts[5].iov_base = 0;
4825 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4826
4827 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4828 return xcb_ret;
4829 }
4830
4831 xcb_input_set_device_modifier_mapping_cookie_t
xcb_input_set_device_modifier_mapping_unchecked(xcb_connection_t * c,uint8_t device_id,uint8_t keycodes_per_modifier,const uint8_t * keymaps)4832 xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c,
4833 uint8_t device_id,
4834 uint8_t keycodes_per_modifier,
4835 const uint8_t *keymaps)
4836 {
4837 static const xcb_protocol_request_t xcb_req = {
4838 .count = 4,
4839 .ext = &xcb_input_id,
4840 .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING,
4841 .isvoid = 0
4842 };
4843
4844 struct iovec xcb_parts[6];
4845 xcb_input_set_device_modifier_mapping_cookie_t xcb_ret;
4846 xcb_input_set_device_modifier_mapping_request_t xcb_out;
4847
4848 xcb_out.device_id = device_id;
4849 xcb_out.keycodes_per_modifier = keycodes_per_modifier;
4850 memset(xcb_out.pad0, 0, 2);
4851
4852 xcb_parts[2].iov_base = (char *) &xcb_out;
4853 xcb_parts[2].iov_len = sizeof(xcb_out);
4854 xcb_parts[3].iov_base = 0;
4855 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4856 /* uint8_t keymaps */
4857 xcb_parts[4].iov_base = (char *) keymaps;
4858 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
4859 xcb_parts[5].iov_base = 0;
4860 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
4861
4862 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4863 return xcb_ret;
4864 }
4865
4866 xcb_input_set_device_modifier_mapping_reply_t *
xcb_input_set_device_modifier_mapping_reply(xcb_connection_t * c,xcb_input_set_device_modifier_mapping_cookie_t cookie,xcb_generic_error_t ** e)4867 xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c,
4868 xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */,
4869 xcb_generic_error_t **e)
4870 {
4871 return (xcb_input_set_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4872 }
4873
4874 int
xcb_input_get_device_button_mapping_sizeof(const void * _buffer)4875 xcb_input_get_device_button_mapping_sizeof (const void *_buffer)
4876 {
4877 char *xcb_tmp = (char *)_buffer;
4878 const xcb_input_get_device_button_mapping_reply_t *_aux = (xcb_input_get_device_button_mapping_reply_t *)_buffer;
4879 unsigned int xcb_buffer_len = 0;
4880 unsigned int xcb_block_len = 0;
4881 unsigned int xcb_pad = 0;
4882 unsigned int xcb_align_to = 0;
4883
4884
4885 xcb_block_len += sizeof(xcb_input_get_device_button_mapping_reply_t);
4886 xcb_tmp += xcb_block_len;
4887 xcb_buffer_len += xcb_block_len;
4888 xcb_block_len = 0;
4889 /* map */
4890 xcb_block_len += _aux->map_size * sizeof(uint8_t);
4891 xcb_tmp += xcb_block_len;
4892 xcb_align_to = ALIGNOF(uint8_t);
4893 xcb_align_to = 4;
4894 /* insert padding */
4895 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4896 xcb_buffer_len += xcb_block_len + xcb_pad;
4897 if (0 != xcb_pad) {
4898 xcb_tmp += xcb_pad;
4899 xcb_pad = 0;
4900 }
4901 xcb_block_len = 0;
4902 /* insert padding */
4903 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4904 xcb_buffer_len += xcb_block_len + xcb_pad;
4905 if (0 != xcb_pad) {
4906 xcb_tmp += xcb_pad;
4907 xcb_pad = 0;
4908 }
4909 xcb_block_len = 0;
4910
4911 return xcb_buffer_len;
4912 }
4913
4914 xcb_input_get_device_button_mapping_cookie_t
xcb_input_get_device_button_mapping(xcb_connection_t * c,uint8_t device_id)4915 xcb_input_get_device_button_mapping (xcb_connection_t *c,
4916 uint8_t device_id)
4917 {
4918 static const xcb_protocol_request_t xcb_req = {
4919 .count = 2,
4920 .ext = &xcb_input_id,
4921 .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING,
4922 .isvoid = 0
4923 };
4924
4925 struct iovec xcb_parts[4];
4926 xcb_input_get_device_button_mapping_cookie_t xcb_ret;
4927 xcb_input_get_device_button_mapping_request_t xcb_out;
4928
4929 xcb_out.device_id = device_id;
4930 memset(xcb_out.pad0, 0, 3);
4931
4932 xcb_parts[2].iov_base = (char *) &xcb_out;
4933 xcb_parts[2].iov_len = sizeof(xcb_out);
4934 xcb_parts[3].iov_base = 0;
4935 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4936
4937 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4938 return xcb_ret;
4939 }
4940
4941 xcb_input_get_device_button_mapping_cookie_t
xcb_input_get_device_button_mapping_unchecked(xcb_connection_t * c,uint8_t device_id)4942 xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c,
4943 uint8_t device_id)
4944 {
4945 static const xcb_protocol_request_t xcb_req = {
4946 .count = 2,
4947 .ext = &xcb_input_id,
4948 .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING,
4949 .isvoid = 0
4950 };
4951
4952 struct iovec xcb_parts[4];
4953 xcb_input_get_device_button_mapping_cookie_t xcb_ret;
4954 xcb_input_get_device_button_mapping_request_t xcb_out;
4955
4956 xcb_out.device_id = device_id;
4957 memset(xcb_out.pad0, 0, 3);
4958
4959 xcb_parts[2].iov_base = (char *) &xcb_out;
4960 xcb_parts[2].iov_len = sizeof(xcb_out);
4961 xcb_parts[3].iov_base = 0;
4962 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4963
4964 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4965 return xcb_ret;
4966 }
4967
4968 uint8_t *
xcb_input_get_device_button_mapping_map(const xcb_input_get_device_button_mapping_reply_t * R)4969 xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R)
4970 {
4971 return (uint8_t *) (R + 1);
4972 }
4973
4974 int
xcb_input_get_device_button_mapping_map_length(const xcb_input_get_device_button_mapping_reply_t * R)4975 xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R)
4976 {
4977 return R->map_size;
4978 }
4979
4980 xcb_generic_iterator_t
xcb_input_get_device_button_mapping_map_end(const xcb_input_get_device_button_mapping_reply_t * R)4981 xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R)
4982 {
4983 xcb_generic_iterator_t i;
4984 i.data = ((uint8_t *) (R + 1)) + (R->map_size);
4985 i.rem = 0;
4986 i.index = (char *) i.data - (char *) R;
4987 return i;
4988 }
4989
4990 xcb_input_get_device_button_mapping_reply_t *
xcb_input_get_device_button_mapping_reply(xcb_connection_t * c,xcb_input_get_device_button_mapping_cookie_t cookie,xcb_generic_error_t ** e)4991 xcb_input_get_device_button_mapping_reply (xcb_connection_t *c,
4992 xcb_input_get_device_button_mapping_cookie_t cookie /**< */,
4993 xcb_generic_error_t **e)
4994 {
4995 return (xcb_input_get_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
4996 }
4997
4998 int
xcb_input_set_device_button_mapping_sizeof(const void * _buffer)4999 xcb_input_set_device_button_mapping_sizeof (const void *_buffer)
5000 {
5001 char *xcb_tmp = (char *)_buffer;
5002 const xcb_input_set_device_button_mapping_request_t *_aux = (xcb_input_set_device_button_mapping_request_t *)_buffer;
5003 unsigned int xcb_buffer_len = 0;
5004 unsigned int xcb_block_len = 0;
5005 unsigned int xcb_pad = 0;
5006 unsigned int xcb_align_to = 0;
5007
5008
5009 xcb_block_len += sizeof(xcb_input_set_device_button_mapping_request_t);
5010 xcb_tmp += xcb_block_len;
5011 xcb_buffer_len += xcb_block_len;
5012 xcb_block_len = 0;
5013 /* map */
5014 xcb_block_len += _aux->map_size * sizeof(uint8_t);
5015 xcb_tmp += xcb_block_len;
5016 xcb_align_to = ALIGNOF(uint8_t);
5017 /* insert padding */
5018 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5019 xcb_buffer_len += xcb_block_len + xcb_pad;
5020 if (0 != xcb_pad) {
5021 xcb_tmp += xcb_pad;
5022 xcb_pad = 0;
5023 }
5024 xcb_block_len = 0;
5025
5026 return xcb_buffer_len;
5027 }
5028
5029 xcb_input_set_device_button_mapping_cookie_t
xcb_input_set_device_button_mapping(xcb_connection_t * c,uint8_t device_id,uint8_t map_size,const uint8_t * map)5030 xcb_input_set_device_button_mapping (xcb_connection_t *c,
5031 uint8_t device_id,
5032 uint8_t map_size,
5033 const uint8_t *map)
5034 {
5035 static const xcb_protocol_request_t xcb_req = {
5036 .count = 4,
5037 .ext = &xcb_input_id,
5038 .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING,
5039 .isvoid = 0
5040 };
5041
5042 struct iovec xcb_parts[6];
5043 xcb_input_set_device_button_mapping_cookie_t xcb_ret;
5044 xcb_input_set_device_button_mapping_request_t xcb_out;
5045
5046 xcb_out.device_id = device_id;
5047 xcb_out.map_size = map_size;
5048 memset(xcb_out.pad0, 0, 2);
5049
5050 xcb_parts[2].iov_base = (char *) &xcb_out;
5051 xcb_parts[2].iov_len = sizeof(xcb_out);
5052 xcb_parts[3].iov_base = 0;
5053 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5054 /* uint8_t map */
5055 xcb_parts[4].iov_base = (char *) map;
5056 xcb_parts[4].iov_len = map_size * sizeof(uint8_t);
5057 xcb_parts[5].iov_base = 0;
5058 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5059
5060 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5061 return xcb_ret;
5062 }
5063
5064 xcb_input_set_device_button_mapping_cookie_t
xcb_input_set_device_button_mapping_unchecked(xcb_connection_t * c,uint8_t device_id,uint8_t map_size,const uint8_t * map)5065 xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c,
5066 uint8_t device_id,
5067 uint8_t map_size,
5068 const uint8_t *map)
5069 {
5070 static const xcb_protocol_request_t xcb_req = {
5071 .count = 4,
5072 .ext = &xcb_input_id,
5073 .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING,
5074 .isvoid = 0
5075 };
5076
5077 struct iovec xcb_parts[6];
5078 xcb_input_set_device_button_mapping_cookie_t xcb_ret;
5079 xcb_input_set_device_button_mapping_request_t xcb_out;
5080
5081 xcb_out.device_id = device_id;
5082 xcb_out.map_size = map_size;
5083 memset(xcb_out.pad0, 0, 2);
5084
5085 xcb_parts[2].iov_base = (char *) &xcb_out;
5086 xcb_parts[2].iov_len = sizeof(xcb_out);
5087 xcb_parts[3].iov_base = 0;
5088 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5089 /* uint8_t map */
5090 xcb_parts[4].iov_base = (char *) map;
5091 xcb_parts[4].iov_len = map_size * sizeof(uint8_t);
5092 xcb_parts[5].iov_base = 0;
5093 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5094
5095 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5096 return xcb_ret;
5097 }
5098
5099 xcb_input_set_device_button_mapping_reply_t *
xcb_input_set_device_button_mapping_reply(xcb_connection_t * c,xcb_input_set_device_button_mapping_cookie_t cookie,xcb_generic_error_t ** e)5100 xcb_input_set_device_button_mapping_reply (xcb_connection_t *c,
5101 xcb_input_set_device_button_mapping_cookie_t cookie /**< */,
5102 xcb_generic_error_t **e)
5103 {
5104 return (xcb_input_set_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5105 }
5106
5107 void
xcb_input_key_state_next(xcb_input_key_state_iterator_t * i)5108 xcb_input_key_state_next (xcb_input_key_state_iterator_t *i)
5109 {
5110 --i->rem;
5111 ++i->data;
5112 i->index += sizeof(xcb_input_key_state_t);
5113 }
5114
5115 xcb_generic_iterator_t
xcb_input_key_state_end(xcb_input_key_state_iterator_t i)5116 xcb_input_key_state_end (xcb_input_key_state_iterator_t i)
5117 {
5118 xcb_generic_iterator_t ret;
5119 ret.data = i.data + i.rem;
5120 ret.index = i.index + ((char *) ret.data - (char *) i.data);
5121 ret.rem = 0;
5122 return ret;
5123 }
5124
5125 void
xcb_input_button_state_next(xcb_input_button_state_iterator_t * i)5126 xcb_input_button_state_next (xcb_input_button_state_iterator_t *i)
5127 {
5128 --i->rem;
5129 ++i->data;
5130 i->index += sizeof(xcb_input_button_state_t);
5131 }
5132
5133 xcb_generic_iterator_t
xcb_input_button_state_end(xcb_input_button_state_iterator_t i)5134 xcb_input_button_state_end (xcb_input_button_state_iterator_t i)
5135 {
5136 xcb_generic_iterator_t ret;
5137 ret.data = i.data + i.rem;
5138 ret.index = i.index + ((char *) ret.data - (char *) i.data);
5139 ret.rem = 0;
5140 return ret;
5141 }
5142
5143 int
xcb_input_valuator_state_sizeof(const void * _buffer)5144 xcb_input_valuator_state_sizeof (const void *_buffer)
5145 {
5146 char *xcb_tmp = (char *)_buffer;
5147 const xcb_input_valuator_state_t *_aux = (xcb_input_valuator_state_t *)_buffer;
5148 unsigned int xcb_buffer_len = 0;
5149 unsigned int xcb_block_len = 0;
5150 unsigned int xcb_pad = 0;
5151 unsigned int xcb_align_to = 0;
5152
5153
5154 xcb_block_len += sizeof(xcb_input_valuator_state_t);
5155 xcb_tmp += xcb_block_len;
5156 xcb_buffer_len += xcb_block_len;
5157 xcb_block_len = 0;
5158 /* valuators */
5159 xcb_block_len += _aux->num_valuators * sizeof(int32_t);
5160 xcb_tmp += xcb_block_len;
5161 xcb_align_to = ALIGNOF(int32_t);
5162 /* insert padding */
5163 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5164 xcb_buffer_len += xcb_block_len + xcb_pad;
5165 if (0 != xcb_pad) {
5166 xcb_tmp += xcb_pad;
5167 xcb_pad = 0;
5168 }
5169 xcb_block_len = 0;
5170
5171 return xcb_buffer_len;
5172 }
5173
5174 int32_t *
xcb_input_valuator_state_valuators(const xcb_input_valuator_state_t * R)5175 xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R)
5176 {
5177 return (int32_t *) (R + 1);
5178 }
5179
5180 int
xcb_input_valuator_state_valuators_length(const xcb_input_valuator_state_t * R)5181 xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R)
5182 {
5183 return R->num_valuators;
5184 }
5185
5186 xcb_generic_iterator_t
xcb_input_valuator_state_valuators_end(const xcb_input_valuator_state_t * R)5187 xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R)
5188 {
5189 xcb_generic_iterator_t i;
5190 i.data = ((int32_t *) (R + 1)) + (R->num_valuators);
5191 i.rem = 0;
5192 i.index = (char *) i.data - (char *) R;
5193 return i;
5194 }
5195
5196 void
xcb_input_valuator_state_next(xcb_input_valuator_state_iterator_t * i)5197 xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i)
5198 {
5199 xcb_input_valuator_state_t *R = i->data;
5200 xcb_generic_iterator_t child;
5201 child.data = (xcb_input_valuator_state_t *)(((char *)R) + xcb_input_valuator_state_sizeof(R));
5202 i->index = (char *) child.data - (char *) i->data;
5203 --i->rem;
5204 i->data = (xcb_input_valuator_state_t *) child.data;
5205 }
5206
5207 xcb_generic_iterator_t
xcb_input_valuator_state_end(xcb_input_valuator_state_iterator_t i)5208 xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i)
5209 {
5210 xcb_generic_iterator_t ret;
5211 while(i.rem > 0)
5212 xcb_input_valuator_state_next(&i);
5213 ret.data = i.data;
5214 ret.rem = i.rem;
5215 ret.index = i.index;
5216 return ret;
5217 }
5218
5219 int32_t *
xcb_input_input_state_data_valuator_valuators(const xcb_input_input_state_data_t * S)5220 xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S)
5221 {
5222 return S->valuator.valuators;
5223 }
5224
5225 int
xcb_input_input_state_data_valuator_valuators_length(const xcb_input_input_state_t * R,const xcb_input_input_state_data_t * S)5226 xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R,
5227 const xcb_input_input_state_data_t *S)
5228 {
5229 return S->valuator.num_valuators;
5230 }
5231
5232 xcb_generic_iterator_t
xcb_input_input_state_data_valuator_valuators_end(const xcb_input_input_state_t * R,const xcb_input_input_state_data_t * S)5233 xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R,
5234 const xcb_input_input_state_data_t *S)
5235 {
5236 xcb_generic_iterator_t i;
5237 i.data = S->valuator.valuators + S->valuator.num_valuators;
5238 i.rem = 0;
5239 i.index = (char *) i.data - (char *) S;
5240 return i;
5241 }
5242
5243 int
xcb_input_input_state_data_serialize(void ** _buffer,uint8_t class_id,const xcb_input_input_state_data_t * _aux)5244 xcb_input_input_state_data_serialize (void **_buffer,
5245 uint8_t class_id,
5246 const xcb_input_input_state_data_t *_aux)
5247 {
5248 char *xcb_out = *_buffer;
5249 unsigned int xcb_buffer_len = 0;
5250 unsigned int xcb_align_to = 0;
5251 unsigned int xcb_padding_offset = 2;
5252
5253 unsigned int xcb_pad = 0;
5254 char xcb_pad0[3] = {0, 0, 0};
5255 struct iovec xcb_parts[11];
5256 unsigned int xcb_parts_idx = 0;
5257 unsigned int xcb_block_len = 0;
5258 unsigned int i;
5259 char *xcb_tmp;
5260
5261 if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
5262 /* xcb_input_input_state_data_t.key.num_keys */
5263 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
5264 xcb_block_len += sizeof(uint8_t);
5265 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5266 xcb_parts_idx++;
5267 xcb_align_to = ALIGNOF(uint8_t);
5268 /* xcb_input_input_state_data_t.key.pad0 */
5269 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
5270 xcb_block_len += sizeof(uint8_t);
5271 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5272 xcb_parts_idx++;
5273 xcb_align_to = ALIGNOF(uint8_t);
5274 /* xcb_input_input_state_data_t.key.keys */
5275 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys;
5276 xcb_block_len += 32;
5277 xcb_parts[xcb_parts_idx].iov_len = 32;
5278 xcb_parts_idx++;
5279 xcb_align_to = ALIGNOF(uint8_t);
5280 }
5281 if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
5282 /* xcb_input_input_state_data_t.button.num_buttons */
5283 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
5284 xcb_block_len += sizeof(uint8_t);
5285 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5286 xcb_parts_idx++;
5287 xcb_align_to = ALIGNOF(uint8_t);
5288 /* xcb_input_input_state_data_t.button.pad1 */
5289 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
5290 xcb_block_len += sizeof(uint8_t);
5291 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5292 xcb_parts_idx++;
5293 xcb_align_to = ALIGNOF(uint8_t);
5294 /* xcb_input_input_state_data_t.button.buttons */
5295 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.buttons;
5296 xcb_block_len += 32;
5297 xcb_parts[xcb_parts_idx].iov_len = 32;
5298 xcb_parts_idx++;
5299 xcb_align_to = ALIGNOF(uint8_t);
5300 }
5301 if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
5302 /* xcb_input_input_state_data_t.valuator.num_valuators */
5303 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.num_valuators;
5304 xcb_block_len += sizeof(uint8_t);
5305 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5306 xcb_parts_idx++;
5307 xcb_align_to = ALIGNOF(uint8_t);
5308 /* xcb_input_input_state_data_t.valuator.mode */
5309 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
5310 xcb_block_len += sizeof(uint8_t);
5311 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
5312 xcb_parts_idx++;
5313 xcb_align_to = ALIGNOF(uint8_t);
5314 /* insert padding */
5315 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
5316 xcb_buffer_len += xcb_block_len + xcb_pad;
5317 if (0 != xcb_pad) {
5318 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
5319 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
5320 xcb_parts_idx++;
5321 xcb_pad = 0;
5322 }
5323 xcb_block_len = 0;
5324 xcb_padding_offset = 0;
5325 /* valuators */
5326 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.valuators;
5327 xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t);
5328 xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.num_valuators * sizeof(int32_t);
5329 xcb_parts_idx++;
5330 xcb_align_to = ALIGNOF(int32_t);
5331 }
5332 /* insert padding */
5333 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
5334 xcb_buffer_len += xcb_block_len + xcb_pad;
5335 if (0 != xcb_pad) {
5336 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
5337 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
5338 xcb_parts_idx++;
5339 xcb_pad = 0;
5340 }
5341 xcb_block_len = 0;
5342 xcb_padding_offset = 0;
5343
5344 if (NULL == xcb_out) {
5345 /* allocate memory */
5346 xcb_out = malloc(xcb_buffer_len);
5347 *_buffer = xcb_out;
5348 }
5349
5350 xcb_tmp = xcb_out;
5351 for(i=0; i<xcb_parts_idx; i++) {
5352 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
5353 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
5354 if (0 != xcb_parts[i].iov_len)
5355 xcb_tmp += xcb_parts[i].iov_len;
5356 }
5357
5358 return xcb_buffer_len;
5359 }
5360
5361 int
xcb_input_input_state_data_unpack(const void * _buffer,uint8_t class_id,xcb_input_input_state_data_t * _aux)5362 xcb_input_input_state_data_unpack (const void *_buffer,
5363 uint8_t class_id,
5364 xcb_input_input_state_data_t *_aux)
5365 {
5366 char *xcb_tmp = (char *)_buffer;
5367 unsigned int xcb_buffer_len = 0;
5368 unsigned int xcb_block_len = 0;
5369 unsigned int xcb_pad = 0;
5370 unsigned int xcb_align_to = 0;
5371 unsigned int xcb_padding_offset = 2;
5372
5373
5374 if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
5375 /* xcb_input_input_state_data_t.key.num_keys */
5376 _aux->key.num_keys = *(uint8_t *)xcb_tmp;
5377 xcb_block_len += sizeof(uint8_t);
5378 xcb_tmp += sizeof(uint8_t);
5379 xcb_align_to = ALIGNOF(uint8_t);
5380 /* xcb_input_input_state_data_t.key.pad0 */
5381 _aux->key.pad0 = *(uint8_t *)xcb_tmp;
5382 xcb_block_len += sizeof(uint8_t);
5383 xcb_tmp += sizeof(uint8_t);
5384 xcb_align_to = ALIGNOF(uint8_t);
5385 /* xcb_input_input_state_data_t.key.keys */
5386 memcpy(_aux->key.keys, xcb_tmp, sizeof(uint8_t) * 32);
5387 xcb_block_len += sizeof(uint8_t) * 32;
5388 xcb_tmp += sizeof(uint8_t) * 32;
5389 xcb_align_to = ALIGNOF(uint8_t);
5390 }
5391 if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
5392 /* xcb_input_input_state_data_t.button.num_buttons */
5393 _aux->button.num_buttons = *(uint8_t *)xcb_tmp;
5394 xcb_block_len += sizeof(uint8_t);
5395 xcb_tmp += sizeof(uint8_t);
5396 xcb_align_to = ALIGNOF(uint8_t);
5397 /* xcb_input_input_state_data_t.button.pad1 */
5398 _aux->button.pad1 = *(uint8_t *)xcb_tmp;
5399 xcb_block_len += sizeof(uint8_t);
5400 xcb_tmp += sizeof(uint8_t);
5401 xcb_align_to = ALIGNOF(uint8_t);
5402 /* xcb_input_input_state_data_t.button.buttons */
5403 memcpy(_aux->button.buttons, xcb_tmp, sizeof(uint8_t) * 32);
5404 xcb_block_len += sizeof(uint8_t) * 32;
5405 xcb_tmp += sizeof(uint8_t) * 32;
5406 xcb_align_to = ALIGNOF(uint8_t);
5407 }
5408 if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
5409 /* xcb_input_input_state_data_t.valuator.num_valuators */
5410 _aux->valuator.num_valuators = *(uint8_t *)xcb_tmp;
5411 xcb_block_len += sizeof(uint8_t);
5412 xcb_tmp += sizeof(uint8_t);
5413 xcb_align_to = ALIGNOF(uint8_t);
5414 /* xcb_input_input_state_data_t.valuator.mode */
5415 _aux->valuator.mode = *(uint8_t *)xcb_tmp;
5416 xcb_block_len += sizeof(uint8_t);
5417 xcb_tmp += sizeof(uint8_t);
5418 xcb_align_to = ALIGNOF(uint8_t);
5419 /* insert padding */
5420 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
5421 xcb_buffer_len += xcb_block_len + xcb_pad;
5422 if (0 != xcb_pad) {
5423 xcb_tmp += xcb_pad;
5424 xcb_pad = 0;
5425 }
5426 xcb_block_len = 0;
5427 xcb_padding_offset = 0;
5428 /* valuators */
5429 _aux->valuator.valuators = (int32_t *)xcb_tmp;
5430 xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t);
5431 xcb_tmp += xcb_block_len;
5432 xcb_align_to = ALIGNOF(int32_t);
5433 }
5434 /* insert padding */
5435 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
5436 xcb_buffer_len += xcb_block_len + xcb_pad;
5437 if (0 != xcb_pad) {
5438 xcb_tmp += xcb_pad;
5439 xcb_pad = 0;
5440 }
5441 xcb_block_len = 0;
5442 xcb_padding_offset = 0;
5443
5444 return xcb_buffer_len;
5445 }
5446
5447 int
xcb_input_input_state_data_sizeof(const void * _buffer,uint8_t class_id)5448 xcb_input_input_state_data_sizeof (const void *_buffer,
5449 uint8_t class_id)
5450 {
5451 xcb_input_input_state_data_t _aux;
5452 return xcb_input_input_state_data_unpack(_buffer, class_id, &_aux);
5453 }
5454
5455 int
xcb_input_input_state_sizeof(const void * _buffer)5456 xcb_input_input_state_sizeof (const void *_buffer)
5457 {
5458 char *xcb_tmp = (char *)_buffer;
5459 const xcb_input_input_state_t *_aux = (xcb_input_input_state_t *)_buffer;
5460 unsigned int xcb_buffer_len = 0;
5461 unsigned int xcb_block_len = 0;
5462 unsigned int xcb_pad = 0;
5463 unsigned int xcb_align_to = 0;
5464
5465
5466 xcb_block_len += sizeof(xcb_input_input_state_t);
5467 xcb_tmp += xcb_block_len;
5468 xcb_buffer_len += xcb_block_len;
5469 xcb_block_len = 0;
5470 /* data */
5471 xcb_block_len += xcb_input_input_state_data_sizeof(xcb_tmp, _aux->class_id);
5472 xcb_tmp += xcb_block_len;
5473 xcb_align_to = ALIGNOF(char);
5474 /* insert padding */
5475 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5476 xcb_buffer_len += xcb_block_len + xcb_pad;
5477 if (0 != xcb_pad) {
5478 xcb_tmp += xcb_pad;
5479 xcb_pad = 0;
5480 }
5481 xcb_block_len = 0;
5482
5483 return xcb_buffer_len;
5484 }
5485
5486 void *
xcb_input_input_state_data(const xcb_input_input_state_t * R)5487 xcb_input_input_state_data (const xcb_input_input_state_t *R)
5488 {
5489 return (void *) (R + 1);
5490 }
5491
5492 void
xcb_input_input_state_next(xcb_input_input_state_iterator_t * i)5493 xcb_input_input_state_next (xcb_input_input_state_iterator_t *i)
5494 {
5495 xcb_input_input_state_t *R = i->data;
5496 xcb_generic_iterator_t child;
5497 child.data = (xcb_input_input_state_t *)(((char *)R) + xcb_input_input_state_sizeof(R));
5498 i->index = (char *) child.data - (char *) i->data;
5499 --i->rem;
5500 i->data = (xcb_input_input_state_t *) child.data;
5501 }
5502
5503 xcb_generic_iterator_t
xcb_input_input_state_end(xcb_input_input_state_iterator_t i)5504 xcb_input_input_state_end (xcb_input_input_state_iterator_t i)
5505 {
5506 xcb_generic_iterator_t ret;
5507 while(i.rem > 0)
5508 xcb_input_input_state_next(&i);
5509 ret.data = i.data;
5510 ret.rem = i.rem;
5511 ret.index = i.index;
5512 return ret;
5513 }
5514
5515 int
xcb_input_query_device_state_sizeof(const void * _buffer)5516 xcb_input_query_device_state_sizeof (const void *_buffer)
5517 {
5518 char *xcb_tmp = (char *)_buffer;
5519 const xcb_input_query_device_state_reply_t *_aux = (xcb_input_query_device_state_reply_t *)_buffer;
5520 unsigned int xcb_buffer_len = 0;
5521 unsigned int xcb_block_len = 0;
5522 unsigned int xcb_pad = 0;
5523 unsigned int xcb_align_to = 0;
5524
5525 unsigned int i;
5526 unsigned int xcb_tmp_len;
5527
5528 xcb_block_len += sizeof(xcb_input_query_device_state_reply_t);
5529 xcb_tmp += xcb_block_len;
5530 xcb_buffer_len += xcb_block_len;
5531 xcb_block_len = 0;
5532 /* classes */
5533 for(i=0; i<_aux->num_classes; i++) {
5534 xcb_tmp_len = xcb_input_input_state_sizeof(xcb_tmp);
5535 xcb_block_len += xcb_tmp_len;
5536 xcb_tmp += xcb_tmp_len;
5537 }
5538 xcb_align_to = ALIGNOF(xcb_input_input_state_t);
5539 /* insert padding */
5540 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5541 xcb_buffer_len += xcb_block_len + xcb_pad;
5542 if (0 != xcb_pad) {
5543 xcb_tmp += xcb_pad;
5544 xcb_pad = 0;
5545 }
5546 xcb_block_len = 0;
5547
5548 return xcb_buffer_len;
5549 }
5550
5551 xcb_input_query_device_state_cookie_t
xcb_input_query_device_state(xcb_connection_t * c,uint8_t device_id)5552 xcb_input_query_device_state (xcb_connection_t *c,
5553 uint8_t device_id)
5554 {
5555 static const xcb_protocol_request_t xcb_req = {
5556 .count = 2,
5557 .ext = &xcb_input_id,
5558 .opcode = XCB_INPUT_QUERY_DEVICE_STATE,
5559 .isvoid = 0
5560 };
5561
5562 struct iovec xcb_parts[4];
5563 xcb_input_query_device_state_cookie_t xcb_ret;
5564 xcb_input_query_device_state_request_t xcb_out;
5565
5566 xcb_out.device_id = device_id;
5567 memset(xcb_out.pad0, 0, 3);
5568
5569 xcb_parts[2].iov_base = (char *) &xcb_out;
5570 xcb_parts[2].iov_len = sizeof(xcb_out);
5571 xcb_parts[3].iov_base = 0;
5572 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5573
5574 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5575 return xcb_ret;
5576 }
5577
5578 xcb_input_query_device_state_cookie_t
xcb_input_query_device_state_unchecked(xcb_connection_t * c,uint8_t device_id)5579 xcb_input_query_device_state_unchecked (xcb_connection_t *c,
5580 uint8_t device_id)
5581 {
5582 static const xcb_protocol_request_t xcb_req = {
5583 .count = 2,
5584 .ext = &xcb_input_id,
5585 .opcode = XCB_INPUT_QUERY_DEVICE_STATE,
5586 .isvoid = 0
5587 };
5588
5589 struct iovec xcb_parts[4];
5590 xcb_input_query_device_state_cookie_t xcb_ret;
5591 xcb_input_query_device_state_request_t xcb_out;
5592
5593 xcb_out.device_id = device_id;
5594 memset(xcb_out.pad0, 0, 3);
5595
5596 xcb_parts[2].iov_base = (char *) &xcb_out;
5597 xcb_parts[2].iov_len = sizeof(xcb_out);
5598 xcb_parts[3].iov_base = 0;
5599 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5600
5601 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5602 return xcb_ret;
5603 }
5604
5605 int
xcb_input_query_device_state_classes_length(const xcb_input_query_device_state_reply_t * R)5606 xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R)
5607 {
5608 return R->num_classes;
5609 }
5610
5611 xcb_input_input_state_iterator_t
xcb_input_query_device_state_classes_iterator(const xcb_input_query_device_state_reply_t * R)5612 xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R)
5613 {
5614 xcb_input_input_state_iterator_t i;
5615 i.data = (xcb_input_input_state_t *) (R + 1);
5616 i.rem = R->num_classes;
5617 i.index = (char *) i.data - (char *) R;
5618 return i;
5619 }
5620
5621 xcb_input_query_device_state_reply_t *
xcb_input_query_device_state_reply(xcb_connection_t * c,xcb_input_query_device_state_cookie_t cookie,xcb_generic_error_t ** e)5622 xcb_input_query_device_state_reply (xcb_connection_t *c,
5623 xcb_input_query_device_state_cookie_t cookie /**< */,
5624 xcb_generic_error_t **e)
5625 {
5626 return (xcb_input_query_device_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5627 }
5628
5629 xcb_void_cookie_t
xcb_input_device_bell_checked(xcb_connection_t * c,uint8_t device_id,uint8_t feedback_id,uint8_t feedback_class,int8_t percent)5630 xcb_input_device_bell_checked (xcb_connection_t *c,
5631 uint8_t device_id,
5632 uint8_t feedback_id,
5633 uint8_t feedback_class,
5634 int8_t percent)
5635 {
5636 static const xcb_protocol_request_t xcb_req = {
5637 .count = 2,
5638 .ext = &xcb_input_id,
5639 .opcode = XCB_INPUT_DEVICE_BELL,
5640 .isvoid = 1
5641 };
5642
5643 struct iovec xcb_parts[4];
5644 xcb_void_cookie_t xcb_ret;
5645 xcb_input_device_bell_request_t xcb_out;
5646
5647 xcb_out.device_id = device_id;
5648 xcb_out.feedback_id = feedback_id;
5649 xcb_out.feedback_class = feedback_class;
5650 xcb_out.percent = percent;
5651
5652 xcb_parts[2].iov_base = (char *) &xcb_out;
5653 xcb_parts[2].iov_len = sizeof(xcb_out);
5654 xcb_parts[3].iov_base = 0;
5655 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5656
5657 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5658 return xcb_ret;
5659 }
5660
5661 xcb_void_cookie_t
xcb_input_device_bell(xcb_connection_t * c,uint8_t device_id,uint8_t feedback_id,uint8_t feedback_class,int8_t percent)5662 xcb_input_device_bell (xcb_connection_t *c,
5663 uint8_t device_id,
5664 uint8_t feedback_id,
5665 uint8_t feedback_class,
5666 int8_t percent)
5667 {
5668 static const xcb_protocol_request_t xcb_req = {
5669 .count = 2,
5670 .ext = &xcb_input_id,
5671 .opcode = XCB_INPUT_DEVICE_BELL,
5672 .isvoid = 1
5673 };
5674
5675 struct iovec xcb_parts[4];
5676 xcb_void_cookie_t xcb_ret;
5677 xcb_input_device_bell_request_t xcb_out;
5678
5679 xcb_out.device_id = device_id;
5680 xcb_out.feedback_id = feedback_id;
5681 xcb_out.feedback_class = feedback_class;
5682 xcb_out.percent = percent;
5683
5684 xcb_parts[2].iov_base = (char *) &xcb_out;
5685 xcb_parts[2].iov_len = sizeof(xcb_out);
5686 xcb_parts[3].iov_base = 0;
5687 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5688
5689 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5690 return xcb_ret;
5691 }
5692
5693 int
xcb_input_set_device_valuators_sizeof(const void * _buffer)5694 xcb_input_set_device_valuators_sizeof (const void *_buffer)
5695 {
5696 char *xcb_tmp = (char *)_buffer;
5697 const xcb_input_set_device_valuators_request_t *_aux = (xcb_input_set_device_valuators_request_t *)_buffer;
5698 unsigned int xcb_buffer_len = 0;
5699 unsigned int xcb_block_len = 0;
5700 unsigned int xcb_pad = 0;
5701 unsigned int xcb_align_to = 0;
5702
5703
5704 xcb_block_len += sizeof(xcb_input_set_device_valuators_request_t);
5705 xcb_tmp += xcb_block_len;
5706 xcb_buffer_len += xcb_block_len;
5707 xcb_block_len = 0;
5708 /* valuators */
5709 xcb_block_len += _aux->num_valuators * sizeof(int32_t);
5710 xcb_tmp += xcb_block_len;
5711 xcb_align_to = ALIGNOF(int32_t);
5712 /* insert padding */
5713 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5714 xcb_buffer_len += xcb_block_len + xcb_pad;
5715 if (0 != xcb_pad) {
5716 xcb_tmp += xcb_pad;
5717 xcb_pad = 0;
5718 }
5719 xcb_block_len = 0;
5720
5721 return xcb_buffer_len;
5722 }
5723
5724 xcb_input_set_device_valuators_cookie_t
xcb_input_set_device_valuators(xcb_connection_t * c,uint8_t device_id,uint8_t first_valuator,uint8_t num_valuators,const int32_t * valuators)5725 xcb_input_set_device_valuators (xcb_connection_t *c,
5726 uint8_t device_id,
5727 uint8_t first_valuator,
5728 uint8_t num_valuators,
5729 const int32_t *valuators)
5730 {
5731 static const xcb_protocol_request_t xcb_req = {
5732 .count = 4,
5733 .ext = &xcb_input_id,
5734 .opcode = XCB_INPUT_SET_DEVICE_VALUATORS,
5735 .isvoid = 0
5736 };
5737
5738 struct iovec xcb_parts[6];
5739 xcb_input_set_device_valuators_cookie_t xcb_ret;
5740 xcb_input_set_device_valuators_request_t xcb_out;
5741
5742 xcb_out.device_id = device_id;
5743 xcb_out.first_valuator = first_valuator;
5744 xcb_out.num_valuators = num_valuators;
5745 xcb_out.pad0 = 0;
5746
5747 xcb_parts[2].iov_base = (char *) &xcb_out;
5748 xcb_parts[2].iov_len = sizeof(xcb_out);
5749 xcb_parts[3].iov_base = 0;
5750 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5751 /* int32_t valuators */
5752 xcb_parts[4].iov_base = (char *) valuators;
5753 xcb_parts[4].iov_len = num_valuators * sizeof(int32_t);
5754 xcb_parts[5].iov_base = 0;
5755 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5756
5757 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5758 return xcb_ret;
5759 }
5760
5761 xcb_input_set_device_valuators_cookie_t
xcb_input_set_device_valuators_unchecked(xcb_connection_t * c,uint8_t device_id,uint8_t first_valuator,uint8_t num_valuators,const int32_t * valuators)5762 xcb_input_set_device_valuators_unchecked (xcb_connection_t *c,
5763 uint8_t device_id,
5764 uint8_t first_valuator,
5765 uint8_t num_valuators,
5766 const int32_t *valuators)
5767 {
5768 static const xcb_protocol_request_t xcb_req = {
5769 .count = 4,
5770 .ext = &xcb_input_id,
5771 .opcode = XCB_INPUT_SET_DEVICE_VALUATORS,
5772 .isvoid = 0
5773 };
5774
5775 struct iovec xcb_parts[6];
5776 xcb_input_set_device_valuators_cookie_t xcb_ret;
5777 xcb_input_set_device_valuators_request_t xcb_out;
5778
5779 xcb_out.device_id = device_id;
5780 xcb_out.first_valuator = first_valuator;
5781 xcb_out.num_valuators = num_valuators;
5782 xcb_out.pad0 = 0;
5783
5784 xcb_parts[2].iov_base = (char *) &xcb_out;
5785 xcb_parts[2].iov_len = sizeof(xcb_out);
5786 xcb_parts[3].iov_base = 0;
5787 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5788 /* int32_t valuators */
5789 xcb_parts[4].iov_base = (char *) valuators;
5790 xcb_parts[4].iov_len = num_valuators * sizeof(int32_t);
5791 xcb_parts[5].iov_base = 0;
5792 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5793
5794 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5795 return xcb_ret;
5796 }
5797
5798 xcb_input_set_device_valuators_reply_t *
xcb_input_set_device_valuators_reply(xcb_connection_t * c,xcb_input_set_device_valuators_cookie_t cookie,xcb_generic_error_t ** e)5799 xcb_input_set_device_valuators_reply (xcb_connection_t *c,
5800 xcb_input_set_device_valuators_cookie_t cookie /**< */,
5801 xcb_generic_error_t **e)
5802 {
5803 return (xcb_input_set_device_valuators_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5804 }
5805
5806 int
xcb_input_device_resolution_state_sizeof(const void * _buffer)5807 xcb_input_device_resolution_state_sizeof (const void *_buffer)
5808 {
5809 char *xcb_tmp = (char *)_buffer;
5810 const xcb_input_device_resolution_state_t *_aux = (xcb_input_device_resolution_state_t *)_buffer;
5811 unsigned int xcb_buffer_len = 0;
5812 unsigned int xcb_block_len = 0;
5813 unsigned int xcb_pad = 0;
5814 unsigned int xcb_align_to = 0;
5815
5816
5817 xcb_block_len += sizeof(xcb_input_device_resolution_state_t);
5818 xcb_tmp += xcb_block_len;
5819 xcb_buffer_len += xcb_block_len;
5820 xcb_block_len = 0;
5821 /* resolution_values */
5822 xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
5823 xcb_tmp += xcb_block_len;
5824 xcb_align_to = ALIGNOF(uint32_t);
5825 /* insert padding */
5826 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5827 xcb_buffer_len += xcb_block_len + xcb_pad;
5828 if (0 != xcb_pad) {
5829 xcb_tmp += xcb_pad;
5830 xcb_pad = 0;
5831 }
5832 xcb_block_len = 0;
5833 /* resolution_min */
5834 xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
5835 xcb_tmp += xcb_block_len;
5836 xcb_align_to = ALIGNOF(uint32_t);
5837 /* insert padding */
5838 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5839 xcb_buffer_len += xcb_block_len + xcb_pad;
5840 if (0 != xcb_pad) {
5841 xcb_tmp += xcb_pad;
5842 xcb_pad = 0;
5843 }
5844 xcb_block_len = 0;
5845 /* resolution_max */
5846 xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
5847 xcb_tmp += xcb_block_len;
5848 xcb_align_to = ALIGNOF(uint32_t);
5849 /* insert padding */
5850 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5851 xcb_buffer_len += xcb_block_len + xcb_pad;
5852 if (0 != xcb_pad) {
5853 xcb_tmp += xcb_pad;
5854 xcb_pad = 0;
5855 }
5856 xcb_block_len = 0;
5857
5858 return xcb_buffer_len;
5859 }
5860
5861 uint32_t *
xcb_input_device_resolution_state_resolution_values(const xcb_input_device_resolution_state_t * R)5862 xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R)
5863 {
5864 return (uint32_t *) (R + 1);
5865 }
5866
5867 int
xcb_input_device_resolution_state_resolution_values_length(const xcb_input_device_resolution_state_t * R)5868 xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R)
5869 {
5870 return R->num_valuators;
5871 }
5872
5873 xcb_generic_iterator_t
xcb_input_device_resolution_state_resolution_values_end(const xcb_input_device_resolution_state_t * R)5874 xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R)
5875 {
5876 xcb_generic_iterator_t i;
5877 i.data = ((uint32_t *) (R + 1)) + (R->num_valuators);
5878 i.rem = 0;
5879 i.index = (char *) i.data - (char *) R;
5880 return i;
5881 }
5882
5883 uint32_t *
xcb_input_device_resolution_state_resolution_min(const xcb_input_device_resolution_state_t * R)5884 xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R)
5885 {
5886 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R);
5887 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
5888 }
5889
5890 int
xcb_input_device_resolution_state_resolution_min_length(const xcb_input_device_resolution_state_t * R)5891 xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R)
5892 {
5893 return R->num_valuators;
5894 }
5895
5896 xcb_generic_iterator_t
xcb_input_device_resolution_state_resolution_min_end(const xcb_input_device_resolution_state_t * R)5897 xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R)
5898 {
5899 xcb_generic_iterator_t i;
5900 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R);
5901 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators);
5902 i.rem = 0;
5903 i.index = (char *) i.data - (char *) R;
5904 return i;
5905 }
5906
5907 uint32_t *
xcb_input_device_resolution_state_resolution_max(const xcb_input_device_resolution_state_t * R)5908 xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R)
5909 {
5910 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R);
5911 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
5912 }
5913
5914 int
xcb_input_device_resolution_state_resolution_max_length(const xcb_input_device_resolution_state_t * R)5915 xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R)
5916 {
5917 return R->num_valuators;
5918 }
5919
5920 xcb_generic_iterator_t
xcb_input_device_resolution_state_resolution_max_end(const xcb_input_device_resolution_state_t * R)5921 xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R)
5922 {
5923 xcb_generic_iterator_t i;
5924 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R);
5925 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators);
5926 i.rem = 0;
5927 i.index = (char *) i.data - (char *) R;
5928 return i;
5929 }
5930
5931 void
xcb_input_device_resolution_state_next(xcb_input_device_resolution_state_iterator_t * i)5932 xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i)
5933 {
5934 xcb_input_device_resolution_state_t *R = i->data;
5935 xcb_generic_iterator_t child;
5936 child.data = (xcb_input_device_resolution_state_t *)(((char *)R) + xcb_input_device_resolution_state_sizeof(R));
5937 i->index = (char *) child.data - (char *) i->data;
5938 --i->rem;
5939 i->data = (xcb_input_device_resolution_state_t *) child.data;
5940 }
5941
5942 xcb_generic_iterator_t
xcb_input_device_resolution_state_end(xcb_input_device_resolution_state_iterator_t i)5943 xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i)
5944 {
5945 xcb_generic_iterator_t ret;
5946 while(i.rem > 0)
5947 xcb_input_device_resolution_state_next(&i);
5948 ret.data = i.data;
5949 ret.rem = i.rem;
5950 ret.index = i.index;
5951 return ret;
5952 }
5953
5954 void
xcb_input_device_abs_calib_state_next(xcb_input_device_abs_calib_state_iterator_t * i)5955 xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i)
5956 {
5957 --i->rem;
5958 ++i->data;
5959 i->index += sizeof(xcb_input_device_abs_calib_state_t);
5960 }
5961
5962 xcb_generic_iterator_t
xcb_input_device_abs_calib_state_end(xcb_input_device_abs_calib_state_iterator_t i)5963 xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i)
5964 {
5965 xcb_generic_iterator_t ret;
5966 ret.data = i.data + i.rem;
5967 ret.index = i.index + ((char *) ret.data - (char *) i.data);
5968 ret.rem = 0;
5969 return ret;
5970 }
5971
5972 void
xcb_input_device_abs_area_state_next(xcb_input_device_abs_area_state_iterator_t * i)5973 xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i)
5974 {
5975 --i->rem;
5976 ++i->data;
5977 i->index += sizeof(xcb_input_device_abs_area_state_t);
5978 }
5979
5980 xcb_generic_iterator_t
xcb_input_device_abs_area_state_end(xcb_input_device_abs_area_state_iterator_t i)5981 xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i)
5982 {
5983 xcb_generic_iterator_t ret;
5984 ret.data = i.data + i.rem;
5985 ret.index = i.index + ((char *) ret.data - (char *) i.data);
5986 ret.rem = 0;
5987 return ret;
5988 }
5989
5990 void
xcb_input_device_core_state_next(xcb_input_device_core_state_iterator_t * i)5991 xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i)
5992 {
5993 --i->rem;
5994 ++i->data;
5995 i->index += sizeof(xcb_input_device_core_state_t);
5996 }
5997
5998 xcb_generic_iterator_t
xcb_input_device_core_state_end(xcb_input_device_core_state_iterator_t i)5999 xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i)
6000 {
6001 xcb_generic_iterator_t ret;
6002 ret.data = i.data + i.rem;
6003 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6004 ret.rem = 0;
6005 return ret;
6006 }
6007
6008 void
xcb_input_device_enable_state_next(xcb_input_device_enable_state_iterator_t * i)6009 xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i)
6010 {
6011 --i->rem;
6012 ++i->data;
6013 i->index += sizeof(xcb_input_device_enable_state_t);
6014 }
6015
6016 xcb_generic_iterator_t
xcb_input_device_enable_state_end(xcb_input_device_enable_state_iterator_t i)6017 xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i)
6018 {
6019 xcb_generic_iterator_t ret;
6020 ret.data = i.data + i.rem;
6021 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6022 ret.rem = 0;
6023 return ret;
6024 }
6025
6026 uint32_t *
xcb_input_device_state_data_resolution_resolution_values(const xcb_input_device_state_data_t * S)6027 xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S)
6028 {
6029 return S->resolution.resolution_values;
6030 }
6031
6032 int
xcb_input_device_state_data_resolution_resolution_values_length(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6033 xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R,
6034 const xcb_input_device_state_data_t *S)
6035 {
6036 return S->resolution.num_valuators;
6037 }
6038
6039 xcb_generic_iterator_t
xcb_input_device_state_data_resolution_resolution_values_end(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6040 xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R,
6041 const xcb_input_device_state_data_t *S)
6042 {
6043 xcb_generic_iterator_t i;
6044 i.data = S->resolution.resolution_values + S->resolution.num_valuators;
6045 i.rem = 0;
6046 i.index = (char *) i.data - (char *) S;
6047 return i;
6048 }
6049
6050 uint32_t *
xcb_input_device_state_data_resolution_resolution_min(const xcb_input_device_state_data_t * S)6051 xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S)
6052 {
6053 return S->resolution.resolution_min;
6054 }
6055
6056 int
xcb_input_device_state_data_resolution_resolution_min_length(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6057 xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R,
6058 const xcb_input_device_state_data_t *S)
6059 {
6060 return S->resolution.num_valuators;
6061 }
6062
6063 xcb_generic_iterator_t
xcb_input_device_state_data_resolution_resolution_min_end(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6064 xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R,
6065 const xcb_input_device_state_data_t *S)
6066 {
6067 xcb_generic_iterator_t i;
6068 i.data = S->resolution.resolution_min + S->resolution.num_valuators;
6069 i.rem = 0;
6070 i.index = (char *) i.data - (char *) S;
6071 return i;
6072 }
6073
6074 uint32_t *
xcb_input_device_state_data_resolution_resolution_max(const xcb_input_device_state_data_t * S)6075 xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S)
6076 {
6077 return S->resolution.resolution_max;
6078 }
6079
6080 int
xcb_input_device_state_data_resolution_resolution_max_length(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6081 xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R,
6082 const xcb_input_device_state_data_t *S)
6083 {
6084 return S->resolution.num_valuators;
6085 }
6086
6087 xcb_generic_iterator_t
xcb_input_device_state_data_resolution_resolution_max_end(const xcb_input_device_state_t * R,const xcb_input_device_state_data_t * S)6088 xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R,
6089 const xcb_input_device_state_data_t *S)
6090 {
6091 xcb_generic_iterator_t i;
6092 i.data = S->resolution.resolution_max + S->resolution.num_valuators;
6093 i.rem = 0;
6094 i.index = (char *) i.data - (char *) S;
6095 return i;
6096 }
6097
6098 int
xcb_input_device_state_data_serialize(void ** _buffer,uint16_t control_id,const xcb_input_device_state_data_t * _aux)6099 xcb_input_device_state_data_serialize (void **_buffer,
6100 uint16_t control_id,
6101 const xcb_input_device_state_data_t *_aux)
6102 {
6103 char *xcb_out = *_buffer;
6104 unsigned int xcb_buffer_len = 0;
6105 unsigned int xcb_align_to = 0;
6106 unsigned int xcb_padding_offset = 0;
6107
6108 unsigned int xcb_pad = 0;
6109 char xcb_pad0[3] = {0, 0, 0};
6110 struct iovec xcb_parts[27];
6111 unsigned int xcb_parts_idx = 0;
6112 unsigned int xcb_block_len = 0;
6113 unsigned int i;
6114 char *xcb_tmp;
6115
6116 if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
6117 /* xcb_input_device_state_data_t.resolution.num_valuators */
6118 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators;
6119 xcb_block_len += sizeof(uint32_t);
6120 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6121 xcb_parts_idx++;
6122 xcb_align_to = ALIGNOF(uint32_t);
6123 /* insert padding */
6124 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6125 xcb_buffer_len += xcb_block_len + xcb_pad;
6126 if (0 != xcb_pad) {
6127 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6128 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6129 xcb_parts_idx++;
6130 xcb_pad = 0;
6131 }
6132 xcb_block_len = 0;
6133 xcb_padding_offset = 0;
6134 /* resolution_values */
6135 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values;
6136 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6137 xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
6138 xcb_parts_idx++;
6139 xcb_align_to = ALIGNOF(uint32_t);
6140 /* insert padding */
6141 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6142 xcb_buffer_len += xcb_block_len + xcb_pad;
6143 if (0 != xcb_pad) {
6144 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6145 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6146 xcb_parts_idx++;
6147 xcb_pad = 0;
6148 }
6149 xcb_block_len = 0;
6150 xcb_padding_offset = 0;
6151 /* resolution_min */
6152 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_min;
6153 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6154 xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
6155 xcb_parts_idx++;
6156 xcb_align_to = ALIGNOF(uint32_t);
6157 /* insert padding */
6158 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6159 xcb_buffer_len += xcb_block_len + xcb_pad;
6160 if (0 != xcb_pad) {
6161 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6162 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6163 xcb_parts_idx++;
6164 xcb_pad = 0;
6165 }
6166 xcb_block_len = 0;
6167 xcb_padding_offset = 0;
6168 /* resolution_max */
6169 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_max;
6170 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6171 xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
6172 xcb_parts_idx++;
6173 xcb_align_to = ALIGNOF(uint32_t);
6174 }
6175 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
6176 /* xcb_input_device_state_data_t.abs_calib.min_x */
6177 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x;
6178 xcb_block_len += sizeof(int32_t);
6179 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6180 xcb_parts_idx++;
6181 xcb_align_to = ALIGNOF(int32_t);
6182 /* xcb_input_device_state_data_t.abs_calib.max_x */
6183 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x;
6184 xcb_block_len += sizeof(int32_t);
6185 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6186 xcb_parts_idx++;
6187 xcb_align_to = ALIGNOF(int32_t);
6188 /* xcb_input_device_state_data_t.abs_calib.min_y */
6189 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y;
6190 xcb_block_len += sizeof(int32_t);
6191 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6192 xcb_parts_idx++;
6193 xcb_align_to = ALIGNOF(int32_t);
6194 /* xcb_input_device_state_data_t.abs_calib.max_y */
6195 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y;
6196 xcb_block_len += sizeof(int32_t);
6197 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6198 xcb_parts_idx++;
6199 xcb_align_to = ALIGNOF(int32_t);
6200 /* xcb_input_device_state_data_t.abs_calib.flip_x */
6201 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x;
6202 xcb_block_len += sizeof(uint32_t);
6203 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6204 xcb_parts_idx++;
6205 xcb_align_to = ALIGNOF(uint32_t);
6206 /* xcb_input_device_state_data_t.abs_calib.flip_y */
6207 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y;
6208 xcb_block_len += sizeof(uint32_t);
6209 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6210 xcb_parts_idx++;
6211 xcb_align_to = ALIGNOF(uint32_t);
6212 /* xcb_input_device_state_data_t.abs_calib.rotation */
6213 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation;
6214 xcb_block_len += sizeof(uint32_t);
6215 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6216 xcb_parts_idx++;
6217 xcb_align_to = ALIGNOF(uint32_t);
6218 /* xcb_input_device_state_data_t.abs_calib.button_threshold */
6219 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold;
6220 xcb_block_len += sizeof(uint32_t);
6221 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6222 xcb_parts_idx++;
6223 xcb_align_to = ALIGNOF(uint32_t);
6224 }
6225 if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
6226 /* xcb_input_device_state_data_t.core.status */
6227 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status;
6228 xcb_block_len += sizeof(uint8_t);
6229 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6230 xcb_parts_idx++;
6231 xcb_align_to = ALIGNOF(uint8_t);
6232 /* xcb_input_device_state_data_t.core.iscore */
6233 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.iscore;
6234 xcb_block_len += sizeof(uint8_t);
6235 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6236 xcb_parts_idx++;
6237 xcb_align_to = ALIGNOF(uint8_t);
6238 /* xcb_input_device_state_data_t.core.pad0 */
6239 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6240 xcb_block_len += sizeof(uint8_t)*2;
6241 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
6242 xcb_parts_idx++;
6243 xcb_align_to = ALIGNOF(uint8_t);
6244 }
6245 if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
6246 /* xcb_input_device_state_data_t.enable.enable */
6247 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable;
6248 xcb_block_len += sizeof(uint8_t);
6249 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6250 xcb_parts_idx++;
6251 xcb_align_to = ALIGNOF(uint8_t);
6252 /* xcb_input_device_state_data_t.enable.pad1 */
6253 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6254 xcb_block_len += sizeof(uint8_t)*3;
6255 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
6256 xcb_parts_idx++;
6257 xcb_align_to = ALIGNOF(uint8_t);
6258 }
6259 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
6260 /* xcb_input_device_state_data_t.abs_area.offset_x */
6261 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x;
6262 xcb_block_len += sizeof(uint32_t);
6263 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6264 xcb_parts_idx++;
6265 xcb_align_to = ALIGNOF(uint32_t);
6266 /* xcb_input_device_state_data_t.abs_area.offset_y */
6267 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y;
6268 xcb_block_len += sizeof(uint32_t);
6269 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6270 xcb_parts_idx++;
6271 xcb_align_to = ALIGNOF(uint32_t);
6272 /* xcb_input_device_state_data_t.abs_area.width */
6273 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width;
6274 xcb_block_len += sizeof(uint32_t);
6275 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6276 xcb_parts_idx++;
6277 xcb_align_to = ALIGNOF(uint32_t);
6278 /* xcb_input_device_state_data_t.abs_area.height */
6279 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height;
6280 xcb_block_len += sizeof(uint32_t);
6281 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6282 xcb_parts_idx++;
6283 xcb_align_to = ALIGNOF(uint32_t);
6284 /* xcb_input_device_state_data_t.abs_area.screen */
6285 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen;
6286 xcb_block_len += sizeof(uint32_t);
6287 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6288 xcb_parts_idx++;
6289 xcb_align_to = ALIGNOF(uint32_t);
6290 /* xcb_input_device_state_data_t.abs_area.following */
6291 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following;
6292 xcb_block_len += sizeof(uint32_t);
6293 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6294 xcb_parts_idx++;
6295 xcb_align_to = ALIGNOF(uint32_t);
6296 }
6297 /* insert padding */
6298 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6299 xcb_buffer_len += xcb_block_len + xcb_pad;
6300 if (0 != xcb_pad) {
6301 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6302 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6303 xcb_parts_idx++;
6304 xcb_pad = 0;
6305 }
6306 xcb_block_len = 0;
6307 xcb_padding_offset = 0;
6308
6309 if (NULL == xcb_out) {
6310 /* allocate memory */
6311 xcb_out = malloc(xcb_buffer_len);
6312 *_buffer = xcb_out;
6313 }
6314
6315 xcb_tmp = xcb_out;
6316 for(i=0; i<xcb_parts_idx; i++) {
6317 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
6318 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
6319 if (0 != xcb_parts[i].iov_len)
6320 xcb_tmp += xcb_parts[i].iov_len;
6321 }
6322
6323 return xcb_buffer_len;
6324 }
6325
6326 int
xcb_input_device_state_data_unpack(const void * _buffer,uint16_t control_id,xcb_input_device_state_data_t * _aux)6327 xcb_input_device_state_data_unpack (const void *_buffer,
6328 uint16_t control_id,
6329 xcb_input_device_state_data_t *_aux)
6330 {
6331 char *xcb_tmp = (char *)_buffer;
6332 unsigned int xcb_buffer_len = 0;
6333 unsigned int xcb_block_len = 0;
6334 unsigned int xcb_pad = 0;
6335 unsigned int xcb_align_to = 0;
6336 unsigned int xcb_padding_offset = 0;
6337
6338
6339 if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
6340 /* xcb_input_device_state_data_t.resolution.num_valuators */
6341 _aux->resolution.num_valuators = *(uint32_t *)xcb_tmp;
6342 xcb_block_len += sizeof(uint32_t);
6343 xcb_tmp += sizeof(uint32_t);
6344 xcb_align_to = ALIGNOF(uint32_t);
6345 /* insert padding */
6346 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6347 xcb_buffer_len += xcb_block_len + xcb_pad;
6348 if (0 != xcb_pad) {
6349 xcb_tmp += xcb_pad;
6350 xcb_pad = 0;
6351 }
6352 xcb_block_len = 0;
6353 xcb_padding_offset = 0;
6354 /* resolution_values */
6355 _aux->resolution.resolution_values = (uint32_t *)xcb_tmp;
6356 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6357 xcb_tmp += xcb_block_len;
6358 xcb_align_to = ALIGNOF(uint32_t);
6359 /* insert padding */
6360 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6361 xcb_buffer_len += xcb_block_len + xcb_pad;
6362 if (0 != xcb_pad) {
6363 xcb_tmp += xcb_pad;
6364 xcb_pad = 0;
6365 }
6366 xcb_block_len = 0;
6367 xcb_padding_offset = 0;
6368 /* resolution_min */
6369 _aux->resolution.resolution_min = (uint32_t *)xcb_tmp;
6370 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6371 xcb_tmp += xcb_block_len;
6372 xcb_align_to = ALIGNOF(uint32_t);
6373 /* insert padding */
6374 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6375 xcb_buffer_len += xcb_block_len + xcb_pad;
6376 if (0 != xcb_pad) {
6377 xcb_tmp += xcb_pad;
6378 xcb_pad = 0;
6379 }
6380 xcb_block_len = 0;
6381 xcb_padding_offset = 0;
6382 /* resolution_max */
6383 _aux->resolution.resolution_max = (uint32_t *)xcb_tmp;
6384 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6385 xcb_tmp += xcb_block_len;
6386 xcb_align_to = ALIGNOF(uint32_t);
6387 }
6388 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
6389 /* xcb_input_device_state_data_t.abs_calib.min_x */
6390 _aux->abs_calib.min_x = *(int32_t *)xcb_tmp;
6391 xcb_block_len += sizeof(int32_t);
6392 xcb_tmp += sizeof(int32_t);
6393 xcb_align_to = ALIGNOF(int32_t);
6394 /* xcb_input_device_state_data_t.abs_calib.max_x */
6395 _aux->abs_calib.max_x = *(int32_t *)xcb_tmp;
6396 xcb_block_len += sizeof(int32_t);
6397 xcb_tmp += sizeof(int32_t);
6398 xcb_align_to = ALIGNOF(int32_t);
6399 /* xcb_input_device_state_data_t.abs_calib.min_y */
6400 _aux->abs_calib.min_y = *(int32_t *)xcb_tmp;
6401 xcb_block_len += sizeof(int32_t);
6402 xcb_tmp += sizeof(int32_t);
6403 xcb_align_to = ALIGNOF(int32_t);
6404 /* xcb_input_device_state_data_t.abs_calib.max_y */
6405 _aux->abs_calib.max_y = *(int32_t *)xcb_tmp;
6406 xcb_block_len += sizeof(int32_t);
6407 xcb_tmp += sizeof(int32_t);
6408 xcb_align_to = ALIGNOF(int32_t);
6409 /* xcb_input_device_state_data_t.abs_calib.flip_x */
6410 _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp;
6411 xcb_block_len += sizeof(uint32_t);
6412 xcb_tmp += sizeof(uint32_t);
6413 xcb_align_to = ALIGNOF(uint32_t);
6414 /* xcb_input_device_state_data_t.abs_calib.flip_y */
6415 _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp;
6416 xcb_block_len += sizeof(uint32_t);
6417 xcb_tmp += sizeof(uint32_t);
6418 xcb_align_to = ALIGNOF(uint32_t);
6419 /* xcb_input_device_state_data_t.abs_calib.rotation */
6420 _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp;
6421 xcb_block_len += sizeof(uint32_t);
6422 xcb_tmp += sizeof(uint32_t);
6423 xcb_align_to = ALIGNOF(uint32_t);
6424 /* xcb_input_device_state_data_t.abs_calib.button_threshold */
6425 _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp;
6426 xcb_block_len += sizeof(uint32_t);
6427 xcb_tmp += sizeof(uint32_t);
6428 xcb_align_to = ALIGNOF(uint32_t);
6429 }
6430 if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
6431 /* xcb_input_device_state_data_t.core.status */
6432 _aux->core.status = *(uint8_t *)xcb_tmp;
6433 xcb_block_len += sizeof(uint8_t);
6434 xcb_tmp += sizeof(uint8_t);
6435 xcb_align_to = ALIGNOF(uint8_t);
6436 /* xcb_input_device_state_data_t.core.iscore */
6437 _aux->core.iscore = *(uint8_t *)xcb_tmp;
6438 xcb_block_len += sizeof(uint8_t);
6439 xcb_tmp += sizeof(uint8_t);
6440 xcb_align_to = ALIGNOF(uint8_t);
6441 /* xcb_input_device_state_data_t.core.pad0 */
6442 _aux->core.pad0[0] = *(uint8_t *)xcb_tmp;
6443 _aux->core.pad0[1] = *(uint8_t *)xcb_tmp;
6444 xcb_block_len += sizeof(uint8_t) * 2;
6445 xcb_tmp += sizeof(uint8_t) * 2;
6446 xcb_align_to = ALIGNOF(uint8_t);
6447 }
6448 if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
6449 /* xcb_input_device_state_data_t.enable.enable */
6450 _aux->enable.enable = *(uint8_t *)xcb_tmp;
6451 xcb_block_len += sizeof(uint8_t);
6452 xcb_tmp += sizeof(uint8_t);
6453 xcb_align_to = ALIGNOF(uint8_t);
6454 /* xcb_input_device_state_data_t.enable.pad1 */
6455 _aux->enable.pad1[0] = *(uint8_t *)xcb_tmp;
6456 _aux->enable.pad1[1] = *(uint8_t *)xcb_tmp;
6457 _aux->enable.pad1[2] = *(uint8_t *)xcb_tmp;
6458 xcb_block_len += sizeof(uint8_t) * 3;
6459 xcb_tmp += sizeof(uint8_t) * 3;
6460 xcb_align_to = ALIGNOF(uint8_t);
6461 }
6462 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
6463 /* xcb_input_device_state_data_t.abs_area.offset_x */
6464 _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp;
6465 xcb_block_len += sizeof(uint32_t);
6466 xcb_tmp += sizeof(uint32_t);
6467 xcb_align_to = ALIGNOF(uint32_t);
6468 /* xcb_input_device_state_data_t.abs_area.offset_y */
6469 _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp;
6470 xcb_block_len += sizeof(uint32_t);
6471 xcb_tmp += sizeof(uint32_t);
6472 xcb_align_to = ALIGNOF(uint32_t);
6473 /* xcb_input_device_state_data_t.abs_area.width */
6474 _aux->abs_area.width = *(uint32_t *)xcb_tmp;
6475 xcb_block_len += sizeof(uint32_t);
6476 xcb_tmp += sizeof(uint32_t);
6477 xcb_align_to = ALIGNOF(uint32_t);
6478 /* xcb_input_device_state_data_t.abs_area.height */
6479 _aux->abs_area.height = *(uint32_t *)xcb_tmp;
6480 xcb_block_len += sizeof(uint32_t);
6481 xcb_tmp += sizeof(uint32_t);
6482 xcb_align_to = ALIGNOF(uint32_t);
6483 /* xcb_input_device_state_data_t.abs_area.screen */
6484 _aux->abs_area.screen = *(uint32_t *)xcb_tmp;
6485 xcb_block_len += sizeof(uint32_t);
6486 xcb_tmp += sizeof(uint32_t);
6487 xcb_align_to = ALIGNOF(uint32_t);
6488 /* xcb_input_device_state_data_t.abs_area.following */
6489 _aux->abs_area.following = *(uint32_t *)xcb_tmp;
6490 xcb_block_len += sizeof(uint32_t);
6491 xcb_tmp += sizeof(uint32_t);
6492 xcb_align_to = ALIGNOF(uint32_t);
6493 }
6494 /* insert padding */
6495 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6496 xcb_buffer_len += xcb_block_len + xcb_pad;
6497 if (0 != xcb_pad) {
6498 xcb_tmp += xcb_pad;
6499 xcb_pad = 0;
6500 }
6501 xcb_block_len = 0;
6502 xcb_padding_offset = 0;
6503
6504 return xcb_buffer_len;
6505 }
6506
6507 int
xcb_input_device_state_data_sizeof(const void * _buffer,uint16_t control_id)6508 xcb_input_device_state_data_sizeof (const void *_buffer,
6509 uint16_t control_id)
6510 {
6511 xcb_input_device_state_data_t _aux;
6512 return xcb_input_device_state_data_unpack(_buffer, control_id, &_aux);
6513 }
6514
6515 int
xcb_input_device_state_sizeof(const void * _buffer)6516 xcb_input_device_state_sizeof (const void *_buffer)
6517 {
6518 char *xcb_tmp = (char *)_buffer;
6519 const xcb_input_device_state_t *_aux = (xcb_input_device_state_t *)_buffer;
6520 unsigned int xcb_buffer_len = 0;
6521 unsigned int xcb_block_len = 0;
6522 unsigned int xcb_pad = 0;
6523 unsigned int xcb_align_to = 0;
6524
6525
6526 xcb_block_len += sizeof(xcb_input_device_state_t);
6527 xcb_tmp += xcb_block_len;
6528 xcb_buffer_len += xcb_block_len;
6529 xcb_block_len = 0;
6530 /* data */
6531 xcb_block_len += xcb_input_device_state_data_sizeof(xcb_tmp, _aux->control_id);
6532 xcb_tmp += xcb_block_len;
6533 xcb_align_to = ALIGNOF(char);
6534 /* insert padding */
6535 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6536 xcb_buffer_len += xcb_block_len + xcb_pad;
6537 if (0 != xcb_pad) {
6538 xcb_tmp += xcb_pad;
6539 xcb_pad = 0;
6540 }
6541 xcb_block_len = 0;
6542
6543 return xcb_buffer_len;
6544 }
6545
6546 void *
xcb_input_device_state_data(const xcb_input_device_state_t * R)6547 xcb_input_device_state_data (const xcb_input_device_state_t *R)
6548 {
6549 return (void *) (R + 1);
6550 }
6551
6552 void
xcb_input_device_state_next(xcb_input_device_state_iterator_t * i)6553 xcb_input_device_state_next (xcb_input_device_state_iterator_t *i)
6554 {
6555 xcb_input_device_state_t *R = i->data;
6556 xcb_generic_iterator_t child;
6557 child.data = (xcb_input_device_state_t *)(((char *)R) + xcb_input_device_state_sizeof(R));
6558 i->index = (char *) child.data - (char *) i->data;
6559 --i->rem;
6560 i->data = (xcb_input_device_state_t *) child.data;
6561 }
6562
6563 xcb_generic_iterator_t
xcb_input_device_state_end(xcb_input_device_state_iterator_t i)6564 xcb_input_device_state_end (xcb_input_device_state_iterator_t i)
6565 {
6566 xcb_generic_iterator_t ret;
6567 while(i.rem > 0)
6568 xcb_input_device_state_next(&i);
6569 ret.data = i.data;
6570 ret.rem = i.rem;
6571 ret.index = i.index;
6572 return ret;
6573 }
6574
6575 int
xcb_input_get_device_control_sizeof(const void * _buffer)6576 xcb_input_get_device_control_sizeof (const void *_buffer)
6577 {
6578 char *xcb_tmp = (char *)_buffer;
6579 unsigned int xcb_buffer_len = 0;
6580 unsigned int xcb_block_len = 0;
6581 unsigned int xcb_pad = 0;
6582 unsigned int xcb_align_to = 0;
6583
6584
6585 xcb_block_len += sizeof(xcb_input_get_device_control_reply_t);
6586 xcb_tmp += xcb_block_len;
6587 xcb_buffer_len += xcb_block_len;
6588 xcb_block_len = 0;
6589 /* control */
6590 xcb_block_len += xcb_input_device_state_sizeof(xcb_tmp);
6591 xcb_tmp += xcb_block_len;
6592 xcb_align_to = ALIGNOF(xcb_input_device_state_t);
6593 /* insert padding */
6594 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6595 xcb_buffer_len += xcb_block_len + xcb_pad;
6596 if (0 != xcb_pad) {
6597 xcb_tmp += xcb_pad;
6598 xcb_pad = 0;
6599 }
6600 xcb_block_len = 0;
6601
6602 return xcb_buffer_len;
6603 }
6604
6605 xcb_input_get_device_control_cookie_t
xcb_input_get_device_control(xcb_connection_t * c,uint16_t control_id,uint8_t device_id)6606 xcb_input_get_device_control (xcb_connection_t *c,
6607 uint16_t control_id,
6608 uint8_t device_id)
6609 {
6610 static const xcb_protocol_request_t xcb_req = {
6611 .count = 2,
6612 .ext = &xcb_input_id,
6613 .opcode = XCB_INPUT_GET_DEVICE_CONTROL,
6614 .isvoid = 0
6615 };
6616
6617 struct iovec xcb_parts[4];
6618 xcb_input_get_device_control_cookie_t xcb_ret;
6619 xcb_input_get_device_control_request_t xcb_out;
6620
6621 xcb_out.control_id = control_id;
6622 xcb_out.device_id = device_id;
6623 xcb_out.pad0 = 0;
6624
6625 xcb_parts[2].iov_base = (char *) &xcb_out;
6626 xcb_parts[2].iov_len = sizeof(xcb_out);
6627 xcb_parts[3].iov_base = 0;
6628 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6629
6630 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6631 return xcb_ret;
6632 }
6633
6634 xcb_input_get_device_control_cookie_t
xcb_input_get_device_control_unchecked(xcb_connection_t * c,uint16_t control_id,uint8_t device_id)6635 xcb_input_get_device_control_unchecked (xcb_connection_t *c,
6636 uint16_t control_id,
6637 uint8_t device_id)
6638 {
6639 static const xcb_protocol_request_t xcb_req = {
6640 .count = 2,
6641 .ext = &xcb_input_id,
6642 .opcode = XCB_INPUT_GET_DEVICE_CONTROL,
6643 .isvoid = 0
6644 };
6645
6646 struct iovec xcb_parts[4];
6647 xcb_input_get_device_control_cookie_t xcb_ret;
6648 xcb_input_get_device_control_request_t xcb_out;
6649
6650 xcb_out.control_id = control_id;
6651 xcb_out.device_id = device_id;
6652 xcb_out.pad0 = 0;
6653
6654 xcb_parts[2].iov_base = (char *) &xcb_out;
6655 xcb_parts[2].iov_len = sizeof(xcb_out);
6656 xcb_parts[3].iov_base = 0;
6657 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6658
6659 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6660 return xcb_ret;
6661 }
6662
6663 xcb_input_device_state_t *
xcb_input_get_device_control_control(const xcb_input_get_device_control_reply_t * R)6664 xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R)
6665 {
6666 return (xcb_input_device_state_t *) (R + 1);
6667 }
6668
6669 xcb_input_get_device_control_reply_t *
xcb_input_get_device_control_reply(xcb_connection_t * c,xcb_input_get_device_control_cookie_t cookie,xcb_generic_error_t ** e)6670 xcb_input_get_device_control_reply (xcb_connection_t *c,
6671 xcb_input_get_device_control_cookie_t cookie /**< */,
6672 xcb_generic_error_t **e)
6673 {
6674 return (xcb_input_get_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
6675 }
6676
6677 int
xcb_input_device_resolution_ctl_sizeof(const void * _buffer)6678 xcb_input_device_resolution_ctl_sizeof (const void *_buffer)
6679 {
6680 char *xcb_tmp = (char *)_buffer;
6681 const xcb_input_device_resolution_ctl_t *_aux = (xcb_input_device_resolution_ctl_t *)_buffer;
6682 unsigned int xcb_buffer_len = 0;
6683 unsigned int xcb_block_len = 0;
6684 unsigned int xcb_pad = 0;
6685 unsigned int xcb_align_to = 0;
6686
6687
6688 xcb_block_len += sizeof(xcb_input_device_resolution_ctl_t);
6689 xcb_tmp += xcb_block_len;
6690 xcb_buffer_len += xcb_block_len;
6691 xcb_block_len = 0;
6692 /* resolution_values */
6693 xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
6694 xcb_tmp += xcb_block_len;
6695 xcb_align_to = ALIGNOF(uint32_t);
6696 /* insert padding */
6697 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6698 xcb_buffer_len += xcb_block_len + xcb_pad;
6699 if (0 != xcb_pad) {
6700 xcb_tmp += xcb_pad;
6701 xcb_pad = 0;
6702 }
6703 xcb_block_len = 0;
6704
6705 return xcb_buffer_len;
6706 }
6707
6708 uint32_t *
xcb_input_device_resolution_ctl_resolution_values(const xcb_input_device_resolution_ctl_t * R)6709 xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R)
6710 {
6711 return (uint32_t *) (R + 1);
6712 }
6713
6714 int
xcb_input_device_resolution_ctl_resolution_values_length(const xcb_input_device_resolution_ctl_t * R)6715 xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R)
6716 {
6717 return R->num_valuators;
6718 }
6719
6720 xcb_generic_iterator_t
xcb_input_device_resolution_ctl_resolution_values_end(const xcb_input_device_resolution_ctl_t * R)6721 xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R)
6722 {
6723 xcb_generic_iterator_t i;
6724 i.data = ((uint32_t *) (R + 1)) + (R->num_valuators);
6725 i.rem = 0;
6726 i.index = (char *) i.data - (char *) R;
6727 return i;
6728 }
6729
6730 void
xcb_input_device_resolution_ctl_next(xcb_input_device_resolution_ctl_iterator_t * i)6731 xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i)
6732 {
6733 xcb_input_device_resolution_ctl_t *R = i->data;
6734 xcb_generic_iterator_t child;
6735 child.data = (xcb_input_device_resolution_ctl_t *)(((char *)R) + xcb_input_device_resolution_ctl_sizeof(R));
6736 i->index = (char *) child.data - (char *) i->data;
6737 --i->rem;
6738 i->data = (xcb_input_device_resolution_ctl_t *) child.data;
6739 }
6740
6741 xcb_generic_iterator_t
xcb_input_device_resolution_ctl_end(xcb_input_device_resolution_ctl_iterator_t i)6742 xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i)
6743 {
6744 xcb_generic_iterator_t ret;
6745 while(i.rem > 0)
6746 xcb_input_device_resolution_ctl_next(&i);
6747 ret.data = i.data;
6748 ret.rem = i.rem;
6749 ret.index = i.index;
6750 return ret;
6751 }
6752
6753 void
xcb_input_device_abs_calib_ctl_next(xcb_input_device_abs_calib_ctl_iterator_t * i)6754 xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i)
6755 {
6756 --i->rem;
6757 ++i->data;
6758 i->index += sizeof(xcb_input_device_abs_calib_ctl_t);
6759 }
6760
6761 xcb_generic_iterator_t
xcb_input_device_abs_calib_ctl_end(xcb_input_device_abs_calib_ctl_iterator_t i)6762 xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i)
6763 {
6764 xcb_generic_iterator_t ret;
6765 ret.data = i.data + i.rem;
6766 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6767 ret.rem = 0;
6768 return ret;
6769 }
6770
6771 void
xcb_input_device_abs_area_ctrl_next(xcb_input_device_abs_area_ctrl_iterator_t * i)6772 xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i)
6773 {
6774 --i->rem;
6775 ++i->data;
6776 i->index += sizeof(xcb_input_device_abs_area_ctrl_t);
6777 }
6778
6779 xcb_generic_iterator_t
xcb_input_device_abs_area_ctrl_end(xcb_input_device_abs_area_ctrl_iterator_t i)6780 xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i)
6781 {
6782 xcb_generic_iterator_t ret;
6783 ret.data = i.data + i.rem;
6784 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6785 ret.rem = 0;
6786 return ret;
6787 }
6788
6789 void
xcb_input_device_core_ctrl_next(xcb_input_device_core_ctrl_iterator_t * i)6790 xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i)
6791 {
6792 --i->rem;
6793 ++i->data;
6794 i->index += sizeof(xcb_input_device_core_ctrl_t);
6795 }
6796
6797 xcb_generic_iterator_t
xcb_input_device_core_ctrl_end(xcb_input_device_core_ctrl_iterator_t i)6798 xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i)
6799 {
6800 xcb_generic_iterator_t ret;
6801 ret.data = i.data + i.rem;
6802 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6803 ret.rem = 0;
6804 return ret;
6805 }
6806
6807 void
xcb_input_device_enable_ctrl_next(xcb_input_device_enable_ctrl_iterator_t * i)6808 xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i)
6809 {
6810 --i->rem;
6811 ++i->data;
6812 i->index += sizeof(xcb_input_device_enable_ctrl_t);
6813 }
6814
6815 xcb_generic_iterator_t
xcb_input_device_enable_ctrl_end(xcb_input_device_enable_ctrl_iterator_t i)6816 xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i)
6817 {
6818 xcb_generic_iterator_t ret;
6819 ret.data = i.data + i.rem;
6820 ret.index = i.index + ((char *) ret.data - (char *) i.data);
6821 ret.rem = 0;
6822 return ret;
6823 }
6824
6825 uint32_t *
xcb_input_device_ctl_data_resolution_resolution_values(const xcb_input_device_ctl_data_t * S)6826 xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S)
6827 {
6828 return S->resolution.resolution_values;
6829 }
6830
6831 int
xcb_input_device_ctl_data_resolution_resolution_values_length(const xcb_input_device_ctl_t * R,const xcb_input_device_ctl_data_t * S)6832 xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R,
6833 const xcb_input_device_ctl_data_t *S)
6834 {
6835 return S->resolution.num_valuators;
6836 }
6837
6838 xcb_generic_iterator_t
xcb_input_device_ctl_data_resolution_resolution_values_end(const xcb_input_device_ctl_t * R,const xcb_input_device_ctl_data_t * S)6839 xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R,
6840 const xcb_input_device_ctl_data_t *S)
6841 {
6842 xcb_generic_iterator_t i;
6843 i.data = S->resolution.resolution_values + S->resolution.num_valuators;
6844 i.rem = 0;
6845 i.index = (char *) i.data - (char *) S;
6846 return i;
6847 }
6848
6849 int
xcb_input_device_ctl_data_serialize(void ** _buffer,uint16_t control_id,const xcb_input_device_ctl_data_t * _aux)6850 xcb_input_device_ctl_data_serialize (void **_buffer,
6851 uint16_t control_id,
6852 const xcb_input_device_ctl_data_t *_aux)
6853 {
6854 char *xcb_out = *_buffer;
6855 unsigned int xcb_buffer_len = 0;
6856 unsigned int xcb_align_to = 0;
6857 unsigned int xcb_padding_offset = 0;
6858
6859 unsigned int xcb_pad = 0;
6860 char xcb_pad0[3] = {0, 0, 0};
6861 struct iovec xcb_parts[24];
6862 unsigned int xcb_parts_idx = 0;
6863 unsigned int xcb_block_len = 0;
6864 unsigned int i;
6865 char *xcb_tmp;
6866
6867 if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
6868 /* xcb_input_device_ctl_data_t.resolution.first_valuator */
6869 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.first_valuator;
6870 xcb_block_len += sizeof(uint8_t);
6871 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6872 xcb_parts_idx++;
6873 xcb_align_to = ALIGNOF(uint8_t);
6874 /* xcb_input_device_ctl_data_t.resolution.num_valuators */
6875 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators;
6876 xcb_block_len += sizeof(uint8_t);
6877 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6878 xcb_parts_idx++;
6879 xcb_align_to = ALIGNOF(uint8_t);
6880 /* xcb_input_device_ctl_data_t.resolution.pad0 */
6881 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6882 xcb_block_len += sizeof(uint8_t)*2;
6883 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
6884 xcb_parts_idx++;
6885 xcb_align_to = ALIGNOF(uint8_t);
6886 /* insert padding */
6887 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6888 xcb_buffer_len += xcb_block_len + xcb_pad;
6889 if (0 != xcb_pad) {
6890 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6891 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6892 xcb_parts_idx++;
6893 xcb_pad = 0;
6894 }
6895 xcb_block_len = 0;
6896 xcb_padding_offset = 0;
6897 /* resolution_values */
6898 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values;
6899 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
6900 xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
6901 xcb_parts_idx++;
6902 xcb_align_to = ALIGNOF(uint32_t);
6903 }
6904 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
6905 /* xcb_input_device_ctl_data_t.abs_calib.min_x */
6906 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x;
6907 xcb_block_len += sizeof(int32_t);
6908 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6909 xcb_parts_idx++;
6910 xcb_align_to = ALIGNOF(int32_t);
6911 /* xcb_input_device_ctl_data_t.abs_calib.max_x */
6912 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x;
6913 xcb_block_len += sizeof(int32_t);
6914 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6915 xcb_parts_idx++;
6916 xcb_align_to = ALIGNOF(int32_t);
6917 /* xcb_input_device_ctl_data_t.abs_calib.min_y */
6918 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y;
6919 xcb_block_len += sizeof(int32_t);
6920 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6921 xcb_parts_idx++;
6922 xcb_align_to = ALIGNOF(int32_t);
6923 /* xcb_input_device_ctl_data_t.abs_calib.max_y */
6924 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y;
6925 xcb_block_len += sizeof(int32_t);
6926 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6927 xcb_parts_idx++;
6928 xcb_align_to = ALIGNOF(int32_t);
6929 /* xcb_input_device_ctl_data_t.abs_calib.flip_x */
6930 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x;
6931 xcb_block_len += sizeof(uint32_t);
6932 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6933 xcb_parts_idx++;
6934 xcb_align_to = ALIGNOF(uint32_t);
6935 /* xcb_input_device_ctl_data_t.abs_calib.flip_y */
6936 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y;
6937 xcb_block_len += sizeof(uint32_t);
6938 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6939 xcb_parts_idx++;
6940 xcb_align_to = ALIGNOF(uint32_t);
6941 /* xcb_input_device_ctl_data_t.abs_calib.rotation */
6942 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation;
6943 xcb_block_len += sizeof(uint32_t);
6944 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6945 xcb_parts_idx++;
6946 xcb_align_to = ALIGNOF(uint32_t);
6947 /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */
6948 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold;
6949 xcb_block_len += sizeof(uint32_t);
6950 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6951 xcb_parts_idx++;
6952 xcb_align_to = ALIGNOF(uint32_t);
6953 }
6954 if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
6955 /* xcb_input_device_ctl_data_t.core.status */
6956 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status;
6957 xcb_block_len += sizeof(uint8_t);
6958 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6959 xcb_parts_idx++;
6960 xcb_align_to = ALIGNOF(uint8_t);
6961 /* xcb_input_device_ctl_data_t.core.pad1 */
6962 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6963 xcb_block_len += sizeof(uint8_t)*3;
6964 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
6965 xcb_parts_idx++;
6966 xcb_align_to = ALIGNOF(uint8_t);
6967 }
6968 if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
6969 /* xcb_input_device_ctl_data_t.enable.enable */
6970 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable;
6971 xcb_block_len += sizeof(uint8_t);
6972 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
6973 xcb_parts_idx++;
6974 xcb_align_to = ALIGNOF(uint8_t);
6975 /* xcb_input_device_ctl_data_t.enable.pad2 */
6976 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6977 xcb_block_len += sizeof(uint8_t)*3;
6978 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
6979 xcb_parts_idx++;
6980 xcb_align_to = ALIGNOF(uint8_t);
6981 }
6982 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
6983 /* xcb_input_device_ctl_data_t.abs_area.offset_x */
6984 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x;
6985 xcb_block_len += sizeof(uint32_t);
6986 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6987 xcb_parts_idx++;
6988 xcb_align_to = ALIGNOF(uint32_t);
6989 /* xcb_input_device_ctl_data_t.abs_area.offset_y */
6990 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y;
6991 xcb_block_len += sizeof(uint32_t);
6992 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
6993 xcb_parts_idx++;
6994 xcb_align_to = ALIGNOF(uint32_t);
6995 /* xcb_input_device_ctl_data_t.abs_area.width */
6996 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width;
6997 xcb_block_len += sizeof(int32_t);
6998 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
6999 xcb_parts_idx++;
7000 xcb_align_to = ALIGNOF(int32_t);
7001 /* xcb_input_device_ctl_data_t.abs_area.height */
7002 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height;
7003 xcb_block_len += sizeof(int32_t);
7004 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7005 xcb_parts_idx++;
7006 xcb_align_to = ALIGNOF(int32_t);
7007 /* xcb_input_device_ctl_data_t.abs_area.screen */
7008 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen;
7009 xcb_block_len += sizeof(int32_t);
7010 xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
7011 xcb_parts_idx++;
7012 xcb_align_to = ALIGNOF(int32_t);
7013 /* xcb_input_device_ctl_data_t.abs_area.following */
7014 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following;
7015 xcb_block_len += sizeof(uint32_t);
7016 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
7017 xcb_parts_idx++;
7018 xcb_align_to = ALIGNOF(uint32_t);
7019 }
7020 /* insert padding */
7021 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7022 xcb_buffer_len += xcb_block_len + xcb_pad;
7023 if (0 != xcb_pad) {
7024 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7025 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7026 xcb_parts_idx++;
7027 xcb_pad = 0;
7028 }
7029 xcb_block_len = 0;
7030 xcb_padding_offset = 0;
7031
7032 if (NULL == xcb_out) {
7033 /* allocate memory */
7034 xcb_out = malloc(xcb_buffer_len);
7035 *_buffer = xcb_out;
7036 }
7037
7038 xcb_tmp = xcb_out;
7039 for(i=0; i<xcb_parts_idx; i++) {
7040 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
7041 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
7042 if (0 != xcb_parts[i].iov_len)
7043 xcb_tmp += xcb_parts[i].iov_len;
7044 }
7045
7046 return xcb_buffer_len;
7047 }
7048
7049 int
xcb_input_device_ctl_data_unpack(const void * _buffer,uint16_t control_id,xcb_input_device_ctl_data_t * _aux)7050 xcb_input_device_ctl_data_unpack (const void *_buffer,
7051 uint16_t control_id,
7052 xcb_input_device_ctl_data_t *_aux)
7053 {
7054 char *xcb_tmp = (char *)_buffer;
7055 unsigned int xcb_buffer_len = 0;
7056 unsigned int xcb_block_len = 0;
7057 unsigned int xcb_pad = 0;
7058 unsigned int xcb_align_to = 0;
7059 unsigned int xcb_padding_offset = 0;
7060
7061
7062 if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
7063 /* xcb_input_device_ctl_data_t.resolution.first_valuator */
7064 _aux->resolution.first_valuator = *(uint8_t *)xcb_tmp;
7065 xcb_block_len += sizeof(uint8_t);
7066 xcb_tmp += sizeof(uint8_t);
7067 xcb_align_to = ALIGNOF(uint8_t);
7068 /* xcb_input_device_ctl_data_t.resolution.num_valuators */
7069 _aux->resolution.num_valuators = *(uint8_t *)xcb_tmp;
7070 xcb_block_len += sizeof(uint8_t);
7071 xcb_tmp += sizeof(uint8_t);
7072 xcb_align_to = ALIGNOF(uint8_t);
7073 /* xcb_input_device_ctl_data_t.resolution.pad0 */
7074 _aux->resolution.pad0[0] = *(uint8_t *)xcb_tmp;
7075 _aux->resolution.pad0[1] = *(uint8_t *)xcb_tmp;
7076 xcb_block_len += sizeof(uint8_t) * 2;
7077 xcb_tmp += sizeof(uint8_t) * 2;
7078 xcb_align_to = ALIGNOF(uint8_t);
7079 /* insert padding */
7080 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7081 xcb_buffer_len += xcb_block_len + xcb_pad;
7082 if (0 != xcb_pad) {
7083 xcb_tmp += xcb_pad;
7084 xcb_pad = 0;
7085 }
7086 xcb_block_len = 0;
7087 xcb_padding_offset = 0;
7088 /* resolution_values */
7089 _aux->resolution.resolution_values = (uint32_t *)xcb_tmp;
7090 xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
7091 xcb_tmp += xcb_block_len;
7092 xcb_align_to = ALIGNOF(uint32_t);
7093 }
7094 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
7095 /* xcb_input_device_ctl_data_t.abs_calib.min_x */
7096 _aux->abs_calib.min_x = *(int32_t *)xcb_tmp;
7097 xcb_block_len += sizeof(int32_t);
7098 xcb_tmp += sizeof(int32_t);
7099 xcb_align_to = ALIGNOF(int32_t);
7100 /* xcb_input_device_ctl_data_t.abs_calib.max_x */
7101 _aux->abs_calib.max_x = *(int32_t *)xcb_tmp;
7102 xcb_block_len += sizeof(int32_t);
7103 xcb_tmp += sizeof(int32_t);
7104 xcb_align_to = ALIGNOF(int32_t);
7105 /* xcb_input_device_ctl_data_t.abs_calib.min_y */
7106 _aux->abs_calib.min_y = *(int32_t *)xcb_tmp;
7107 xcb_block_len += sizeof(int32_t);
7108 xcb_tmp += sizeof(int32_t);
7109 xcb_align_to = ALIGNOF(int32_t);
7110 /* xcb_input_device_ctl_data_t.abs_calib.max_y */
7111 _aux->abs_calib.max_y = *(int32_t *)xcb_tmp;
7112 xcb_block_len += sizeof(int32_t);
7113 xcb_tmp += sizeof(int32_t);
7114 xcb_align_to = ALIGNOF(int32_t);
7115 /* xcb_input_device_ctl_data_t.abs_calib.flip_x */
7116 _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp;
7117 xcb_block_len += sizeof(uint32_t);
7118 xcb_tmp += sizeof(uint32_t);
7119 xcb_align_to = ALIGNOF(uint32_t);
7120 /* xcb_input_device_ctl_data_t.abs_calib.flip_y */
7121 _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp;
7122 xcb_block_len += sizeof(uint32_t);
7123 xcb_tmp += sizeof(uint32_t);
7124 xcb_align_to = ALIGNOF(uint32_t);
7125 /* xcb_input_device_ctl_data_t.abs_calib.rotation */
7126 _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp;
7127 xcb_block_len += sizeof(uint32_t);
7128 xcb_tmp += sizeof(uint32_t);
7129 xcb_align_to = ALIGNOF(uint32_t);
7130 /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */
7131 _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp;
7132 xcb_block_len += sizeof(uint32_t);
7133 xcb_tmp += sizeof(uint32_t);
7134 xcb_align_to = ALIGNOF(uint32_t);
7135 }
7136 if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
7137 /* xcb_input_device_ctl_data_t.core.status */
7138 _aux->core.status = *(uint8_t *)xcb_tmp;
7139 xcb_block_len += sizeof(uint8_t);
7140 xcb_tmp += sizeof(uint8_t);
7141 xcb_align_to = ALIGNOF(uint8_t);
7142 /* xcb_input_device_ctl_data_t.core.pad1 */
7143 _aux->core.pad1[0] = *(uint8_t *)xcb_tmp;
7144 _aux->core.pad1[1] = *(uint8_t *)xcb_tmp;
7145 _aux->core.pad1[2] = *(uint8_t *)xcb_tmp;
7146 xcb_block_len += sizeof(uint8_t) * 3;
7147 xcb_tmp += sizeof(uint8_t) * 3;
7148 xcb_align_to = ALIGNOF(uint8_t);
7149 }
7150 if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
7151 /* xcb_input_device_ctl_data_t.enable.enable */
7152 _aux->enable.enable = *(uint8_t *)xcb_tmp;
7153 xcb_block_len += sizeof(uint8_t);
7154 xcb_tmp += sizeof(uint8_t);
7155 xcb_align_to = ALIGNOF(uint8_t);
7156 /* xcb_input_device_ctl_data_t.enable.pad2 */
7157 _aux->enable.pad2[0] = *(uint8_t *)xcb_tmp;
7158 _aux->enable.pad2[1] = *(uint8_t *)xcb_tmp;
7159 _aux->enable.pad2[2] = *(uint8_t *)xcb_tmp;
7160 xcb_block_len += sizeof(uint8_t) * 3;
7161 xcb_tmp += sizeof(uint8_t) * 3;
7162 xcb_align_to = ALIGNOF(uint8_t);
7163 }
7164 if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
7165 /* xcb_input_device_ctl_data_t.abs_area.offset_x */
7166 _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp;
7167 xcb_block_len += sizeof(uint32_t);
7168 xcb_tmp += sizeof(uint32_t);
7169 xcb_align_to = ALIGNOF(uint32_t);
7170 /* xcb_input_device_ctl_data_t.abs_area.offset_y */
7171 _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp;
7172 xcb_block_len += sizeof(uint32_t);
7173 xcb_tmp += sizeof(uint32_t);
7174 xcb_align_to = ALIGNOF(uint32_t);
7175 /* xcb_input_device_ctl_data_t.abs_area.width */
7176 _aux->abs_area.width = *(int32_t *)xcb_tmp;
7177 xcb_block_len += sizeof(int32_t);
7178 xcb_tmp += sizeof(int32_t);
7179 xcb_align_to = ALIGNOF(int32_t);
7180 /* xcb_input_device_ctl_data_t.abs_area.height */
7181 _aux->abs_area.height = *(int32_t *)xcb_tmp;
7182 xcb_block_len += sizeof(int32_t);
7183 xcb_tmp += sizeof(int32_t);
7184 xcb_align_to = ALIGNOF(int32_t);
7185 /* xcb_input_device_ctl_data_t.abs_area.screen */
7186 _aux->abs_area.screen = *(int32_t *)xcb_tmp;
7187 xcb_block_len += sizeof(int32_t);
7188 xcb_tmp += sizeof(int32_t);
7189 xcb_align_to = ALIGNOF(int32_t);
7190 /* xcb_input_device_ctl_data_t.abs_area.following */
7191 _aux->abs_area.following = *(uint32_t *)xcb_tmp;
7192 xcb_block_len += sizeof(uint32_t);
7193 xcb_tmp += sizeof(uint32_t);
7194 xcb_align_to = ALIGNOF(uint32_t);
7195 }
7196 /* insert padding */
7197 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7198 xcb_buffer_len += xcb_block_len + xcb_pad;
7199 if (0 != xcb_pad) {
7200 xcb_tmp += xcb_pad;
7201 xcb_pad = 0;
7202 }
7203 xcb_block_len = 0;
7204 xcb_padding_offset = 0;
7205
7206 return xcb_buffer_len;
7207 }
7208
7209 int
xcb_input_device_ctl_data_sizeof(const void * _buffer,uint16_t control_id)7210 xcb_input_device_ctl_data_sizeof (const void *_buffer,
7211 uint16_t control_id)
7212 {
7213 xcb_input_device_ctl_data_t _aux;
7214 return xcb_input_device_ctl_data_unpack(_buffer, control_id, &_aux);
7215 }
7216
7217 int
xcb_input_device_ctl_sizeof(const void * _buffer)7218 xcb_input_device_ctl_sizeof (const void *_buffer)
7219 {
7220 char *xcb_tmp = (char *)_buffer;
7221 const xcb_input_device_ctl_t *_aux = (xcb_input_device_ctl_t *)_buffer;
7222 unsigned int xcb_buffer_len = 0;
7223 unsigned int xcb_block_len = 0;
7224 unsigned int xcb_pad = 0;
7225 unsigned int xcb_align_to = 0;
7226
7227
7228 xcb_block_len += sizeof(xcb_input_device_ctl_t);
7229 xcb_tmp += xcb_block_len;
7230 xcb_buffer_len += xcb_block_len;
7231 xcb_block_len = 0;
7232 /* data */
7233 xcb_block_len += xcb_input_device_ctl_data_sizeof(xcb_tmp, _aux->control_id);
7234 xcb_tmp += xcb_block_len;
7235 xcb_align_to = ALIGNOF(char);
7236 /* insert padding */
7237 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7238 xcb_buffer_len += xcb_block_len + xcb_pad;
7239 if (0 != xcb_pad) {
7240 xcb_tmp += xcb_pad;
7241 xcb_pad = 0;
7242 }
7243 xcb_block_len = 0;
7244
7245 return xcb_buffer_len;
7246 }
7247
7248 void *
xcb_input_device_ctl_data(const xcb_input_device_ctl_t * R)7249 xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R)
7250 {
7251 return (void *) (R + 1);
7252 }
7253
7254 void
xcb_input_device_ctl_next(xcb_input_device_ctl_iterator_t * i)7255 xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i)
7256 {
7257 xcb_input_device_ctl_t *R = i->data;
7258 xcb_generic_iterator_t child;
7259 child.data = (xcb_input_device_ctl_t *)(((char *)R) + xcb_input_device_ctl_sizeof(R));
7260 i->index = (char *) child.data - (char *) i->data;
7261 --i->rem;
7262 i->data = (xcb_input_device_ctl_t *) child.data;
7263 }
7264
7265 xcb_generic_iterator_t
xcb_input_device_ctl_end(xcb_input_device_ctl_iterator_t i)7266 xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i)
7267 {
7268 xcb_generic_iterator_t ret;
7269 while(i.rem > 0)
7270 xcb_input_device_ctl_next(&i);
7271 ret.data = i.data;
7272 ret.rem = i.rem;
7273 ret.index = i.index;
7274 return ret;
7275 }
7276
7277 int
xcb_input_change_device_control_sizeof(const void * _buffer)7278 xcb_input_change_device_control_sizeof (const void *_buffer)
7279 {
7280 char *xcb_tmp = (char *)_buffer;
7281 unsigned int xcb_buffer_len = 0;
7282 unsigned int xcb_block_len = 0;
7283 unsigned int xcb_pad = 0;
7284 unsigned int xcb_align_to = 0;
7285
7286
7287 xcb_block_len += sizeof(xcb_input_change_device_control_request_t);
7288 xcb_tmp += xcb_block_len;
7289 xcb_buffer_len += xcb_block_len;
7290 xcb_block_len = 0;
7291 /* control */
7292 xcb_block_len += xcb_input_device_ctl_sizeof(xcb_tmp);
7293 xcb_tmp += xcb_block_len;
7294 xcb_align_to = ALIGNOF(xcb_input_device_ctl_t);
7295 /* insert padding */
7296 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7297 xcb_buffer_len += xcb_block_len + xcb_pad;
7298 if (0 != xcb_pad) {
7299 xcb_tmp += xcb_pad;
7300 xcb_pad = 0;
7301 }
7302 xcb_block_len = 0;
7303
7304 return xcb_buffer_len;
7305 }
7306
7307 xcb_input_change_device_control_cookie_t
xcb_input_change_device_control(xcb_connection_t * c,uint16_t control_id,uint8_t device_id,xcb_input_device_ctl_t * control)7308 xcb_input_change_device_control (xcb_connection_t *c,
7309 uint16_t control_id,
7310 uint8_t device_id,
7311 xcb_input_device_ctl_t *control)
7312 {
7313 static const xcb_protocol_request_t xcb_req = {
7314 .count = 4,
7315 .ext = &xcb_input_id,
7316 .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL,
7317 .isvoid = 0
7318 };
7319
7320 struct iovec xcb_parts[6];
7321 xcb_input_change_device_control_cookie_t xcb_ret;
7322 xcb_input_change_device_control_request_t xcb_out;
7323
7324 xcb_out.control_id = control_id;
7325 xcb_out.device_id = device_id;
7326 xcb_out.pad0 = 0;
7327
7328 xcb_parts[2].iov_base = (char *) &xcb_out;
7329 xcb_parts[2].iov_len = sizeof(xcb_out);
7330 xcb_parts[3].iov_base = 0;
7331 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7332 /* xcb_input_device_ctl_t control */
7333 xcb_parts[4].iov_base = (char *) control;
7334 xcb_parts[4].iov_len =
7335 xcb_input_device_ctl_sizeof (control);
7336
7337 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7338 return xcb_ret;
7339 }
7340
7341 xcb_input_change_device_control_cookie_t
xcb_input_change_device_control_unchecked(xcb_connection_t * c,uint16_t control_id,uint8_t device_id,xcb_input_device_ctl_t * control)7342 xcb_input_change_device_control_unchecked (xcb_connection_t *c,
7343 uint16_t control_id,
7344 uint8_t device_id,
7345 xcb_input_device_ctl_t *control)
7346 {
7347 static const xcb_protocol_request_t xcb_req = {
7348 .count = 4,
7349 .ext = &xcb_input_id,
7350 .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL,
7351 .isvoid = 0
7352 };
7353
7354 struct iovec xcb_parts[6];
7355 xcb_input_change_device_control_cookie_t xcb_ret;
7356 xcb_input_change_device_control_request_t xcb_out;
7357
7358 xcb_out.control_id = control_id;
7359 xcb_out.device_id = device_id;
7360 xcb_out.pad0 = 0;
7361
7362 xcb_parts[2].iov_base = (char *) &xcb_out;
7363 xcb_parts[2].iov_len = sizeof(xcb_out);
7364 xcb_parts[3].iov_base = 0;
7365 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7366 /* xcb_input_device_ctl_t control */
7367 xcb_parts[4].iov_base = (char *) control;
7368 xcb_parts[4].iov_len =
7369 xcb_input_device_ctl_sizeof (control);
7370
7371 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7372 return xcb_ret;
7373 }
7374
7375 xcb_input_change_device_control_reply_t *
xcb_input_change_device_control_reply(xcb_connection_t * c,xcb_input_change_device_control_cookie_t cookie,xcb_generic_error_t ** e)7376 xcb_input_change_device_control_reply (xcb_connection_t *c,
7377 xcb_input_change_device_control_cookie_t cookie /**< */,
7378 xcb_generic_error_t **e)
7379 {
7380 return (xcb_input_change_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
7381 }
7382
7383 int
xcb_input_list_device_properties_sizeof(const void * _buffer)7384 xcb_input_list_device_properties_sizeof (const void *_buffer)
7385 {
7386 char *xcb_tmp = (char *)_buffer;
7387 const xcb_input_list_device_properties_reply_t *_aux = (xcb_input_list_device_properties_reply_t *)_buffer;
7388 unsigned int xcb_buffer_len = 0;
7389 unsigned int xcb_block_len = 0;
7390 unsigned int xcb_pad = 0;
7391 unsigned int xcb_align_to = 0;
7392
7393
7394 xcb_block_len += sizeof(xcb_input_list_device_properties_reply_t);
7395 xcb_tmp += xcb_block_len;
7396 xcb_buffer_len += xcb_block_len;
7397 xcb_block_len = 0;
7398 /* atoms */
7399 xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t);
7400 xcb_tmp += xcb_block_len;
7401 xcb_align_to = ALIGNOF(xcb_atom_t);
7402 /* insert padding */
7403 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7404 xcb_buffer_len += xcb_block_len + xcb_pad;
7405 if (0 != xcb_pad) {
7406 xcb_tmp += xcb_pad;
7407 xcb_pad = 0;
7408 }
7409 xcb_block_len = 0;
7410
7411 return xcb_buffer_len;
7412 }
7413
7414 xcb_input_list_device_properties_cookie_t
xcb_input_list_device_properties(xcb_connection_t * c,uint8_t device_id)7415 xcb_input_list_device_properties (xcb_connection_t *c,
7416 uint8_t device_id)
7417 {
7418 static const xcb_protocol_request_t xcb_req = {
7419 .count = 2,
7420 .ext = &xcb_input_id,
7421 .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES,
7422 .isvoid = 0
7423 };
7424
7425 struct iovec xcb_parts[4];
7426 xcb_input_list_device_properties_cookie_t xcb_ret;
7427 xcb_input_list_device_properties_request_t xcb_out;
7428
7429 xcb_out.device_id = device_id;
7430 memset(xcb_out.pad0, 0, 3);
7431
7432 xcb_parts[2].iov_base = (char *) &xcb_out;
7433 xcb_parts[2].iov_len = sizeof(xcb_out);
7434 xcb_parts[3].iov_base = 0;
7435 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7436
7437 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7438 return xcb_ret;
7439 }
7440
7441 xcb_input_list_device_properties_cookie_t
xcb_input_list_device_properties_unchecked(xcb_connection_t * c,uint8_t device_id)7442 xcb_input_list_device_properties_unchecked (xcb_connection_t *c,
7443 uint8_t device_id)
7444 {
7445 static const xcb_protocol_request_t xcb_req = {
7446 .count = 2,
7447 .ext = &xcb_input_id,
7448 .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES,
7449 .isvoid = 0
7450 };
7451
7452 struct iovec xcb_parts[4];
7453 xcb_input_list_device_properties_cookie_t xcb_ret;
7454 xcb_input_list_device_properties_request_t xcb_out;
7455
7456 xcb_out.device_id = device_id;
7457 memset(xcb_out.pad0, 0, 3);
7458
7459 xcb_parts[2].iov_base = (char *) &xcb_out;
7460 xcb_parts[2].iov_len = sizeof(xcb_out);
7461 xcb_parts[3].iov_base = 0;
7462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7463
7464 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7465 return xcb_ret;
7466 }
7467
7468 xcb_atom_t *
xcb_input_list_device_properties_atoms(const xcb_input_list_device_properties_reply_t * R)7469 xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R)
7470 {
7471 return (xcb_atom_t *) (R + 1);
7472 }
7473
7474 int
xcb_input_list_device_properties_atoms_length(const xcb_input_list_device_properties_reply_t * R)7475 xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R)
7476 {
7477 return R->num_atoms;
7478 }
7479
7480 xcb_generic_iterator_t
xcb_input_list_device_properties_atoms_end(const xcb_input_list_device_properties_reply_t * R)7481 xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R)
7482 {
7483 xcb_generic_iterator_t i;
7484 i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms);
7485 i.rem = 0;
7486 i.index = (char *) i.data - (char *) R;
7487 return i;
7488 }
7489
7490 xcb_input_list_device_properties_reply_t *
xcb_input_list_device_properties_reply(xcb_connection_t * c,xcb_input_list_device_properties_cookie_t cookie,xcb_generic_error_t ** e)7491 xcb_input_list_device_properties_reply (xcb_connection_t *c,
7492 xcb_input_list_device_properties_cookie_t cookie /**< */,
7493 xcb_generic_error_t **e)
7494 {
7495 return (xcb_input_list_device_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
7496 }
7497
7498 uint8_t *
xcb_input_change_device_property_items_data_8(const xcb_input_change_device_property_items_t * S)7499 xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S)
7500 {
7501 return S->data8;
7502 }
7503
7504 int
xcb_input_change_device_property_items_data_8_length(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7505 xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R,
7506 const xcb_input_change_device_property_items_t *S)
7507 {
7508 return R->num_items;
7509 }
7510
7511 xcb_generic_iterator_t
xcb_input_change_device_property_items_data_8_end(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7512 xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R,
7513 const xcb_input_change_device_property_items_t *S)
7514 {
7515 xcb_generic_iterator_t i;
7516 i.data = S->data8 + R->num_items;
7517 i.rem = 0;
7518 i.index = (char *) i.data - (char *) S;
7519 return i;
7520 }
7521
7522 uint16_t *
xcb_input_change_device_property_items_data_16(const xcb_input_change_device_property_items_t * S)7523 xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S)
7524 {
7525 return S->data16;
7526 }
7527
7528 int
xcb_input_change_device_property_items_data_16_length(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7529 xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R,
7530 const xcb_input_change_device_property_items_t *S)
7531 {
7532 return R->num_items;
7533 }
7534
7535 xcb_generic_iterator_t
xcb_input_change_device_property_items_data_16_end(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7536 xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R,
7537 const xcb_input_change_device_property_items_t *S)
7538 {
7539 xcb_generic_iterator_t i;
7540 i.data = S->data16 + R->num_items;
7541 i.rem = 0;
7542 i.index = (char *) i.data - (char *) S;
7543 return i;
7544 }
7545
7546 uint32_t *
xcb_input_change_device_property_items_data_32(const xcb_input_change_device_property_items_t * S)7547 xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S)
7548 {
7549 return S->data32;
7550 }
7551
7552 int
xcb_input_change_device_property_items_data_32_length(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7553 xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R,
7554 const xcb_input_change_device_property_items_t *S)
7555 {
7556 return R->num_items;
7557 }
7558
7559 xcb_generic_iterator_t
xcb_input_change_device_property_items_data_32_end(const xcb_input_change_device_property_request_t * R,const xcb_input_change_device_property_items_t * S)7560 xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R,
7561 const xcb_input_change_device_property_items_t *S)
7562 {
7563 xcb_generic_iterator_t i;
7564 i.data = S->data32 + R->num_items;
7565 i.rem = 0;
7566 i.index = (char *) i.data - (char *) S;
7567 return i;
7568 }
7569
7570 int
xcb_input_change_device_property_items_serialize(void ** _buffer,uint32_t num_items,uint8_t format,const xcb_input_change_device_property_items_t * _aux)7571 xcb_input_change_device_property_items_serialize (void **_buffer,
7572 uint32_t num_items,
7573 uint8_t format,
7574 const xcb_input_change_device_property_items_t *_aux)
7575 {
7576 char *xcb_out = *_buffer;
7577 unsigned int xcb_buffer_len = 0;
7578 unsigned int xcb_align_to = 0;
7579 unsigned int xcb_padding_offset = 0;
7580
7581 unsigned int xcb_pad = 0;
7582 char xcb_pad0[3] = {0, 0, 0};
7583 struct iovec xcb_parts[9];
7584 unsigned int xcb_parts_idx = 0;
7585 unsigned int xcb_block_len = 0;
7586 unsigned int i;
7587 char *xcb_tmp;
7588
7589 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
7590 /* insert padding */
7591 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7592 xcb_buffer_len += xcb_block_len + xcb_pad;
7593 if (0 != xcb_pad) {
7594 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7595 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7596 xcb_parts_idx++;
7597 xcb_pad = 0;
7598 }
7599 xcb_block_len = 0;
7600 xcb_padding_offset = 0;
7601 /* data8 */
7602 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
7603 xcb_block_len += num_items * sizeof(uint8_t);
7604 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
7605 xcb_parts_idx++;
7606 xcb_align_to = ALIGNOF(uint8_t);
7607 xcb_align_to = 4;
7608 /* insert padding */
7609 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7610 xcb_buffer_len += xcb_block_len + xcb_pad;
7611 if (0 != xcb_pad) {
7612 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7613 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7614 xcb_parts_idx++;
7615 xcb_pad = 0;
7616 }
7617 xcb_block_len = 0;
7618 xcb_padding_offset = 0;
7619 }
7620 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
7621 /* insert padding */
7622 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7623 xcb_buffer_len += xcb_block_len + xcb_pad;
7624 if (0 != xcb_pad) {
7625 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7626 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7627 xcb_parts_idx++;
7628 xcb_pad = 0;
7629 }
7630 xcb_block_len = 0;
7631 xcb_padding_offset = 0;
7632 /* data16 */
7633 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
7634 xcb_block_len += num_items * sizeof(uint16_t);
7635 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
7636 xcb_parts_idx++;
7637 xcb_align_to = ALIGNOF(uint16_t);
7638 xcb_align_to = 4;
7639 /* insert padding */
7640 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7641 xcb_buffer_len += xcb_block_len + xcb_pad;
7642 if (0 != xcb_pad) {
7643 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7644 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7645 xcb_parts_idx++;
7646 xcb_pad = 0;
7647 }
7648 xcb_block_len = 0;
7649 xcb_padding_offset = 0;
7650 }
7651 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
7652 /* insert padding */
7653 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7654 xcb_buffer_len += xcb_block_len + xcb_pad;
7655 if (0 != xcb_pad) {
7656 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7657 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7658 xcb_parts_idx++;
7659 xcb_pad = 0;
7660 }
7661 xcb_block_len = 0;
7662 xcb_padding_offset = 0;
7663 /* data32 */
7664 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
7665 xcb_block_len += num_items * sizeof(uint32_t);
7666 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
7667 xcb_parts_idx++;
7668 xcb_align_to = ALIGNOF(uint32_t);
7669 }
7670 /* insert padding */
7671 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7672 xcb_buffer_len += xcb_block_len + xcb_pad;
7673 if (0 != xcb_pad) {
7674 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7675 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7676 xcb_parts_idx++;
7677 xcb_pad = 0;
7678 }
7679 xcb_block_len = 0;
7680 xcb_padding_offset = 0;
7681
7682 if (NULL == xcb_out) {
7683 /* allocate memory */
7684 xcb_out = malloc(xcb_buffer_len);
7685 *_buffer = xcb_out;
7686 }
7687
7688 xcb_tmp = xcb_out;
7689 for(i=0; i<xcb_parts_idx; i++) {
7690 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
7691 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
7692 if (0 != xcb_parts[i].iov_len)
7693 xcb_tmp += xcb_parts[i].iov_len;
7694 }
7695
7696 return xcb_buffer_len;
7697 }
7698
7699 int
xcb_input_change_device_property_items_unpack(const void * _buffer,uint32_t num_items,uint8_t format,xcb_input_change_device_property_items_t * _aux)7700 xcb_input_change_device_property_items_unpack (const void *_buffer,
7701 uint32_t num_items,
7702 uint8_t format,
7703 xcb_input_change_device_property_items_t *_aux)
7704 {
7705 char *xcb_tmp = (char *)_buffer;
7706 unsigned int xcb_buffer_len = 0;
7707 unsigned int xcb_block_len = 0;
7708 unsigned int xcb_pad = 0;
7709 unsigned int xcb_align_to = 0;
7710 unsigned int xcb_padding_offset = 0;
7711
7712
7713 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
7714 /* insert padding */
7715 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7716 xcb_buffer_len += xcb_block_len + xcb_pad;
7717 if (0 != xcb_pad) {
7718 xcb_tmp += xcb_pad;
7719 xcb_pad = 0;
7720 }
7721 xcb_block_len = 0;
7722 xcb_padding_offset = 0;
7723 /* data8 */
7724 _aux->data8 = (uint8_t *)xcb_tmp;
7725 xcb_block_len += num_items * sizeof(uint8_t);
7726 xcb_tmp += xcb_block_len;
7727 xcb_align_to = ALIGNOF(uint8_t);
7728 xcb_align_to = 4;
7729 /* insert padding */
7730 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7731 xcb_buffer_len += xcb_block_len + xcb_pad;
7732 if (0 != xcb_pad) {
7733 xcb_tmp += xcb_pad;
7734 xcb_pad = 0;
7735 }
7736 xcb_block_len = 0;
7737 xcb_padding_offset = 0;
7738 }
7739 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
7740 /* insert padding */
7741 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7742 xcb_buffer_len += xcb_block_len + xcb_pad;
7743 if (0 != xcb_pad) {
7744 xcb_tmp += xcb_pad;
7745 xcb_pad = 0;
7746 }
7747 xcb_block_len = 0;
7748 xcb_padding_offset = 0;
7749 /* data16 */
7750 _aux->data16 = (uint16_t *)xcb_tmp;
7751 xcb_block_len += num_items * sizeof(uint16_t);
7752 xcb_tmp += xcb_block_len;
7753 xcb_align_to = ALIGNOF(uint16_t);
7754 xcb_align_to = 4;
7755 /* insert padding */
7756 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7757 xcb_buffer_len += xcb_block_len + xcb_pad;
7758 if (0 != xcb_pad) {
7759 xcb_tmp += xcb_pad;
7760 xcb_pad = 0;
7761 }
7762 xcb_block_len = 0;
7763 xcb_padding_offset = 0;
7764 }
7765 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
7766 /* insert padding */
7767 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7768 xcb_buffer_len += xcb_block_len + xcb_pad;
7769 if (0 != xcb_pad) {
7770 xcb_tmp += xcb_pad;
7771 xcb_pad = 0;
7772 }
7773 xcb_block_len = 0;
7774 xcb_padding_offset = 0;
7775 /* data32 */
7776 _aux->data32 = (uint32_t *)xcb_tmp;
7777 xcb_block_len += num_items * sizeof(uint32_t);
7778 xcb_tmp += xcb_block_len;
7779 xcb_align_to = ALIGNOF(uint32_t);
7780 }
7781 /* insert padding */
7782 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7783 xcb_buffer_len += xcb_block_len + xcb_pad;
7784 if (0 != xcb_pad) {
7785 xcb_tmp += xcb_pad;
7786 xcb_pad = 0;
7787 }
7788 xcb_block_len = 0;
7789 xcb_padding_offset = 0;
7790
7791 return xcb_buffer_len;
7792 }
7793
7794 int
xcb_input_change_device_property_items_sizeof(const void * _buffer,uint32_t num_items,uint8_t format)7795 xcb_input_change_device_property_items_sizeof (const void *_buffer,
7796 uint32_t num_items,
7797 uint8_t format)
7798 {
7799 xcb_input_change_device_property_items_t _aux;
7800 return xcb_input_change_device_property_items_unpack(_buffer, num_items, format, &_aux);
7801 }
7802
7803 int
xcb_input_change_device_property_sizeof(const void * _buffer)7804 xcb_input_change_device_property_sizeof (const void *_buffer)
7805 {
7806 char *xcb_tmp = (char *)_buffer;
7807 const xcb_input_change_device_property_request_t *_aux = (xcb_input_change_device_property_request_t *)_buffer;
7808 unsigned int xcb_buffer_len = 0;
7809 unsigned int xcb_block_len = 0;
7810 unsigned int xcb_pad = 0;
7811 unsigned int xcb_align_to = 0;
7812
7813
7814 xcb_block_len += sizeof(xcb_input_change_device_property_request_t);
7815 xcb_tmp += xcb_block_len;
7816 xcb_buffer_len += xcb_block_len;
7817 xcb_block_len = 0;
7818 /* items */
7819 xcb_block_len += xcb_input_change_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
7820 xcb_tmp += xcb_block_len;
7821 xcb_align_to = ALIGNOF(char);
7822 /* insert padding */
7823 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7824 xcb_buffer_len += xcb_block_len + xcb_pad;
7825 if (0 != xcb_pad) {
7826 xcb_tmp += xcb_pad;
7827 xcb_pad = 0;
7828 }
7829 xcb_block_len = 0;
7830
7831 return xcb_buffer_len;
7832 }
7833
7834 xcb_void_cookie_t
xcb_input_change_device_property_checked(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint8_t device_id,uint8_t format,uint8_t mode,uint32_t num_items,const void * items)7835 xcb_input_change_device_property_checked (xcb_connection_t *c,
7836 xcb_atom_t property,
7837 xcb_atom_t type,
7838 uint8_t device_id,
7839 uint8_t format,
7840 uint8_t mode,
7841 uint32_t num_items,
7842 const void *items)
7843 {
7844 static const xcb_protocol_request_t xcb_req = {
7845 .count = 3,
7846 .ext = &xcb_input_id,
7847 .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
7848 .isvoid = 1
7849 };
7850
7851 struct iovec xcb_parts[5];
7852 xcb_void_cookie_t xcb_ret;
7853 xcb_input_change_device_property_request_t xcb_out;
7854
7855 xcb_out.property = property;
7856 xcb_out.type = type;
7857 xcb_out.device_id = device_id;
7858 xcb_out.format = format;
7859 xcb_out.mode = mode;
7860 xcb_out.pad0 = 0;
7861 xcb_out.num_items = num_items;
7862
7863 xcb_parts[2].iov_base = (char *) &xcb_out;
7864 xcb_parts[2].iov_len = sizeof(xcb_out);
7865 xcb_parts[3].iov_base = 0;
7866 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7867 /* xcb_input_change_device_property_items_t items */
7868 xcb_parts[4].iov_base = (char *) items;
7869 xcb_parts[4].iov_len =
7870 xcb_input_change_device_property_items_sizeof (items, num_items, format);
7871
7872 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7873 return xcb_ret;
7874 }
7875
7876 xcb_void_cookie_t
xcb_input_change_device_property(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint8_t device_id,uint8_t format,uint8_t mode,uint32_t num_items,const void * items)7877 xcb_input_change_device_property (xcb_connection_t *c,
7878 xcb_atom_t property,
7879 xcb_atom_t type,
7880 uint8_t device_id,
7881 uint8_t format,
7882 uint8_t mode,
7883 uint32_t num_items,
7884 const void *items)
7885 {
7886 static const xcb_protocol_request_t xcb_req = {
7887 .count = 3,
7888 .ext = &xcb_input_id,
7889 .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
7890 .isvoid = 1
7891 };
7892
7893 struct iovec xcb_parts[5];
7894 xcb_void_cookie_t xcb_ret;
7895 xcb_input_change_device_property_request_t xcb_out;
7896
7897 xcb_out.property = property;
7898 xcb_out.type = type;
7899 xcb_out.device_id = device_id;
7900 xcb_out.format = format;
7901 xcb_out.mode = mode;
7902 xcb_out.pad0 = 0;
7903 xcb_out.num_items = num_items;
7904
7905 xcb_parts[2].iov_base = (char *) &xcb_out;
7906 xcb_parts[2].iov_len = sizeof(xcb_out);
7907 xcb_parts[3].iov_base = 0;
7908 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7909 /* xcb_input_change_device_property_items_t items */
7910 xcb_parts[4].iov_base = (char *) items;
7911 xcb_parts[4].iov_len =
7912 xcb_input_change_device_property_items_sizeof (items, num_items, format);
7913
7914 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7915 return xcb_ret;
7916 }
7917
7918 xcb_void_cookie_t
xcb_input_change_device_property_aux_checked(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint8_t device_id,uint8_t format,uint8_t mode,uint32_t num_items,const xcb_input_change_device_property_items_t * items)7919 xcb_input_change_device_property_aux_checked (xcb_connection_t *c,
7920 xcb_atom_t property,
7921 xcb_atom_t type,
7922 uint8_t device_id,
7923 uint8_t format,
7924 uint8_t mode,
7925 uint32_t num_items,
7926 const xcb_input_change_device_property_items_t *items)
7927 {
7928 static const xcb_protocol_request_t xcb_req = {
7929 .count = 3,
7930 .ext = &xcb_input_id,
7931 .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
7932 .isvoid = 1
7933 };
7934
7935 struct iovec xcb_parts[5];
7936 xcb_void_cookie_t xcb_ret;
7937 xcb_input_change_device_property_request_t xcb_out;
7938 void *xcb_aux0 = 0;
7939
7940 xcb_out.property = property;
7941 xcb_out.type = type;
7942 xcb_out.device_id = device_id;
7943 xcb_out.format = format;
7944 xcb_out.mode = mode;
7945 xcb_out.pad0 = 0;
7946 xcb_out.num_items = num_items;
7947
7948 xcb_parts[2].iov_base = (char *) &xcb_out;
7949 xcb_parts[2].iov_len = sizeof(xcb_out);
7950 xcb_parts[3].iov_base = 0;
7951 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7952 /* xcb_input_change_device_property_items_t items */
7953 xcb_parts[4].iov_len =
7954 xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items);
7955 xcb_parts[4].iov_base = xcb_aux0;
7956
7957 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7958 free(xcb_aux0);
7959 return xcb_ret;
7960 }
7961
7962 xcb_void_cookie_t
xcb_input_change_device_property_aux(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint8_t device_id,uint8_t format,uint8_t mode,uint32_t num_items,const xcb_input_change_device_property_items_t * items)7963 xcb_input_change_device_property_aux (xcb_connection_t *c,
7964 xcb_atom_t property,
7965 xcb_atom_t type,
7966 uint8_t device_id,
7967 uint8_t format,
7968 uint8_t mode,
7969 uint32_t num_items,
7970 const xcb_input_change_device_property_items_t *items)
7971 {
7972 static const xcb_protocol_request_t xcb_req = {
7973 .count = 3,
7974 .ext = &xcb_input_id,
7975 .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
7976 .isvoid = 1
7977 };
7978
7979 struct iovec xcb_parts[5];
7980 xcb_void_cookie_t xcb_ret;
7981 xcb_input_change_device_property_request_t xcb_out;
7982 void *xcb_aux0 = 0;
7983
7984 xcb_out.property = property;
7985 xcb_out.type = type;
7986 xcb_out.device_id = device_id;
7987 xcb_out.format = format;
7988 xcb_out.mode = mode;
7989 xcb_out.pad0 = 0;
7990 xcb_out.num_items = num_items;
7991
7992 xcb_parts[2].iov_base = (char *) &xcb_out;
7993 xcb_parts[2].iov_len = sizeof(xcb_out);
7994 xcb_parts[3].iov_base = 0;
7995 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7996 /* xcb_input_change_device_property_items_t items */
7997 xcb_parts[4].iov_len =
7998 xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items);
7999 xcb_parts[4].iov_base = xcb_aux0;
8000
8001 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8002 free(xcb_aux0);
8003 return xcb_ret;
8004 }
8005
8006 void *
xcb_input_change_device_property_items(const xcb_input_change_device_property_request_t * R)8007 xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R)
8008 {
8009 return (void *) (R + 1);
8010 }
8011
8012 xcb_void_cookie_t
xcb_input_delete_device_property_checked(xcb_connection_t * c,xcb_atom_t property,uint8_t device_id)8013 xcb_input_delete_device_property_checked (xcb_connection_t *c,
8014 xcb_atom_t property,
8015 uint8_t device_id)
8016 {
8017 static const xcb_protocol_request_t xcb_req = {
8018 .count = 2,
8019 .ext = &xcb_input_id,
8020 .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY,
8021 .isvoid = 1
8022 };
8023
8024 struct iovec xcb_parts[4];
8025 xcb_void_cookie_t xcb_ret;
8026 xcb_input_delete_device_property_request_t xcb_out;
8027
8028 xcb_out.property = property;
8029 xcb_out.device_id = device_id;
8030 memset(xcb_out.pad0, 0, 3);
8031
8032 xcb_parts[2].iov_base = (char *) &xcb_out;
8033 xcb_parts[2].iov_len = sizeof(xcb_out);
8034 xcb_parts[3].iov_base = 0;
8035 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8036
8037 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8038 return xcb_ret;
8039 }
8040
8041 xcb_void_cookie_t
xcb_input_delete_device_property(xcb_connection_t * c,xcb_atom_t property,uint8_t device_id)8042 xcb_input_delete_device_property (xcb_connection_t *c,
8043 xcb_atom_t property,
8044 uint8_t device_id)
8045 {
8046 static const xcb_protocol_request_t xcb_req = {
8047 .count = 2,
8048 .ext = &xcb_input_id,
8049 .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY,
8050 .isvoid = 1
8051 };
8052
8053 struct iovec xcb_parts[4];
8054 xcb_void_cookie_t xcb_ret;
8055 xcb_input_delete_device_property_request_t xcb_out;
8056
8057 xcb_out.property = property;
8058 xcb_out.device_id = device_id;
8059 memset(xcb_out.pad0, 0, 3);
8060
8061 xcb_parts[2].iov_base = (char *) &xcb_out;
8062 xcb_parts[2].iov_len = sizeof(xcb_out);
8063 xcb_parts[3].iov_base = 0;
8064 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8065
8066 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8067 return xcb_ret;
8068 }
8069
8070 uint8_t *
xcb_input_get_device_property_items_data_8(const xcb_input_get_device_property_items_t * S)8071 xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S)
8072 {
8073 return S->data8;
8074 }
8075
8076 int
xcb_input_get_device_property_items_data_8_length(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8077 xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R,
8078 const xcb_input_get_device_property_items_t *S)
8079 {
8080 return R->num_items;
8081 }
8082
8083 xcb_generic_iterator_t
xcb_input_get_device_property_items_data_8_end(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8084 xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R,
8085 const xcb_input_get_device_property_items_t *S)
8086 {
8087 xcb_generic_iterator_t i;
8088 i.data = S->data8 + R->num_items;
8089 i.rem = 0;
8090 i.index = (char *) i.data - (char *) S;
8091 return i;
8092 }
8093
8094 uint16_t *
xcb_input_get_device_property_items_data_16(const xcb_input_get_device_property_items_t * S)8095 xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S)
8096 {
8097 return S->data16;
8098 }
8099
8100 int
xcb_input_get_device_property_items_data_16_length(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8101 xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R,
8102 const xcb_input_get_device_property_items_t *S)
8103 {
8104 return R->num_items;
8105 }
8106
8107 xcb_generic_iterator_t
xcb_input_get_device_property_items_data_16_end(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8108 xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R,
8109 const xcb_input_get_device_property_items_t *S)
8110 {
8111 xcb_generic_iterator_t i;
8112 i.data = S->data16 + R->num_items;
8113 i.rem = 0;
8114 i.index = (char *) i.data - (char *) S;
8115 return i;
8116 }
8117
8118 uint32_t *
xcb_input_get_device_property_items_data_32(const xcb_input_get_device_property_items_t * S)8119 xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S)
8120 {
8121 return S->data32;
8122 }
8123
8124 int
xcb_input_get_device_property_items_data_32_length(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8125 xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R,
8126 const xcb_input_get_device_property_items_t *S)
8127 {
8128 return R->num_items;
8129 }
8130
8131 xcb_generic_iterator_t
xcb_input_get_device_property_items_data_32_end(const xcb_input_get_device_property_reply_t * R,const xcb_input_get_device_property_items_t * S)8132 xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R,
8133 const xcb_input_get_device_property_items_t *S)
8134 {
8135 xcb_generic_iterator_t i;
8136 i.data = S->data32 + R->num_items;
8137 i.rem = 0;
8138 i.index = (char *) i.data - (char *) S;
8139 return i;
8140 }
8141
8142 int
xcb_input_get_device_property_items_serialize(void ** _buffer,uint32_t num_items,uint8_t format,const xcb_input_get_device_property_items_t * _aux)8143 xcb_input_get_device_property_items_serialize (void **_buffer,
8144 uint32_t num_items,
8145 uint8_t format,
8146 const xcb_input_get_device_property_items_t *_aux)
8147 {
8148 char *xcb_out = *_buffer;
8149 unsigned int xcb_buffer_len = 0;
8150 unsigned int xcb_align_to = 0;
8151 unsigned int xcb_padding_offset = 0;
8152
8153 unsigned int xcb_pad = 0;
8154 char xcb_pad0[3] = {0, 0, 0};
8155 struct iovec xcb_parts[9];
8156 unsigned int xcb_parts_idx = 0;
8157 unsigned int xcb_block_len = 0;
8158 unsigned int i;
8159 char *xcb_tmp;
8160
8161 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
8162 /* insert padding */
8163 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8164 xcb_buffer_len += xcb_block_len + xcb_pad;
8165 if (0 != xcb_pad) {
8166 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8167 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8168 xcb_parts_idx++;
8169 xcb_pad = 0;
8170 }
8171 xcb_block_len = 0;
8172 xcb_padding_offset = 0;
8173 /* data8 */
8174 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
8175 xcb_block_len += num_items * sizeof(uint8_t);
8176 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
8177 xcb_parts_idx++;
8178 xcb_align_to = ALIGNOF(uint8_t);
8179 xcb_align_to = 4;
8180 /* insert padding */
8181 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8182 xcb_buffer_len += xcb_block_len + xcb_pad;
8183 if (0 != xcb_pad) {
8184 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8185 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8186 xcb_parts_idx++;
8187 xcb_pad = 0;
8188 }
8189 xcb_block_len = 0;
8190 xcb_padding_offset = 0;
8191 }
8192 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
8193 /* insert padding */
8194 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8195 xcb_buffer_len += xcb_block_len + xcb_pad;
8196 if (0 != xcb_pad) {
8197 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8198 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8199 xcb_parts_idx++;
8200 xcb_pad = 0;
8201 }
8202 xcb_block_len = 0;
8203 xcb_padding_offset = 0;
8204 /* data16 */
8205 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
8206 xcb_block_len += num_items * sizeof(uint16_t);
8207 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
8208 xcb_parts_idx++;
8209 xcb_align_to = ALIGNOF(uint16_t);
8210 xcb_align_to = 4;
8211 /* insert padding */
8212 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8213 xcb_buffer_len += xcb_block_len + xcb_pad;
8214 if (0 != xcb_pad) {
8215 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8216 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8217 xcb_parts_idx++;
8218 xcb_pad = 0;
8219 }
8220 xcb_block_len = 0;
8221 xcb_padding_offset = 0;
8222 }
8223 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
8224 /* insert padding */
8225 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8226 xcb_buffer_len += xcb_block_len + xcb_pad;
8227 if (0 != xcb_pad) {
8228 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8229 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8230 xcb_parts_idx++;
8231 xcb_pad = 0;
8232 }
8233 xcb_block_len = 0;
8234 xcb_padding_offset = 0;
8235 /* data32 */
8236 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
8237 xcb_block_len += num_items * sizeof(uint32_t);
8238 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
8239 xcb_parts_idx++;
8240 xcb_align_to = ALIGNOF(uint32_t);
8241 }
8242 /* insert padding */
8243 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8244 xcb_buffer_len += xcb_block_len + xcb_pad;
8245 if (0 != xcb_pad) {
8246 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8247 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8248 xcb_parts_idx++;
8249 xcb_pad = 0;
8250 }
8251 xcb_block_len = 0;
8252 xcb_padding_offset = 0;
8253
8254 if (NULL == xcb_out) {
8255 /* allocate memory */
8256 xcb_out = malloc(xcb_buffer_len);
8257 *_buffer = xcb_out;
8258 }
8259
8260 xcb_tmp = xcb_out;
8261 for(i=0; i<xcb_parts_idx; i++) {
8262 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
8263 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
8264 if (0 != xcb_parts[i].iov_len)
8265 xcb_tmp += xcb_parts[i].iov_len;
8266 }
8267
8268 return xcb_buffer_len;
8269 }
8270
8271 int
xcb_input_get_device_property_items_unpack(const void * _buffer,uint32_t num_items,uint8_t format,xcb_input_get_device_property_items_t * _aux)8272 xcb_input_get_device_property_items_unpack (const void *_buffer,
8273 uint32_t num_items,
8274 uint8_t format,
8275 xcb_input_get_device_property_items_t *_aux)
8276 {
8277 char *xcb_tmp = (char *)_buffer;
8278 unsigned int xcb_buffer_len = 0;
8279 unsigned int xcb_block_len = 0;
8280 unsigned int xcb_pad = 0;
8281 unsigned int xcb_align_to = 0;
8282 unsigned int xcb_padding_offset = 0;
8283
8284
8285 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
8286 /* insert padding */
8287 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8288 xcb_buffer_len += xcb_block_len + xcb_pad;
8289 if (0 != xcb_pad) {
8290 xcb_tmp += xcb_pad;
8291 xcb_pad = 0;
8292 }
8293 xcb_block_len = 0;
8294 xcb_padding_offset = 0;
8295 /* data8 */
8296 _aux->data8 = (uint8_t *)xcb_tmp;
8297 xcb_block_len += num_items * sizeof(uint8_t);
8298 xcb_tmp += xcb_block_len;
8299 xcb_align_to = ALIGNOF(uint8_t);
8300 xcb_align_to = 4;
8301 /* insert padding */
8302 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8303 xcb_buffer_len += xcb_block_len + xcb_pad;
8304 if (0 != xcb_pad) {
8305 xcb_tmp += xcb_pad;
8306 xcb_pad = 0;
8307 }
8308 xcb_block_len = 0;
8309 xcb_padding_offset = 0;
8310 }
8311 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
8312 /* insert padding */
8313 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8314 xcb_buffer_len += xcb_block_len + xcb_pad;
8315 if (0 != xcb_pad) {
8316 xcb_tmp += xcb_pad;
8317 xcb_pad = 0;
8318 }
8319 xcb_block_len = 0;
8320 xcb_padding_offset = 0;
8321 /* data16 */
8322 _aux->data16 = (uint16_t *)xcb_tmp;
8323 xcb_block_len += num_items * sizeof(uint16_t);
8324 xcb_tmp += xcb_block_len;
8325 xcb_align_to = ALIGNOF(uint16_t);
8326 xcb_align_to = 4;
8327 /* insert padding */
8328 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8329 xcb_buffer_len += xcb_block_len + xcb_pad;
8330 if (0 != xcb_pad) {
8331 xcb_tmp += xcb_pad;
8332 xcb_pad = 0;
8333 }
8334 xcb_block_len = 0;
8335 xcb_padding_offset = 0;
8336 }
8337 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
8338 /* insert padding */
8339 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8340 xcb_buffer_len += xcb_block_len + xcb_pad;
8341 if (0 != xcb_pad) {
8342 xcb_tmp += xcb_pad;
8343 xcb_pad = 0;
8344 }
8345 xcb_block_len = 0;
8346 xcb_padding_offset = 0;
8347 /* data32 */
8348 _aux->data32 = (uint32_t *)xcb_tmp;
8349 xcb_block_len += num_items * sizeof(uint32_t);
8350 xcb_tmp += xcb_block_len;
8351 xcb_align_to = ALIGNOF(uint32_t);
8352 }
8353 /* insert padding */
8354 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8355 xcb_buffer_len += xcb_block_len + xcb_pad;
8356 if (0 != xcb_pad) {
8357 xcb_tmp += xcb_pad;
8358 xcb_pad = 0;
8359 }
8360 xcb_block_len = 0;
8361 xcb_padding_offset = 0;
8362
8363 return xcb_buffer_len;
8364 }
8365
8366 int
xcb_input_get_device_property_items_sizeof(const void * _buffer,uint32_t num_items,uint8_t format)8367 xcb_input_get_device_property_items_sizeof (const void *_buffer,
8368 uint32_t num_items,
8369 uint8_t format)
8370 {
8371 xcb_input_get_device_property_items_t _aux;
8372 return xcb_input_get_device_property_items_unpack(_buffer, num_items, format, &_aux);
8373 }
8374
8375 int
xcb_input_get_device_property_sizeof(const void * _buffer)8376 xcb_input_get_device_property_sizeof (const void *_buffer)
8377 {
8378 char *xcb_tmp = (char *)_buffer;
8379 const xcb_input_get_device_property_reply_t *_aux = (xcb_input_get_device_property_reply_t *)_buffer;
8380 unsigned int xcb_buffer_len = 0;
8381 unsigned int xcb_block_len = 0;
8382 unsigned int xcb_pad = 0;
8383 unsigned int xcb_align_to = 0;
8384
8385
8386 xcb_block_len += sizeof(xcb_input_get_device_property_reply_t);
8387 xcb_tmp += xcb_block_len;
8388 xcb_buffer_len += xcb_block_len;
8389 xcb_block_len = 0;
8390 /* items */
8391 xcb_block_len += xcb_input_get_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
8392 xcb_tmp += xcb_block_len;
8393 xcb_align_to = ALIGNOF(char);
8394 /* insert padding */
8395 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8396 xcb_buffer_len += xcb_block_len + xcb_pad;
8397 if (0 != xcb_pad) {
8398 xcb_tmp += xcb_pad;
8399 xcb_pad = 0;
8400 }
8401 xcb_block_len = 0;
8402
8403 return xcb_buffer_len;
8404 }
8405
8406 xcb_input_get_device_property_cookie_t
xcb_input_get_device_property(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint32_t offset,uint32_t len,uint8_t device_id,uint8_t _delete)8407 xcb_input_get_device_property (xcb_connection_t *c,
8408 xcb_atom_t property,
8409 xcb_atom_t type,
8410 uint32_t offset,
8411 uint32_t len,
8412 uint8_t device_id,
8413 uint8_t _delete)
8414 {
8415 static const xcb_protocol_request_t xcb_req = {
8416 .count = 2,
8417 .ext = &xcb_input_id,
8418 .opcode = XCB_INPUT_GET_DEVICE_PROPERTY,
8419 .isvoid = 0
8420 };
8421
8422 struct iovec xcb_parts[4];
8423 xcb_input_get_device_property_cookie_t xcb_ret;
8424 xcb_input_get_device_property_request_t xcb_out;
8425
8426 xcb_out.property = property;
8427 xcb_out.type = type;
8428 xcb_out.offset = offset;
8429 xcb_out.len = len;
8430 xcb_out.device_id = device_id;
8431 xcb_out._delete = _delete;
8432 memset(xcb_out.pad0, 0, 2);
8433
8434 xcb_parts[2].iov_base = (char *) &xcb_out;
8435 xcb_parts[2].iov_len = sizeof(xcb_out);
8436 xcb_parts[3].iov_base = 0;
8437 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8438
8439 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8440 return xcb_ret;
8441 }
8442
8443 xcb_input_get_device_property_cookie_t
xcb_input_get_device_property_unchecked(xcb_connection_t * c,xcb_atom_t property,xcb_atom_t type,uint32_t offset,uint32_t len,uint8_t device_id,uint8_t _delete)8444 xcb_input_get_device_property_unchecked (xcb_connection_t *c,
8445 xcb_atom_t property,
8446 xcb_atom_t type,
8447 uint32_t offset,
8448 uint32_t len,
8449 uint8_t device_id,
8450 uint8_t _delete)
8451 {
8452 static const xcb_protocol_request_t xcb_req = {
8453 .count = 2,
8454 .ext = &xcb_input_id,
8455 .opcode = XCB_INPUT_GET_DEVICE_PROPERTY,
8456 .isvoid = 0
8457 };
8458
8459 struct iovec xcb_parts[4];
8460 xcb_input_get_device_property_cookie_t xcb_ret;
8461 xcb_input_get_device_property_request_t xcb_out;
8462
8463 xcb_out.property = property;
8464 xcb_out.type = type;
8465 xcb_out.offset = offset;
8466 xcb_out.len = len;
8467 xcb_out.device_id = device_id;
8468 xcb_out._delete = _delete;
8469 memset(xcb_out.pad0, 0, 2);
8470
8471 xcb_parts[2].iov_base = (char *) &xcb_out;
8472 xcb_parts[2].iov_len = sizeof(xcb_out);
8473 xcb_parts[3].iov_base = 0;
8474 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8475
8476 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8477 return xcb_ret;
8478 }
8479
8480 void *
xcb_input_get_device_property_items(const xcb_input_get_device_property_reply_t * R)8481 xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R)
8482 {
8483 return (void *) (R + 1);
8484 }
8485
8486 xcb_input_get_device_property_reply_t *
xcb_input_get_device_property_reply(xcb_connection_t * c,xcb_input_get_device_property_cookie_t cookie,xcb_generic_error_t ** e)8487 xcb_input_get_device_property_reply (xcb_connection_t *c,
8488 xcb_input_get_device_property_cookie_t cookie /**< */,
8489 xcb_generic_error_t **e)
8490 {
8491 return (xcb_input_get_device_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
8492 }
8493
8494 void
xcb_input_group_info_next(xcb_input_group_info_iterator_t * i)8495 xcb_input_group_info_next (xcb_input_group_info_iterator_t *i)
8496 {
8497 --i->rem;
8498 ++i->data;
8499 i->index += sizeof(xcb_input_group_info_t);
8500 }
8501
8502 xcb_generic_iterator_t
xcb_input_group_info_end(xcb_input_group_info_iterator_t i)8503 xcb_input_group_info_end (xcb_input_group_info_iterator_t i)
8504 {
8505 xcb_generic_iterator_t ret;
8506 ret.data = i.data + i.rem;
8507 ret.index = i.index + ((char *) ret.data - (char *) i.data);
8508 ret.rem = 0;
8509 return ret;
8510 }
8511
8512 void
xcb_input_modifier_info_next(xcb_input_modifier_info_iterator_t * i)8513 xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i)
8514 {
8515 --i->rem;
8516 ++i->data;
8517 i->index += sizeof(xcb_input_modifier_info_t);
8518 }
8519
8520 xcb_generic_iterator_t
xcb_input_modifier_info_end(xcb_input_modifier_info_iterator_t i)8521 xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i)
8522 {
8523 xcb_generic_iterator_t ret;
8524 ret.data = i.data + i.rem;
8525 ret.index = i.index + ((char *) ret.data - (char *) i.data);
8526 ret.rem = 0;
8527 return ret;
8528 }
8529
8530 int
xcb_input_xi_query_pointer_sizeof(const void * _buffer)8531 xcb_input_xi_query_pointer_sizeof (const void *_buffer)
8532 {
8533 char *xcb_tmp = (char *)_buffer;
8534 const xcb_input_xi_query_pointer_reply_t *_aux = (xcb_input_xi_query_pointer_reply_t *)_buffer;
8535 unsigned int xcb_buffer_len = 0;
8536 unsigned int xcb_block_len = 0;
8537 unsigned int xcb_pad = 0;
8538 unsigned int xcb_align_to = 0;
8539
8540
8541 xcb_block_len += sizeof(xcb_input_xi_query_pointer_reply_t);
8542 xcb_tmp += xcb_block_len;
8543 xcb_buffer_len += xcb_block_len;
8544 xcb_block_len = 0;
8545 /* buttons */
8546 xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
8547 xcb_tmp += xcb_block_len;
8548 xcb_align_to = ALIGNOF(uint32_t);
8549 /* insert padding */
8550 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8551 xcb_buffer_len += xcb_block_len + xcb_pad;
8552 if (0 != xcb_pad) {
8553 xcb_tmp += xcb_pad;
8554 xcb_pad = 0;
8555 }
8556 xcb_block_len = 0;
8557
8558 return xcb_buffer_len;
8559 }
8560
8561 xcb_input_xi_query_pointer_cookie_t
xcb_input_xi_query_pointer(xcb_connection_t * c,xcb_window_t window,xcb_input_device_id_t deviceid)8562 xcb_input_xi_query_pointer (xcb_connection_t *c,
8563 xcb_window_t window,
8564 xcb_input_device_id_t deviceid)
8565 {
8566 static const xcb_protocol_request_t xcb_req = {
8567 .count = 2,
8568 .ext = &xcb_input_id,
8569 .opcode = XCB_INPUT_XI_QUERY_POINTER,
8570 .isvoid = 0
8571 };
8572
8573 struct iovec xcb_parts[4];
8574 xcb_input_xi_query_pointer_cookie_t xcb_ret;
8575 xcb_input_xi_query_pointer_request_t xcb_out;
8576
8577 xcb_out.window = window;
8578 xcb_out.deviceid = deviceid;
8579 memset(xcb_out.pad0, 0, 2);
8580
8581 xcb_parts[2].iov_base = (char *) &xcb_out;
8582 xcb_parts[2].iov_len = sizeof(xcb_out);
8583 xcb_parts[3].iov_base = 0;
8584 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8585
8586 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8587 return xcb_ret;
8588 }
8589
8590 xcb_input_xi_query_pointer_cookie_t
xcb_input_xi_query_pointer_unchecked(xcb_connection_t * c,xcb_window_t window,xcb_input_device_id_t deviceid)8591 xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c,
8592 xcb_window_t window,
8593 xcb_input_device_id_t deviceid)
8594 {
8595 static const xcb_protocol_request_t xcb_req = {
8596 .count = 2,
8597 .ext = &xcb_input_id,
8598 .opcode = XCB_INPUT_XI_QUERY_POINTER,
8599 .isvoid = 0
8600 };
8601
8602 struct iovec xcb_parts[4];
8603 xcb_input_xi_query_pointer_cookie_t xcb_ret;
8604 xcb_input_xi_query_pointer_request_t xcb_out;
8605
8606 xcb_out.window = window;
8607 xcb_out.deviceid = deviceid;
8608 memset(xcb_out.pad0, 0, 2);
8609
8610 xcb_parts[2].iov_base = (char *) &xcb_out;
8611 xcb_parts[2].iov_len = sizeof(xcb_out);
8612 xcb_parts[3].iov_base = 0;
8613 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8614
8615 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8616 return xcb_ret;
8617 }
8618
8619 uint32_t *
xcb_input_xi_query_pointer_buttons(const xcb_input_xi_query_pointer_reply_t * R)8620 xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R)
8621 {
8622 return (uint32_t *) (R + 1);
8623 }
8624
8625 int
xcb_input_xi_query_pointer_buttons_length(const xcb_input_xi_query_pointer_reply_t * R)8626 xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R)
8627 {
8628 return R->buttons_len;
8629 }
8630
8631 xcb_generic_iterator_t
xcb_input_xi_query_pointer_buttons_end(const xcb_input_xi_query_pointer_reply_t * R)8632 xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R)
8633 {
8634 xcb_generic_iterator_t i;
8635 i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
8636 i.rem = 0;
8637 i.index = (char *) i.data - (char *) R;
8638 return i;
8639 }
8640
8641 xcb_input_xi_query_pointer_reply_t *
xcb_input_xi_query_pointer_reply(xcb_connection_t * c,xcb_input_xi_query_pointer_cookie_t cookie,xcb_generic_error_t ** e)8642 xcb_input_xi_query_pointer_reply (xcb_connection_t *c,
8643 xcb_input_xi_query_pointer_cookie_t cookie /**< */,
8644 xcb_generic_error_t **e)
8645 {
8646 return (xcb_input_xi_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
8647 }
8648
8649 xcb_void_cookie_t
xcb_input_xi_warp_pointer_checked(xcb_connection_t * c,xcb_window_t src_win,xcb_window_t dst_win,xcb_input_fp1616_t src_x,xcb_input_fp1616_t src_y,uint16_t src_width,uint16_t src_height,xcb_input_fp1616_t dst_x,xcb_input_fp1616_t dst_y,xcb_input_device_id_t deviceid)8650 xcb_input_xi_warp_pointer_checked (xcb_connection_t *c,
8651 xcb_window_t src_win,
8652 xcb_window_t dst_win,
8653 xcb_input_fp1616_t src_x,
8654 xcb_input_fp1616_t src_y,
8655 uint16_t src_width,
8656 uint16_t src_height,
8657 xcb_input_fp1616_t dst_x,
8658 xcb_input_fp1616_t dst_y,
8659 xcb_input_device_id_t deviceid)
8660 {
8661 static const xcb_protocol_request_t xcb_req = {
8662 .count = 2,
8663 .ext = &xcb_input_id,
8664 .opcode = XCB_INPUT_XI_WARP_POINTER,
8665 .isvoid = 1
8666 };
8667
8668 struct iovec xcb_parts[4];
8669 xcb_void_cookie_t xcb_ret;
8670 xcb_input_xi_warp_pointer_request_t xcb_out;
8671
8672 xcb_out.src_win = src_win;
8673 xcb_out.dst_win = dst_win;
8674 xcb_out.src_x = src_x;
8675 xcb_out.src_y = src_y;
8676 xcb_out.src_width = src_width;
8677 xcb_out.src_height = src_height;
8678 xcb_out.dst_x = dst_x;
8679 xcb_out.dst_y = dst_y;
8680 xcb_out.deviceid = deviceid;
8681 memset(xcb_out.pad0, 0, 2);
8682
8683 xcb_parts[2].iov_base = (char *) &xcb_out;
8684 xcb_parts[2].iov_len = sizeof(xcb_out);
8685 xcb_parts[3].iov_base = 0;
8686 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8687
8688 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8689 return xcb_ret;
8690 }
8691
8692 xcb_void_cookie_t
xcb_input_xi_warp_pointer(xcb_connection_t * c,xcb_window_t src_win,xcb_window_t dst_win,xcb_input_fp1616_t src_x,xcb_input_fp1616_t src_y,uint16_t src_width,uint16_t src_height,xcb_input_fp1616_t dst_x,xcb_input_fp1616_t dst_y,xcb_input_device_id_t deviceid)8693 xcb_input_xi_warp_pointer (xcb_connection_t *c,
8694 xcb_window_t src_win,
8695 xcb_window_t dst_win,
8696 xcb_input_fp1616_t src_x,
8697 xcb_input_fp1616_t src_y,
8698 uint16_t src_width,
8699 uint16_t src_height,
8700 xcb_input_fp1616_t dst_x,
8701 xcb_input_fp1616_t dst_y,
8702 xcb_input_device_id_t deviceid)
8703 {
8704 static const xcb_protocol_request_t xcb_req = {
8705 .count = 2,
8706 .ext = &xcb_input_id,
8707 .opcode = XCB_INPUT_XI_WARP_POINTER,
8708 .isvoid = 1
8709 };
8710
8711 struct iovec xcb_parts[4];
8712 xcb_void_cookie_t xcb_ret;
8713 xcb_input_xi_warp_pointer_request_t xcb_out;
8714
8715 xcb_out.src_win = src_win;
8716 xcb_out.dst_win = dst_win;
8717 xcb_out.src_x = src_x;
8718 xcb_out.src_y = src_y;
8719 xcb_out.src_width = src_width;
8720 xcb_out.src_height = src_height;
8721 xcb_out.dst_x = dst_x;
8722 xcb_out.dst_y = dst_y;
8723 xcb_out.deviceid = deviceid;
8724 memset(xcb_out.pad0, 0, 2);
8725
8726 xcb_parts[2].iov_base = (char *) &xcb_out;
8727 xcb_parts[2].iov_len = sizeof(xcb_out);
8728 xcb_parts[3].iov_base = 0;
8729 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8730
8731 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8732 return xcb_ret;
8733 }
8734
8735 xcb_void_cookie_t
xcb_input_xi_change_cursor_checked(xcb_connection_t * c,xcb_window_t window,xcb_cursor_t cursor,xcb_input_device_id_t deviceid)8736 xcb_input_xi_change_cursor_checked (xcb_connection_t *c,
8737 xcb_window_t window,
8738 xcb_cursor_t cursor,
8739 xcb_input_device_id_t deviceid)
8740 {
8741 static const xcb_protocol_request_t xcb_req = {
8742 .count = 2,
8743 .ext = &xcb_input_id,
8744 .opcode = XCB_INPUT_XI_CHANGE_CURSOR,
8745 .isvoid = 1
8746 };
8747
8748 struct iovec xcb_parts[4];
8749 xcb_void_cookie_t xcb_ret;
8750 xcb_input_xi_change_cursor_request_t xcb_out;
8751
8752 xcb_out.window = window;
8753 xcb_out.cursor = cursor;
8754 xcb_out.deviceid = deviceid;
8755 memset(xcb_out.pad0, 0, 2);
8756
8757 xcb_parts[2].iov_base = (char *) &xcb_out;
8758 xcb_parts[2].iov_len = sizeof(xcb_out);
8759 xcb_parts[3].iov_base = 0;
8760 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8761
8762 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
8763 return xcb_ret;
8764 }
8765
8766 xcb_void_cookie_t
xcb_input_xi_change_cursor(xcb_connection_t * c,xcb_window_t window,xcb_cursor_t cursor,xcb_input_device_id_t deviceid)8767 xcb_input_xi_change_cursor (xcb_connection_t *c,
8768 xcb_window_t window,
8769 xcb_cursor_t cursor,
8770 xcb_input_device_id_t deviceid)
8771 {
8772 static const xcb_protocol_request_t xcb_req = {
8773 .count = 2,
8774 .ext = &xcb_input_id,
8775 .opcode = XCB_INPUT_XI_CHANGE_CURSOR,
8776 .isvoid = 1
8777 };
8778
8779 struct iovec xcb_parts[4];
8780 xcb_void_cookie_t xcb_ret;
8781 xcb_input_xi_change_cursor_request_t xcb_out;
8782
8783 xcb_out.window = window;
8784 xcb_out.cursor = cursor;
8785 xcb_out.deviceid = deviceid;
8786 memset(xcb_out.pad0, 0, 2);
8787
8788 xcb_parts[2].iov_base = (char *) &xcb_out;
8789 xcb_parts[2].iov_len = sizeof(xcb_out);
8790 xcb_parts[3].iov_base = 0;
8791 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8792
8793 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8794 return xcb_ret;
8795 }
8796
8797 int
xcb_input_add_master_sizeof(const void * _buffer)8798 xcb_input_add_master_sizeof (const void *_buffer)
8799 {
8800 char *xcb_tmp = (char *)_buffer;
8801 const xcb_input_add_master_t *_aux = (xcb_input_add_master_t *)_buffer;
8802 unsigned int xcb_buffer_len = 0;
8803 unsigned int xcb_block_len = 0;
8804 unsigned int xcb_pad = 0;
8805 unsigned int xcb_align_to = 0;
8806
8807
8808 xcb_block_len += sizeof(xcb_input_add_master_t);
8809 xcb_tmp += xcb_block_len;
8810 xcb_buffer_len += xcb_block_len;
8811 xcb_block_len = 0;
8812 /* name */
8813 xcb_block_len += _aux->name_len * sizeof(char);
8814 xcb_tmp += xcb_block_len;
8815 xcb_align_to = ALIGNOF(char);
8816 xcb_align_to = 4;
8817 /* insert padding */
8818 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8819 xcb_buffer_len += xcb_block_len + xcb_pad;
8820 if (0 != xcb_pad) {
8821 xcb_tmp += xcb_pad;
8822 xcb_pad = 0;
8823 }
8824 xcb_block_len = 0;
8825 /* insert padding */
8826 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
8827 xcb_buffer_len += xcb_block_len + xcb_pad;
8828 if (0 != xcb_pad) {
8829 xcb_tmp += xcb_pad;
8830 xcb_pad = 0;
8831 }
8832 xcb_block_len = 0;
8833
8834 return xcb_buffer_len;
8835 }
8836
8837 char *
xcb_input_add_master_name(const xcb_input_add_master_t * R)8838 xcb_input_add_master_name (const xcb_input_add_master_t *R)
8839 {
8840 return (char *) (R + 1);
8841 }
8842
8843 int
xcb_input_add_master_name_length(const xcb_input_add_master_t * R)8844 xcb_input_add_master_name_length (const xcb_input_add_master_t *R)
8845 {
8846 return R->name_len;
8847 }
8848
8849 xcb_generic_iterator_t
xcb_input_add_master_name_end(const xcb_input_add_master_t * R)8850 xcb_input_add_master_name_end (const xcb_input_add_master_t *R)
8851 {
8852 xcb_generic_iterator_t i;
8853 i.data = ((char *) (R + 1)) + (R->name_len);
8854 i.rem = 0;
8855 i.index = (char *) i.data - (char *) R;
8856 return i;
8857 }
8858
8859 void
xcb_input_add_master_next(xcb_input_add_master_iterator_t * i)8860 xcb_input_add_master_next (xcb_input_add_master_iterator_t *i)
8861 {
8862 xcb_input_add_master_t *R = i->data;
8863 xcb_generic_iterator_t child;
8864 child.data = (xcb_input_add_master_t *)(((char *)R) + xcb_input_add_master_sizeof(R));
8865 i->index = (char *) child.data - (char *) i->data;
8866 --i->rem;
8867 i->data = (xcb_input_add_master_t *) child.data;
8868 }
8869
8870 xcb_generic_iterator_t
xcb_input_add_master_end(xcb_input_add_master_iterator_t i)8871 xcb_input_add_master_end (xcb_input_add_master_iterator_t i)
8872 {
8873 xcb_generic_iterator_t ret;
8874 while(i.rem > 0)
8875 xcb_input_add_master_next(&i);
8876 ret.data = i.data;
8877 ret.rem = i.rem;
8878 ret.index = i.index;
8879 return ret;
8880 }
8881
8882 void
xcb_input_remove_master_next(xcb_input_remove_master_iterator_t * i)8883 xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i)
8884 {
8885 --i->rem;
8886 ++i->data;
8887 i->index += sizeof(xcb_input_remove_master_t);
8888 }
8889
8890 xcb_generic_iterator_t
xcb_input_remove_master_end(xcb_input_remove_master_iterator_t i)8891 xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i)
8892 {
8893 xcb_generic_iterator_t ret;
8894 ret.data = i.data + i.rem;
8895 ret.index = i.index + ((char *) ret.data - (char *) i.data);
8896 ret.rem = 0;
8897 return ret;
8898 }
8899
8900 void
xcb_input_attach_slave_next(xcb_input_attach_slave_iterator_t * i)8901 xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i)
8902 {
8903 --i->rem;
8904 ++i->data;
8905 i->index += sizeof(xcb_input_attach_slave_t);
8906 }
8907
8908 xcb_generic_iterator_t
xcb_input_attach_slave_end(xcb_input_attach_slave_iterator_t i)8909 xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i)
8910 {
8911 xcb_generic_iterator_t ret;
8912 ret.data = i.data + i.rem;
8913 ret.index = i.index + ((char *) ret.data - (char *) i.data);
8914 ret.rem = 0;
8915 return ret;
8916 }
8917
8918 void
xcb_input_detach_slave_next(xcb_input_detach_slave_iterator_t * i)8919 xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i)
8920 {
8921 --i->rem;
8922 ++i->data;
8923 i->index += sizeof(xcb_input_detach_slave_t);
8924 }
8925
8926 xcb_generic_iterator_t
xcb_input_detach_slave_end(xcb_input_detach_slave_iterator_t i)8927 xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i)
8928 {
8929 xcb_generic_iterator_t ret;
8930 ret.data = i.data + i.rem;
8931 ret.index = i.index + ((char *) ret.data - (char *) i.data);
8932 ret.rem = 0;
8933 return ret;
8934 }
8935
8936 char *
xcb_input_hierarchy_change_data_add_master_name(const xcb_input_hierarchy_change_data_t * S)8937 xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S)
8938 {
8939 return S->add_master.name;
8940 }
8941
8942 int
xcb_input_hierarchy_change_data_add_master_name_length(const xcb_input_hierarchy_change_t * R,const xcb_input_hierarchy_change_data_t * S)8943 xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R,
8944 const xcb_input_hierarchy_change_data_t *S)
8945 {
8946 return S->add_master.name_len;
8947 }
8948
8949 xcb_generic_iterator_t
xcb_input_hierarchy_change_data_add_master_name_end(const xcb_input_hierarchy_change_t * R,const xcb_input_hierarchy_change_data_t * S)8950 xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R,
8951 const xcb_input_hierarchy_change_data_t *S)
8952 {
8953 xcb_generic_iterator_t i;
8954 i.data = S->add_master.name + S->add_master.name_len;
8955 i.rem = 0;
8956 i.index = (char *) i.data - (char *) S;
8957 return i;
8958 }
8959
8960 int
xcb_input_hierarchy_change_data_serialize(void ** _buffer,uint16_t type,const xcb_input_hierarchy_change_data_t * _aux)8961 xcb_input_hierarchy_change_data_serialize (void **_buffer,
8962 uint16_t type,
8963 const xcb_input_hierarchy_change_data_t *_aux)
8964 {
8965 char *xcb_out = *_buffer;
8966 unsigned int xcb_buffer_len = 0;
8967 unsigned int xcb_align_to = 0;
8968 unsigned int xcb_padding_offset = 0;
8969
8970 unsigned int xcb_pad = 0;
8971 char xcb_pad0[3] = {0, 0, 0};
8972 struct iovec xcb_parts[16];
8973 unsigned int xcb_parts_idx = 0;
8974 unsigned int xcb_block_len = 0;
8975 unsigned int i;
8976 char *xcb_tmp;
8977
8978 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) {
8979 /* xcb_input_hierarchy_change_data_t.add_master.name_len */
8980 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.name_len;
8981 xcb_block_len += sizeof(uint16_t);
8982 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
8983 xcb_parts_idx++;
8984 xcb_align_to = ALIGNOF(uint16_t);
8985 /* xcb_input_hierarchy_change_data_t.add_master.send_core */
8986 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.send_core;
8987 xcb_block_len += sizeof(uint8_t);
8988 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
8989 xcb_parts_idx++;
8990 xcb_align_to = ALIGNOF(uint8_t);
8991 /* xcb_input_hierarchy_change_data_t.add_master.enable */
8992 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.enable;
8993 xcb_block_len += sizeof(uint8_t);
8994 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
8995 xcb_parts_idx++;
8996 xcb_align_to = ALIGNOF(uint8_t);
8997 /* insert padding */
8998 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8999 xcb_buffer_len += xcb_block_len + xcb_pad;
9000 if (0 != xcb_pad) {
9001 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9002 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9003 xcb_parts_idx++;
9004 xcb_pad = 0;
9005 }
9006 xcb_block_len = 0;
9007 xcb_padding_offset = 0;
9008 /* name */
9009 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->add_master.name;
9010 xcb_block_len += _aux->add_master.name_len * sizeof(char);
9011 xcb_parts[xcb_parts_idx].iov_len = _aux->add_master.name_len * sizeof(char);
9012 xcb_parts_idx++;
9013 xcb_align_to = ALIGNOF(char);
9014 xcb_align_to = 4;
9015 /* insert padding */
9016 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9017 xcb_buffer_len += xcb_block_len + xcb_pad;
9018 if (0 != xcb_pad) {
9019 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9020 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9021 xcb_parts_idx++;
9022 xcb_pad = 0;
9023 }
9024 xcb_block_len = 0;
9025 xcb_padding_offset = 0;
9026 }
9027 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) {
9028 /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */
9029 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.deviceid;
9030 xcb_block_len += sizeof(xcb_input_device_id_t);
9031 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9032 xcb_parts_idx++;
9033 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9034 /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */
9035 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_mode;
9036 xcb_block_len += sizeof(uint8_t);
9037 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9038 xcb_parts_idx++;
9039 xcb_align_to = ALIGNOF(uint8_t);
9040 /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */
9041 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
9042 xcb_block_len += sizeof(uint8_t);
9043 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9044 xcb_parts_idx++;
9045 xcb_align_to = ALIGNOF(uint8_t);
9046 /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */
9047 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_pointer;
9048 xcb_block_len += sizeof(xcb_input_device_id_t);
9049 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9050 xcb_parts_idx++;
9051 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9052 /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */
9053 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_keyboard;
9054 xcb_block_len += sizeof(xcb_input_device_id_t);
9055 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9056 xcb_parts_idx++;
9057 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9058 }
9059 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) {
9060 /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */
9061 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.deviceid;
9062 xcb_block_len += sizeof(xcb_input_device_id_t);
9063 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9064 xcb_parts_idx++;
9065 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9066 /* xcb_input_hierarchy_change_data_t.attach_slave.master */
9067 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.master;
9068 xcb_block_len += sizeof(xcb_input_device_id_t);
9069 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9070 xcb_parts_idx++;
9071 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9072 }
9073 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) {
9074 /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */
9075 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->detach_slave.deviceid;
9076 xcb_block_len += sizeof(xcb_input_device_id_t);
9077 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
9078 xcb_parts_idx++;
9079 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9080 /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */
9081 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9082 xcb_block_len += sizeof(uint8_t)*2;
9083 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
9084 xcb_parts_idx++;
9085 xcb_align_to = ALIGNOF(uint8_t);
9086 }
9087 /* insert padding */
9088 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9089 xcb_buffer_len += xcb_block_len + xcb_pad;
9090 if (0 != xcb_pad) {
9091 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9092 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9093 xcb_parts_idx++;
9094 xcb_pad = 0;
9095 }
9096 xcb_block_len = 0;
9097 xcb_padding_offset = 0;
9098
9099 if (NULL == xcb_out) {
9100 /* allocate memory */
9101 xcb_out = malloc(xcb_buffer_len);
9102 *_buffer = xcb_out;
9103 }
9104
9105 xcb_tmp = xcb_out;
9106 for(i=0; i<xcb_parts_idx; i++) {
9107 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
9108 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
9109 if (0 != xcb_parts[i].iov_len)
9110 xcb_tmp += xcb_parts[i].iov_len;
9111 }
9112
9113 return xcb_buffer_len;
9114 }
9115
9116 int
xcb_input_hierarchy_change_data_unpack(const void * _buffer,uint16_t type,xcb_input_hierarchy_change_data_t * _aux)9117 xcb_input_hierarchy_change_data_unpack (const void *_buffer,
9118 uint16_t type,
9119 xcb_input_hierarchy_change_data_t *_aux)
9120 {
9121 char *xcb_tmp = (char *)_buffer;
9122 unsigned int xcb_buffer_len = 0;
9123 unsigned int xcb_block_len = 0;
9124 unsigned int xcb_pad = 0;
9125 unsigned int xcb_align_to = 0;
9126 unsigned int xcb_padding_offset = 0;
9127
9128
9129 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) {
9130 /* xcb_input_hierarchy_change_data_t.add_master.name_len */
9131 _aux->add_master.name_len = *(uint16_t *)xcb_tmp;
9132 xcb_block_len += sizeof(uint16_t);
9133 xcb_tmp += sizeof(uint16_t);
9134 xcb_align_to = ALIGNOF(uint16_t);
9135 /* xcb_input_hierarchy_change_data_t.add_master.send_core */
9136 _aux->add_master.send_core = *(uint8_t *)xcb_tmp;
9137 xcb_block_len += sizeof(uint8_t);
9138 xcb_tmp += sizeof(uint8_t);
9139 xcb_align_to = ALIGNOF(uint8_t);
9140 /* xcb_input_hierarchy_change_data_t.add_master.enable */
9141 _aux->add_master.enable = *(uint8_t *)xcb_tmp;
9142 xcb_block_len += sizeof(uint8_t);
9143 xcb_tmp += sizeof(uint8_t);
9144 xcb_align_to = ALIGNOF(uint8_t);
9145 /* insert padding */
9146 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9147 xcb_buffer_len += xcb_block_len + xcb_pad;
9148 if (0 != xcb_pad) {
9149 xcb_tmp += xcb_pad;
9150 xcb_pad = 0;
9151 }
9152 xcb_block_len = 0;
9153 xcb_padding_offset = 0;
9154 /* name */
9155 _aux->add_master.name = (char *)xcb_tmp;
9156 xcb_block_len += _aux->add_master.name_len * sizeof(char);
9157 xcb_tmp += xcb_block_len;
9158 xcb_align_to = ALIGNOF(char);
9159 xcb_align_to = 4;
9160 /* insert padding */
9161 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9162 xcb_buffer_len += xcb_block_len + xcb_pad;
9163 if (0 != xcb_pad) {
9164 xcb_tmp += xcb_pad;
9165 xcb_pad = 0;
9166 }
9167 xcb_block_len = 0;
9168 xcb_padding_offset = 0;
9169 }
9170 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) {
9171 /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */
9172 _aux->remove_master.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
9173 xcb_block_len += sizeof(xcb_input_device_id_t);
9174 xcb_tmp += sizeof(xcb_input_device_id_t);
9175 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9176 /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */
9177 _aux->remove_master.return_mode = *(uint8_t *)xcb_tmp;
9178 xcb_block_len += sizeof(uint8_t);
9179 xcb_tmp += sizeof(uint8_t);
9180 xcb_align_to = ALIGNOF(uint8_t);
9181 /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */
9182 _aux->remove_master.pad1 = *(uint8_t *)xcb_tmp;
9183 xcb_block_len += sizeof(uint8_t);
9184 xcb_tmp += sizeof(uint8_t);
9185 xcb_align_to = ALIGNOF(uint8_t);
9186 /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */
9187 _aux->remove_master.return_pointer = *(xcb_input_device_id_t *)xcb_tmp;
9188 xcb_block_len += sizeof(xcb_input_device_id_t);
9189 xcb_tmp += sizeof(xcb_input_device_id_t);
9190 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9191 /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */
9192 _aux->remove_master.return_keyboard = *(xcb_input_device_id_t *)xcb_tmp;
9193 xcb_block_len += sizeof(xcb_input_device_id_t);
9194 xcb_tmp += sizeof(xcb_input_device_id_t);
9195 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9196 }
9197 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) {
9198 /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */
9199 _aux->attach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
9200 xcb_block_len += sizeof(xcb_input_device_id_t);
9201 xcb_tmp += sizeof(xcb_input_device_id_t);
9202 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9203 /* xcb_input_hierarchy_change_data_t.attach_slave.master */
9204 _aux->attach_slave.master = *(xcb_input_device_id_t *)xcb_tmp;
9205 xcb_block_len += sizeof(xcb_input_device_id_t);
9206 xcb_tmp += sizeof(xcb_input_device_id_t);
9207 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9208 }
9209 if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) {
9210 /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */
9211 _aux->detach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
9212 xcb_block_len += sizeof(xcb_input_device_id_t);
9213 xcb_tmp += sizeof(xcb_input_device_id_t);
9214 xcb_align_to = ALIGNOF(xcb_input_device_id_t);
9215 /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */
9216 _aux->detach_slave.pad2[0] = *(uint8_t *)xcb_tmp;
9217 _aux->detach_slave.pad2[1] = *(uint8_t *)xcb_tmp;
9218 xcb_block_len += sizeof(uint8_t) * 2;
9219 xcb_tmp += sizeof(uint8_t) * 2;
9220 xcb_align_to = ALIGNOF(uint8_t);
9221 }
9222 /* insert padding */
9223 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9224 xcb_buffer_len += xcb_block_len + xcb_pad;
9225 if (0 != xcb_pad) {
9226 xcb_tmp += xcb_pad;
9227 xcb_pad = 0;
9228 }
9229 xcb_block_len = 0;
9230 xcb_padding_offset = 0;
9231
9232 return xcb_buffer_len;
9233 }
9234
9235 int
xcb_input_hierarchy_change_data_sizeof(const void * _buffer,uint16_t type)9236 xcb_input_hierarchy_change_data_sizeof (const void *_buffer,
9237 uint16_t type)
9238 {
9239 xcb_input_hierarchy_change_data_t _aux;
9240 return xcb_input_hierarchy_change_data_unpack(_buffer, type, &_aux);
9241 }
9242
9243 int
xcb_input_hierarchy_change_sizeof(const void * _buffer)9244 xcb_input_hierarchy_change_sizeof (const void *_buffer)
9245 {
9246 char *xcb_tmp = (char *)_buffer;
9247 const xcb_input_hierarchy_change_t *_aux = (xcb_input_hierarchy_change_t *)_buffer;
9248 unsigned int xcb_buffer_len = 0;
9249 unsigned int xcb_block_len = 0;
9250 unsigned int xcb_pad = 0;
9251 unsigned int xcb_align_to = 0;
9252
9253
9254 xcb_block_len += sizeof(xcb_input_hierarchy_change_t);
9255 xcb_tmp += xcb_block_len;
9256 xcb_buffer_len += xcb_block_len;
9257 xcb_block_len = 0;
9258 /* data */
9259 xcb_block_len += xcb_input_hierarchy_change_data_sizeof(xcb_tmp, _aux->type);
9260 xcb_tmp += xcb_block_len;
9261 xcb_align_to = ALIGNOF(char);
9262 /* insert padding */
9263 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9264 xcb_buffer_len += xcb_block_len + xcb_pad;
9265 if (0 != xcb_pad) {
9266 xcb_tmp += xcb_pad;
9267 xcb_pad = 0;
9268 }
9269 xcb_block_len = 0;
9270
9271 return xcb_buffer_len;
9272 }
9273
9274 void *
xcb_input_hierarchy_change_data(const xcb_input_hierarchy_change_t * R)9275 xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R)
9276 {
9277 return (void *) (R + 1);
9278 }
9279
9280 void
xcb_input_hierarchy_change_next(xcb_input_hierarchy_change_iterator_t * i)9281 xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i)
9282 {
9283 xcb_input_hierarchy_change_t *R = i->data;
9284 xcb_generic_iterator_t child;
9285 child.data = (xcb_input_hierarchy_change_t *)(((char *)R) + xcb_input_hierarchy_change_sizeof(R));
9286 i->index = (char *) child.data - (char *) i->data;
9287 --i->rem;
9288 i->data = (xcb_input_hierarchy_change_t *) child.data;
9289 }
9290
9291 xcb_generic_iterator_t
xcb_input_hierarchy_change_end(xcb_input_hierarchy_change_iterator_t i)9292 xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i)
9293 {
9294 xcb_generic_iterator_t ret;
9295 while(i.rem > 0)
9296 xcb_input_hierarchy_change_next(&i);
9297 ret.data = i.data;
9298 ret.rem = i.rem;
9299 ret.index = i.index;
9300 return ret;
9301 }
9302
9303 int
xcb_input_xi_change_hierarchy_sizeof(const void * _buffer)9304 xcb_input_xi_change_hierarchy_sizeof (const void *_buffer)
9305 {
9306 char *xcb_tmp = (char *)_buffer;
9307 const xcb_input_xi_change_hierarchy_request_t *_aux = (xcb_input_xi_change_hierarchy_request_t *)_buffer;
9308 unsigned int xcb_buffer_len = 0;
9309 unsigned int xcb_block_len = 0;
9310 unsigned int xcb_pad = 0;
9311 unsigned int xcb_align_to = 0;
9312
9313 unsigned int i;
9314 unsigned int xcb_tmp_len;
9315
9316 xcb_block_len += sizeof(xcb_input_xi_change_hierarchy_request_t);
9317 xcb_tmp += xcb_block_len;
9318 xcb_buffer_len += xcb_block_len;
9319 xcb_block_len = 0;
9320 /* changes */
9321 for(i=0; i<_aux->num_changes; i++) {
9322 xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
9323 xcb_block_len += xcb_tmp_len;
9324 xcb_tmp += xcb_tmp_len;
9325 }
9326 xcb_align_to = ALIGNOF(xcb_input_hierarchy_change_t);
9327 /* insert padding */
9328 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9329 xcb_buffer_len += xcb_block_len + xcb_pad;
9330 if (0 != xcb_pad) {
9331 xcb_tmp += xcb_pad;
9332 xcb_pad = 0;
9333 }
9334 xcb_block_len = 0;
9335
9336 return xcb_buffer_len;
9337 }
9338
9339 xcb_void_cookie_t
xcb_input_xi_change_hierarchy_checked(xcb_connection_t * c,uint8_t num_changes,const xcb_input_hierarchy_change_t * changes)9340 xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c,
9341 uint8_t num_changes,
9342 const xcb_input_hierarchy_change_t *changes)
9343 {
9344 static const xcb_protocol_request_t xcb_req = {
9345 .count = 4,
9346 .ext = &xcb_input_id,
9347 .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY,
9348 .isvoid = 1
9349 };
9350
9351 struct iovec xcb_parts[6];
9352 xcb_void_cookie_t xcb_ret;
9353 xcb_input_xi_change_hierarchy_request_t xcb_out;
9354 unsigned int xcb_tmp_len;
9355 char *xcb_tmp;
9356 unsigned int i;
9357
9358 xcb_out.num_changes = num_changes;
9359 memset(xcb_out.pad0, 0, 3);
9360
9361 xcb_parts[2].iov_base = (char *) &xcb_out;
9362 xcb_parts[2].iov_len = sizeof(xcb_out);
9363 xcb_parts[3].iov_base = 0;
9364 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9365 /* xcb_input_hierarchy_change_t changes */
9366 xcb_parts[4].iov_base = (char *) changes;
9367 xcb_parts[4].iov_len = 0;
9368 xcb_tmp = (char *)changes;
9369 for(i=0; i<num_changes; i++) {
9370 xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
9371 xcb_parts[4].iov_len += xcb_tmp_len;
9372 xcb_tmp += xcb_tmp_len;
9373 }
9374 xcb_parts[5].iov_base = 0;
9375 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9376
9377 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9378 return xcb_ret;
9379 }
9380
9381 xcb_void_cookie_t
xcb_input_xi_change_hierarchy(xcb_connection_t * c,uint8_t num_changes,const xcb_input_hierarchy_change_t * changes)9382 xcb_input_xi_change_hierarchy (xcb_connection_t *c,
9383 uint8_t num_changes,
9384 const xcb_input_hierarchy_change_t *changes)
9385 {
9386 static const xcb_protocol_request_t xcb_req = {
9387 .count = 4,
9388 .ext = &xcb_input_id,
9389 .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY,
9390 .isvoid = 1
9391 };
9392
9393 struct iovec xcb_parts[6];
9394 xcb_void_cookie_t xcb_ret;
9395 xcb_input_xi_change_hierarchy_request_t xcb_out;
9396 unsigned int xcb_tmp_len;
9397 char *xcb_tmp;
9398 unsigned int i;
9399
9400 xcb_out.num_changes = num_changes;
9401 memset(xcb_out.pad0, 0, 3);
9402
9403 xcb_parts[2].iov_base = (char *) &xcb_out;
9404 xcb_parts[2].iov_len = sizeof(xcb_out);
9405 xcb_parts[3].iov_base = 0;
9406 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9407 /* xcb_input_hierarchy_change_t changes */
9408 xcb_parts[4].iov_base = (char *) changes;
9409 xcb_parts[4].iov_len = 0;
9410 xcb_tmp = (char *)changes;
9411 for(i=0; i<num_changes; i++) {
9412 xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
9413 xcb_parts[4].iov_len += xcb_tmp_len;
9414 xcb_tmp += xcb_tmp_len;
9415 }
9416 xcb_parts[5].iov_base = 0;
9417 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9418
9419 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9420 return xcb_ret;
9421 }
9422
9423 int
xcb_input_xi_change_hierarchy_changes_length(const xcb_input_xi_change_hierarchy_request_t * R)9424 xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R)
9425 {
9426 return R->num_changes;
9427 }
9428
9429 xcb_input_hierarchy_change_iterator_t
xcb_input_xi_change_hierarchy_changes_iterator(const xcb_input_xi_change_hierarchy_request_t * R)9430 xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R)
9431 {
9432 xcb_input_hierarchy_change_iterator_t i;
9433 i.data = (xcb_input_hierarchy_change_t *) (R + 1);
9434 i.rem = R->num_changes;
9435 i.index = (char *) i.data - (char *) R;
9436 return i;
9437 }
9438
9439 xcb_void_cookie_t
xcb_input_xi_set_client_pointer_checked(xcb_connection_t * c,xcb_window_t window,xcb_input_device_id_t deviceid)9440 xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c,
9441 xcb_window_t window,
9442 xcb_input_device_id_t deviceid)
9443 {
9444 static const xcb_protocol_request_t xcb_req = {
9445 .count = 2,
9446 .ext = &xcb_input_id,
9447 .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER,
9448 .isvoid = 1
9449 };
9450
9451 struct iovec xcb_parts[4];
9452 xcb_void_cookie_t xcb_ret;
9453 xcb_input_xi_set_client_pointer_request_t xcb_out;
9454
9455 xcb_out.window = window;
9456 xcb_out.deviceid = deviceid;
9457 memset(xcb_out.pad0, 0, 2);
9458
9459 xcb_parts[2].iov_base = (char *) &xcb_out;
9460 xcb_parts[2].iov_len = sizeof(xcb_out);
9461 xcb_parts[3].iov_base = 0;
9462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9463
9464 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9465 return xcb_ret;
9466 }
9467
9468 xcb_void_cookie_t
xcb_input_xi_set_client_pointer(xcb_connection_t * c,xcb_window_t window,xcb_input_device_id_t deviceid)9469 xcb_input_xi_set_client_pointer (xcb_connection_t *c,
9470 xcb_window_t window,
9471 xcb_input_device_id_t deviceid)
9472 {
9473 static const xcb_protocol_request_t xcb_req = {
9474 .count = 2,
9475 .ext = &xcb_input_id,
9476 .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER,
9477 .isvoid = 1
9478 };
9479
9480 struct iovec xcb_parts[4];
9481 xcb_void_cookie_t xcb_ret;
9482 xcb_input_xi_set_client_pointer_request_t xcb_out;
9483
9484 xcb_out.window = window;
9485 xcb_out.deviceid = deviceid;
9486 memset(xcb_out.pad0, 0, 2);
9487
9488 xcb_parts[2].iov_base = (char *) &xcb_out;
9489 xcb_parts[2].iov_len = sizeof(xcb_out);
9490 xcb_parts[3].iov_base = 0;
9491 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9492
9493 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9494 return xcb_ret;
9495 }
9496
9497 xcb_input_xi_get_client_pointer_cookie_t
xcb_input_xi_get_client_pointer(xcb_connection_t * c,xcb_window_t window)9498 xcb_input_xi_get_client_pointer (xcb_connection_t *c,
9499 xcb_window_t window)
9500 {
9501 static const xcb_protocol_request_t xcb_req = {
9502 .count = 2,
9503 .ext = &xcb_input_id,
9504 .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER,
9505 .isvoid = 0
9506 };
9507
9508 struct iovec xcb_parts[4];
9509 xcb_input_xi_get_client_pointer_cookie_t xcb_ret;
9510 xcb_input_xi_get_client_pointer_request_t xcb_out;
9511
9512 xcb_out.window = window;
9513
9514 xcb_parts[2].iov_base = (char *) &xcb_out;
9515 xcb_parts[2].iov_len = sizeof(xcb_out);
9516 xcb_parts[3].iov_base = 0;
9517 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9518
9519 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9520 return xcb_ret;
9521 }
9522
9523 xcb_input_xi_get_client_pointer_cookie_t
xcb_input_xi_get_client_pointer_unchecked(xcb_connection_t * c,xcb_window_t window)9524 xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c,
9525 xcb_window_t window)
9526 {
9527 static const xcb_protocol_request_t xcb_req = {
9528 .count = 2,
9529 .ext = &xcb_input_id,
9530 .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER,
9531 .isvoid = 0
9532 };
9533
9534 struct iovec xcb_parts[4];
9535 xcb_input_xi_get_client_pointer_cookie_t xcb_ret;
9536 xcb_input_xi_get_client_pointer_request_t xcb_out;
9537
9538 xcb_out.window = window;
9539
9540 xcb_parts[2].iov_base = (char *) &xcb_out;
9541 xcb_parts[2].iov_len = sizeof(xcb_out);
9542 xcb_parts[3].iov_base = 0;
9543 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9544
9545 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9546 return xcb_ret;
9547 }
9548
9549 xcb_input_xi_get_client_pointer_reply_t *
xcb_input_xi_get_client_pointer_reply(xcb_connection_t * c,xcb_input_xi_get_client_pointer_cookie_t cookie,xcb_generic_error_t ** e)9550 xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c,
9551 xcb_input_xi_get_client_pointer_cookie_t cookie /**< */,
9552 xcb_generic_error_t **e)
9553 {
9554 return (xcb_input_xi_get_client_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
9555 }
9556
9557 int
xcb_input_event_mask_sizeof(const void * _buffer)9558 xcb_input_event_mask_sizeof (const void *_buffer)
9559 {
9560 char *xcb_tmp = (char *)_buffer;
9561 const xcb_input_event_mask_t *_aux = (xcb_input_event_mask_t *)_buffer;
9562 unsigned int xcb_buffer_len = 0;
9563 unsigned int xcb_block_len = 0;
9564 unsigned int xcb_pad = 0;
9565 unsigned int xcb_align_to = 0;
9566
9567
9568 xcb_block_len += sizeof(xcb_input_event_mask_t);
9569 xcb_tmp += xcb_block_len;
9570 xcb_buffer_len += xcb_block_len;
9571 xcb_block_len = 0;
9572 /* mask */
9573 xcb_block_len += _aux->mask_len * sizeof(uint32_t);
9574 xcb_tmp += xcb_block_len;
9575 xcb_align_to = ALIGNOF(uint32_t);
9576 /* insert padding */
9577 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9578 xcb_buffer_len += xcb_block_len + xcb_pad;
9579 if (0 != xcb_pad) {
9580 xcb_tmp += xcb_pad;
9581 xcb_pad = 0;
9582 }
9583 xcb_block_len = 0;
9584
9585 return xcb_buffer_len;
9586 }
9587
9588 uint32_t *
xcb_input_event_mask_mask(const xcb_input_event_mask_t * R)9589 xcb_input_event_mask_mask (const xcb_input_event_mask_t *R)
9590 {
9591 return (uint32_t *) (R + 1);
9592 }
9593
9594 int
xcb_input_event_mask_mask_length(const xcb_input_event_mask_t * R)9595 xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R)
9596 {
9597 return R->mask_len;
9598 }
9599
9600 xcb_generic_iterator_t
xcb_input_event_mask_mask_end(const xcb_input_event_mask_t * R)9601 xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R)
9602 {
9603 xcb_generic_iterator_t i;
9604 i.data = ((uint32_t *) (R + 1)) + (R->mask_len);
9605 i.rem = 0;
9606 i.index = (char *) i.data - (char *) R;
9607 return i;
9608 }
9609
9610 void
xcb_input_event_mask_next(xcb_input_event_mask_iterator_t * i)9611 xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i)
9612 {
9613 xcb_input_event_mask_t *R = i->data;
9614 xcb_generic_iterator_t child;
9615 child.data = (xcb_input_event_mask_t *)(((char *)R) + xcb_input_event_mask_sizeof(R));
9616 i->index = (char *) child.data - (char *) i->data;
9617 --i->rem;
9618 i->data = (xcb_input_event_mask_t *) child.data;
9619 }
9620
9621 xcb_generic_iterator_t
xcb_input_event_mask_end(xcb_input_event_mask_iterator_t i)9622 xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i)
9623 {
9624 xcb_generic_iterator_t ret;
9625 while(i.rem > 0)
9626 xcb_input_event_mask_next(&i);
9627 ret.data = i.data;
9628 ret.rem = i.rem;
9629 ret.index = i.index;
9630 return ret;
9631 }
9632
9633 int
xcb_input_xi_select_events_sizeof(const void * _buffer)9634 xcb_input_xi_select_events_sizeof (const void *_buffer)
9635 {
9636 char *xcb_tmp = (char *)_buffer;
9637 const xcb_input_xi_select_events_request_t *_aux = (xcb_input_xi_select_events_request_t *)_buffer;
9638 unsigned int xcb_buffer_len = 0;
9639 unsigned int xcb_block_len = 0;
9640 unsigned int xcb_pad = 0;
9641 unsigned int xcb_align_to = 0;
9642
9643 unsigned int i;
9644 unsigned int xcb_tmp_len;
9645
9646 xcb_block_len += sizeof(xcb_input_xi_select_events_request_t);
9647 xcb_tmp += xcb_block_len;
9648 xcb_buffer_len += xcb_block_len;
9649 xcb_block_len = 0;
9650 /* masks */
9651 for(i=0; i<_aux->num_mask; i++) {
9652 xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
9653 xcb_block_len += xcb_tmp_len;
9654 xcb_tmp += xcb_tmp_len;
9655 }
9656 xcb_align_to = ALIGNOF(xcb_input_event_mask_t);
9657 /* insert padding */
9658 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9659 xcb_buffer_len += xcb_block_len + xcb_pad;
9660 if (0 != xcb_pad) {
9661 xcb_tmp += xcb_pad;
9662 xcb_pad = 0;
9663 }
9664 xcb_block_len = 0;
9665
9666 return xcb_buffer_len;
9667 }
9668
9669 xcb_void_cookie_t
xcb_input_xi_select_events_checked(xcb_connection_t * c,xcb_window_t window,uint16_t num_mask,const xcb_input_event_mask_t * masks)9670 xcb_input_xi_select_events_checked (xcb_connection_t *c,
9671 xcb_window_t window,
9672 uint16_t num_mask,
9673 const xcb_input_event_mask_t *masks)
9674 {
9675 static const xcb_protocol_request_t xcb_req = {
9676 .count = 4,
9677 .ext = &xcb_input_id,
9678 .opcode = XCB_INPUT_XI_SELECT_EVENTS,
9679 .isvoid = 1
9680 };
9681
9682 struct iovec xcb_parts[6];
9683 xcb_void_cookie_t xcb_ret;
9684 xcb_input_xi_select_events_request_t xcb_out;
9685 unsigned int xcb_tmp_len;
9686 char *xcb_tmp;
9687 unsigned int i;
9688
9689 xcb_out.window = window;
9690 xcb_out.num_mask = num_mask;
9691 memset(xcb_out.pad0, 0, 2);
9692
9693 xcb_parts[2].iov_base = (char *) &xcb_out;
9694 xcb_parts[2].iov_len = sizeof(xcb_out);
9695 xcb_parts[3].iov_base = 0;
9696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9697 /* xcb_input_event_mask_t masks */
9698 xcb_parts[4].iov_base = (char *) masks;
9699 xcb_parts[4].iov_len = 0;
9700 xcb_tmp = (char *)masks;
9701 for(i=0; i<num_mask; i++) {
9702 xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
9703 xcb_parts[4].iov_len += xcb_tmp_len;
9704 xcb_tmp += xcb_tmp_len;
9705 }
9706 xcb_parts[5].iov_base = 0;
9707 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9708
9709 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9710 return xcb_ret;
9711 }
9712
9713 xcb_void_cookie_t
xcb_input_xi_select_events(xcb_connection_t * c,xcb_window_t window,uint16_t num_mask,const xcb_input_event_mask_t * masks)9714 xcb_input_xi_select_events (xcb_connection_t *c,
9715 xcb_window_t window,
9716 uint16_t num_mask,
9717 const xcb_input_event_mask_t *masks)
9718 {
9719 static const xcb_protocol_request_t xcb_req = {
9720 .count = 4,
9721 .ext = &xcb_input_id,
9722 .opcode = XCB_INPUT_XI_SELECT_EVENTS,
9723 .isvoid = 1
9724 };
9725
9726 struct iovec xcb_parts[6];
9727 xcb_void_cookie_t xcb_ret;
9728 xcb_input_xi_select_events_request_t xcb_out;
9729 unsigned int xcb_tmp_len;
9730 char *xcb_tmp;
9731 unsigned int i;
9732
9733 xcb_out.window = window;
9734 xcb_out.num_mask = num_mask;
9735 memset(xcb_out.pad0, 0, 2);
9736
9737 xcb_parts[2].iov_base = (char *) &xcb_out;
9738 xcb_parts[2].iov_len = sizeof(xcb_out);
9739 xcb_parts[3].iov_base = 0;
9740 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9741 /* xcb_input_event_mask_t masks */
9742 xcb_parts[4].iov_base = (char *) masks;
9743 xcb_parts[4].iov_len = 0;
9744 xcb_tmp = (char *)masks;
9745 for(i=0; i<num_mask; i++) {
9746 xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
9747 xcb_parts[4].iov_len += xcb_tmp_len;
9748 xcb_tmp += xcb_tmp_len;
9749 }
9750 xcb_parts[5].iov_base = 0;
9751 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
9752
9753 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9754 return xcb_ret;
9755 }
9756
9757 int
xcb_input_xi_select_events_masks_length(const xcb_input_xi_select_events_request_t * R)9758 xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R)
9759 {
9760 return R->num_mask;
9761 }
9762
9763 xcb_input_event_mask_iterator_t
xcb_input_xi_select_events_masks_iterator(const xcb_input_xi_select_events_request_t * R)9764 xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R)
9765 {
9766 xcb_input_event_mask_iterator_t i;
9767 i.data = (xcb_input_event_mask_t *) (R + 1);
9768 i.rem = R->num_mask;
9769 i.index = (char *) i.data - (char *) R;
9770 return i;
9771 }
9772
9773 xcb_input_xi_query_version_cookie_t
xcb_input_xi_query_version(xcb_connection_t * c,uint16_t major_version,uint16_t minor_version)9774 xcb_input_xi_query_version (xcb_connection_t *c,
9775 uint16_t major_version,
9776 uint16_t minor_version)
9777 {
9778 static const xcb_protocol_request_t xcb_req = {
9779 .count = 2,
9780 .ext = &xcb_input_id,
9781 .opcode = XCB_INPUT_XI_QUERY_VERSION,
9782 .isvoid = 0
9783 };
9784
9785 struct iovec xcb_parts[4];
9786 xcb_input_xi_query_version_cookie_t xcb_ret;
9787 xcb_input_xi_query_version_request_t xcb_out;
9788
9789 xcb_out.major_version = major_version;
9790 xcb_out.minor_version = minor_version;
9791
9792 xcb_parts[2].iov_base = (char *) &xcb_out;
9793 xcb_parts[2].iov_len = sizeof(xcb_out);
9794 xcb_parts[3].iov_base = 0;
9795 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9796
9797 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
9798 return xcb_ret;
9799 }
9800
9801 xcb_input_xi_query_version_cookie_t
xcb_input_xi_query_version_unchecked(xcb_connection_t * c,uint16_t major_version,uint16_t minor_version)9802 xcb_input_xi_query_version_unchecked (xcb_connection_t *c,
9803 uint16_t major_version,
9804 uint16_t minor_version)
9805 {
9806 static const xcb_protocol_request_t xcb_req = {
9807 .count = 2,
9808 .ext = &xcb_input_id,
9809 .opcode = XCB_INPUT_XI_QUERY_VERSION,
9810 .isvoid = 0
9811 };
9812
9813 struct iovec xcb_parts[4];
9814 xcb_input_xi_query_version_cookie_t xcb_ret;
9815 xcb_input_xi_query_version_request_t xcb_out;
9816
9817 xcb_out.major_version = major_version;
9818 xcb_out.minor_version = minor_version;
9819
9820 xcb_parts[2].iov_base = (char *) &xcb_out;
9821 xcb_parts[2].iov_len = sizeof(xcb_out);
9822 xcb_parts[3].iov_base = 0;
9823 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
9824
9825 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
9826 return xcb_ret;
9827 }
9828
9829 xcb_input_xi_query_version_reply_t *
xcb_input_xi_query_version_reply(xcb_connection_t * c,xcb_input_xi_query_version_cookie_t cookie,xcb_generic_error_t ** e)9830 xcb_input_xi_query_version_reply (xcb_connection_t *c,
9831 xcb_input_xi_query_version_cookie_t cookie /**< */,
9832 xcb_generic_error_t **e)
9833 {
9834 return (xcb_input_xi_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
9835 }
9836
9837 int
xcb_input_button_class_sizeof(const void * _buffer)9838 xcb_input_button_class_sizeof (const void *_buffer)
9839 {
9840 char *xcb_tmp = (char *)_buffer;
9841 const xcb_input_button_class_t *_aux = (xcb_input_button_class_t *)_buffer;
9842 unsigned int xcb_buffer_len = 0;
9843 unsigned int xcb_block_len = 0;
9844 unsigned int xcb_pad = 0;
9845 unsigned int xcb_align_to = 0;
9846
9847
9848 xcb_block_len += sizeof(xcb_input_button_class_t);
9849 xcb_tmp += xcb_block_len;
9850 xcb_buffer_len += xcb_block_len;
9851 xcb_block_len = 0;
9852 /* state */
9853 xcb_block_len += ((_aux->num_buttons + 31) / 32) * sizeof(xcb_atom_t);
9854 xcb_tmp += xcb_block_len;
9855 xcb_align_to = ALIGNOF(uint32_t);
9856 /* insert padding */
9857 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9858 xcb_buffer_len += xcb_block_len + xcb_pad;
9859 if (0 != xcb_pad) {
9860 xcb_tmp += xcb_pad;
9861 xcb_pad = 0;
9862 }
9863 xcb_block_len = 0;
9864 /* labels */
9865 xcb_block_len += _aux->num_buttons * sizeof(xcb_atom_t);
9866 xcb_tmp += xcb_block_len;
9867 xcb_align_to = ALIGNOF(xcb_atom_t);
9868 /* insert padding */
9869 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9870 xcb_buffer_len += xcb_block_len + xcb_pad;
9871 if (0 != xcb_pad) {
9872 xcb_tmp += xcb_pad;
9873 xcb_pad = 0;
9874 }
9875 xcb_block_len = 0;
9876
9877 return xcb_buffer_len;
9878 }
9879
9880 uint32_t *
xcb_input_button_class_state(const xcb_input_button_class_t * R)9881 xcb_input_button_class_state (const xcb_input_button_class_t *R)
9882 {
9883 return (uint32_t *) (R + 1);
9884 }
9885
9886 int
xcb_input_button_class_state_length(const xcb_input_button_class_t * R)9887 xcb_input_button_class_state_length (const xcb_input_button_class_t *R)
9888 {
9889 return ((R->num_buttons + 31) / 32);
9890 }
9891
9892 xcb_generic_iterator_t
xcb_input_button_class_state_end(const xcb_input_button_class_t * R)9893 xcb_input_button_class_state_end (const xcb_input_button_class_t *R)
9894 {
9895 xcb_generic_iterator_t i;
9896 i.data = ((uint32_t *) (R + 1)) + (((R->num_buttons + 31) / 32));
9897 i.rem = 0;
9898 i.index = (char *) i.data - (char *) R;
9899 return i;
9900 }
9901
9902 xcb_atom_t *
xcb_input_button_class_labels(const xcb_input_button_class_t * R)9903 xcb_input_button_class_labels (const xcb_input_button_class_t *R)
9904 {
9905 xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R);
9906 return (xcb_atom_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index) + 0);
9907 }
9908
9909 int
xcb_input_button_class_labels_length(const xcb_input_button_class_t * R)9910 xcb_input_button_class_labels_length (const xcb_input_button_class_t *R)
9911 {
9912 return R->num_buttons;
9913 }
9914
9915 xcb_generic_iterator_t
xcb_input_button_class_labels_end(const xcb_input_button_class_t * R)9916 xcb_input_button_class_labels_end (const xcb_input_button_class_t *R)
9917 {
9918 xcb_generic_iterator_t i;
9919 xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R);
9920 i.data = ((xcb_atom_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index))) + (R->num_buttons);
9921 i.rem = 0;
9922 i.index = (char *) i.data - (char *) R;
9923 return i;
9924 }
9925
9926 void
xcb_input_button_class_next(xcb_input_button_class_iterator_t * i)9927 xcb_input_button_class_next (xcb_input_button_class_iterator_t *i)
9928 {
9929 xcb_input_button_class_t *R = i->data;
9930 xcb_generic_iterator_t child;
9931 child.data = (xcb_input_button_class_t *)(((char *)R) + xcb_input_button_class_sizeof(R));
9932 i->index = (char *) child.data - (char *) i->data;
9933 --i->rem;
9934 i->data = (xcb_input_button_class_t *) child.data;
9935 }
9936
9937 xcb_generic_iterator_t
xcb_input_button_class_end(xcb_input_button_class_iterator_t i)9938 xcb_input_button_class_end (xcb_input_button_class_iterator_t i)
9939 {
9940 xcb_generic_iterator_t ret;
9941 while(i.rem > 0)
9942 xcb_input_button_class_next(&i);
9943 ret.data = i.data;
9944 ret.rem = i.rem;
9945 ret.index = i.index;
9946 return ret;
9947 }
9948
9949 int
xcb_input_key_class_sizeof(const void * _buffer)9950 xcb_input_key_class_sizeof (const void *_buffer)
9951 {
9952 char *xcb_tmp = (char *)_buffer;
9953 const xcb_input_key_class_t *_aux = (xcb_input_key_class_t *)_buffer;
9954 unsigned int xcb_buffer_len = 0;
9955 unsigned int xcb_block_len = 0;
9956 unsigned int xcb_pad = 0;
9957 unsigned int xcb_align_to = 0;
9958
9959
9960 xcb_block_len += sizeof(xcb_input_key_class_t);
9961 xcb_tmp += xcb_block_len;
9962 xcb_buffer_len += xcb_block_len;
9963 xcb_block_len = 0;
9964 /* keys */
9965 xcb_block_len += _aux->num_keys * sizeof(uint32_t);
9966 xcb_tmp += xcb_block_len;
9967 xcb_align_to = ALIGNOF(uint32_t);
9968 /* insert padding */
9969 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
9970 xcb_buffer_len += xcb_block_len + xcb_pad;
9971 if (0 != xcb_pad) {
9972 xcb_tmp += xcb_pad;
9973 xcb_pad = 0;
9974 }
9975 xcb_block_len = 0;
9976
9977 return xcb_buffer_len;
9978 }
9979
9980 uint32_t *
xcb_input_key_class_keys(const xcb_input_key_class_t * R)9981 xcb_input_key_class_keys (const xcb_input_key_class_t *R)
9982 {
9983 return (uint32_t *) (R + 1);
9984 }
9985
9986 int
xcb_input_key_class_keys_length(const xcb_input_key_class_t * R)9987 xcb_input_key_class_keys_length (const xcb_input_key_class_t *R)
9988 {
9989 return R->num_keys;
9990 }
9991
9992 xcb_generic_iterator_t
xcb_input_key_class_keys_end(const xcb_input_key_class_t * R)9993 xcb_input_key_class_keys_end (const xcb_input_key_class_t *R)
9994 {
9995 xcb_generic_iterator_t i;
9996 i.data = ((uint32_t *) (R + 1)) + (R->num_keys);
9997 i.rem = 0;
9998 i.index = (char *) i.data - (char *) R;
9999 return i;
10000 }
10001
10002 void
xcb_input_key_class_next(xcb_input_key_class_iterator_t * i)10003 xcb_input_key_class_next (xcb_input_key_class_iterator_t *i)
10004 {
10005 xcb_input_key_class_t *R = i->data;
10006 xcb_generic_iterator_t child;
10007 child.data = (xcb_input_key_class_t *)(((char *)R) + xcb_input_key_class_sizeof(R));
10008 i->index = (char *) child.data - (char *) i->data;
10009 --i->rem;
10010 i->data = (xcb_input_key_class_t *) child.data;
10011 }
10012
10013 xcb_generic_iterator_t
xcb_input_key_class_end(xcb_input_key_class_iterator_t i)10014 xcb_input_key_class_end (xcb_input_key_class_iterator_t i)
10015 {
10016 xcb_generic_iterator_t ret;
10017 while(i.rem > 0)
10018 xcb_input_key_class_next(&i);
10019 ret.data = i.data;
10020 ret.rem = i.rem;
10021 ret.index = i.index;
10022 return ret;
10023 }
10024
10025 void
xcb_input_scroll_class_next(xcb_input_scroll_class_iterator_t * i)10026 xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i)
10027 {
10028 --i->rem;
10029 ++i->data;
10030 i->index += sizeof(xcb_input_scroll_class_t);
10031 }
10032
10033 xcb_generic_iterator_t
xcb_input_scroll_class_end(xcb_input_scroll_class_iterator_t i)10034 xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i)
10035 {
10036 xcb_generic_iterator_t ret;
10037 ret.data = i.data + i.rem;
10038 ret.index = i.index + ((char *) ret.data - (char *) i.data);
10039 ret.rem = 0;
10040 return ret;
10041 }
10042
10043 void
xcb_input_touch_class_next(xcb_input_touch_class_iterator_t * i)10044 xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i)
10045 {
10046 --i->rem;
10047 ++i->data;
10048 i->index += sizeof(xcb_input_touch_class_t);
10049 }
10050
10051 xcb_generic_iterator_t
xcb_input_touch_class_end(xcb_input_touch_class_iterator_t i)10052 xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i)
10053 {
10054 xcb_generic_iterator_t ret;
10055 ret.data = i.data + i.rem;
10056 ret.index = i.index + ((char *) ret.data - (char *) i.data);
10057 ret.rem = 0;
10058 return ret;
10059 }
10060
10061 void
xcb_input_gesture_class_next(xcb_input_gesture_class_iterator_t * i)10062 xcb_input_gesture_class_next (xcb_input_gesture_class_iterator_t *i)
10063 {
10064 --i->rem;
10065 ++i->data;
10066 i->index += sizeof(xcb_input_gesture_class_t);
10067 }
10068
10069 xcb_generic_iterator_t
xcb_input_gesture_class_end(xcb_input_gesture_class_iterator_t i)10070 xcb_input_gesture_class_end (xcb_input_gesture_class_iterator_t i)
10071 {
10072 xcb_generic_iterator_t ret;
10073 ret.data = i.data + i.rem;
10074 ret.index = i.index + ((char *) ret.data - (char *) i.data);
10075 ret.rem = 0;
10076 return ret;
10077 }
10078
10079 void
xcb_input_valuator_class_next(xcb_input_valuator_class_iterator_t * i)10080 xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i)
10081 {
10082 --i->rem;
10083 ++i->data;
10084 i->index += sizeof(xcb_input_valuator_class_t);
10085 }
10086
10087 xcb_generic_iterator_t
xcb_input_valuator_class_end(xcb_input_valuator_class_iterator_t i)10088 xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i)
10089 {
10090 xcb_generic_iterator_t ret;
10091 ret.data = i.data + i.rem;
10092 ret.index = i.index + ((char *) ret.data - (char *) i.data);
10093 ret.rem = 0;
10094 return ret;
10095 }
10096
10097 uint32_t *
xcb_input_device_class_data_key_keys(const xcb_input_device_class_data_t * S)10098 xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S)
10099 {
10100 return S->key.keys;
10101 }
10102
10103 int
xcb_input_device_class_data_key_keys_length(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10104 xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R,
10105 const xcb_input_device_class_data_t *S)
10106 {
10107 return S->key.num_keys;
10108 }
10109
10110 xcb_generic_iterator_t
xcb_input_device_class_data_key_keys_end(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10111 xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R,
10112 const xcb_input_device_class_data_t *S)
10113 {
10114 xcb_generic_iterator_t i;
10115 i.data = S->key.keys + S->key.num_keys;
10116 i.rem = 0;
10117 i.index = (char *) i.data - (char *) S;
10118 return i;
10119 }
10120
10121 uint32_t *
xcb_input_device_class_data_button_state(const xcb_input_device_class_data_t * S)10122 xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S)
10123 {
10124 return S->button.state;
10125 }
10126
10127 int
xcb_input_device_class_data_button_state_length(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10128 xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R,
10129 const xcb_input_device_class_data_t *S)
10130 {
10131 return ((S->button.num_buttons + 31) / 32);
10132 }
10133
10134 xcb_generic_iterator_t
xcb_input_device_class_data_button_state_end(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10135 xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R,
10136 const xcb_input_device_class_data_t *S)
10137 {
10138 xcb_generic_iterator_t i;
10139 i.data = S->button.state + ((S->button.num_buttons + 31) / 32);
10140 i.rem = 0;
10141 i.index = (char *) i.data - (char *) S;
10142 return i;
10143 }
10144
10145 xcb_atom_t *
xcb_input_device_class_data_button_labels(const xcb_input_device_class_data_t * S)10146 xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S)
10147 {
10148 return S->button.labels;
10149 }
10150
10151 int
xcb_input_device_class_data_button_labels_length(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10152 xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R,
10153 const xcb_input_device_class_data_t *S)
10154 {
10155 return S->button.num_buttons;
10156 }
10157
10158 xcb_generic_iterator_t
xcb_input_device_class_data_button_labels_end(const xcb_input_device_class_t * R,const xcb_input_device_class_data_t * S)10159 xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R,
10160 const xcb_input_device_class_data_t *S)
10161 {
10162 xcb_generic_iterator_t i;
10163 i.data = S->button.labels + S->button.num_buttons;
10164 i.rem = 0;
10165 i.index = (char *) i.data - (char *) S;
10166 return i;
10167 }
10168
10169 int
xcb_input_device_class_data_serialize(void ** _buffer,uint16_t type,const xcb_input_device_class_data_t * _aux)10170 xcb_input_device_class_data_serialize (void **_buffer,
10171 uint16_t type,
10172 const xcb_input_device_class_data_t *_aux)
10173 {
10174 char *xcb_out = *_buffer;
10175 unsigned int xcb_buffer_len = 0;
10176 unsigned int xcb_align_to = 0;
10177 unsigned int xcb_padding_offset = 2;
10178
10179 unsigned int xcb_pad = 0;
10180 char xcb_pad0[3] = {0, 0, 0};
10181 struct iovec xcb_parts[26];
10182 unsigned int xcb_parts_idx = 0;
10183 unsigned int xcb_block_len = 0;
10184 unsigned int i;
10185 char *xcb_tmp;
10186
10187 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) {
10188 /* xcb_input_device_class_data_t.key.num_keys */
10189 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
10190 xcb_block_len += sizeof(uint16_t);
10191 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10192 xcb_parts_idx++;
10193 xcb_align_to = ALIGNOF(uint16_t);
10194 /* insert padding */
10195 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10196 xcb_buffer_len += xcb_block_len + xcb_pad;
10197 if (0 != xcb_pad) {
10198 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10199 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10200 xcb_parts_idx++;
10201 xcb_pad = 0;
10202 }
10203 xcb_block_len = 0;
10204 xcb_padding_offset = 0;
10205 /* keys */
10206 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys;
10207 xcb_block_len += _aux->key.num_keys * sizeof(uint32_t);
10208 xcb_parts[xcb_parts_idx].iov_len = _aux->key.num_keys * sizeof(uint32_t);
10209 xcb_parts_idx++;
10210 xcb_align_to = ALIGNOF(uint32_t);
10211 }
10212 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) {
10213 /* xcb_input_device_class_data_t.button.num_buttons */
10214 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
10215 xcb_block_len += sizeof(uint16_t);
10216 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10217 xcb_parts_idx++;
10218 xcb_align_to = ALIGNOF(uint16_t);
10219 /* insert padding */
10220 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10221 xcb_buffer_len += xcb_block_len + xcb_pad;
10222 if (0 != xcb_pad) {
10223 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10224 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10225 xcb_parts_idx++;
10226 xcb_pad = 0;
10227 }
10228 xcb_block_len = 0;
10229 xcb_padding_offset = 0;
10230 /* state */
10231 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.state;
10232 xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
10233 xcb_parts[xcb_parts_idx].iov_len = ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
10234 xcb_parts_idx++;
10235 xcb_align_to = ALIGNOF(uint32_t);
10236 /* insert padding */
10237 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10238 xcb_buffer_len += xcb_block_len + xcb_pad;
10239 if (0 != xcb_pad) {
10240 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10241 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10242 xcb_parts_idx++;
10243 xcb_pad = 0;
10244 }
10245 xcb_block_len = 0;
10246 xcb_padding_offset = 0;
10247 /* labels */
10248 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.labels;
10249 xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t);
10250 xcb_parts[xcb_parts_idx].iov_len = _aux->button.num_buttons * sizeof(uint32_t);
10251 xcb_parts_idx++;
10252 xcb_align_to = ALIGNOF(xcb_atom_t);
10253 }
10254 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
10255 /* xcb_input_device_class_data_t.valuator.number */
10256 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.number;
10257 xcb_block_len += sizeof(uint16_t);
10258 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10259 xcb_parts_idx++;
10260 xcb_align_to = ALIGNOF(uint16_t);
10261 /* xcb_input_device_class_data_t.valuator.label */
10262 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.label;
10263 xcb_block_len += sizeof(xcb_atom_t);
10264 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
10265 xcb_parts_idx++;
10266 xcb_align_to = ALIGNOF(xcb_atom_t);
10267 /* xcb_input_device_class_data_t.valuator.min */
10268 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.min;
10269 xcb_block_len += sizeof(xcb_input_fp3232_t);
10270 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
10271 xcb_parts_idx++;
10272 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10273 /* xcb_input_device_class_data_t.valuator.max */
10274 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.max;
10275 xcb_block_len += sizeof(xcb_input_fp3232_t);
10276 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
10277 xcb_parts_idx++;
10278 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10279 /* xcb_input_device_class_data_t.valuator.value */
10280 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.value;
10281 xcb_block_len += sizeof(xcb_input_fp3232_t);
10282 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
10283 xcb_parts_idx++;
10284 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10285 /* xcb_input_device_class_data_t.valuator.resolution */
10286 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.resolution;
10287 xcb_block_len += sizeof(uint32_t);
10288 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10289 xcb_parts_idx++;
10290 xcb_align_to = ALIGNOF(uint32_t);
10291 /* xcb_input_device_class_data_t.valuator.mode */
10292 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
10293 xcb_block_len += sizeof(uint8_t);
10294 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10295 xcb_parts_idx++;
10296 xcb_align_to = ALIGNOF(uint8_t);
10297 /* xcb_input_device_class_data_t.valuator.pad0 */
10298 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10299 xcb_block_len += sizeof(uint8_t)*3;
10300 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
10301 xcb_parts_idx++;
10302 xcb_align_to = ALIGNOF(uint8_t);
10303 }
10304 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) {
10305 /* xcb_input_device_class_data_t.scroll.number */
10306 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.number;
10307 xcb_block_len += sizeof(uint16_t);
10308 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10309 xcb_parts_idx++;
10310 xcb_align_to = ALIGNOF(uint16_t);
10311 /* xcb_input_device_class_data_t.scroll.scroll_type */
10312 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.scroll_type;
10313 xcb_block_len += sizeof(uint16_t);
10314 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10315 xcb_parts_idx++;
10316 xcb_align_to = ALIGNOF(uint16_t);
10317 /* xcb_input_device_class_data_t.scroll.pad1 */
10318 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10319 xcb_block_len += sizeof(uint8_t)*2;
10320 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
10321 xcb_parts_idx++;
10322 xcb_align_to = ALIGNOF(uint8_t);
10323 /* xcb_input_device_class_data_t.scroll.flags */
10324 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.flags;
10325 xcb_block_len += sizeof(uint32_t);
10326 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10327 xcb_parts_idx++;
10328 xcb_align_to = ALIGNOF(uint32_t);
10329 /* xcb_input_device_class_data_t.scroll.increment */
10330 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.increment;
10331 xcb_block_len += sizeof(xcb_input_fp3232_t);
10332 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
10333 xcb_parts_idx++;
10334 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10335 }
10336 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) {
10337 /* xcb_input_device_class_data_t.touch.mode */
10338 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.mode;
10339 xcb_block_len += sizeof(uint8_t);
10340 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10341 xcb_parts_idx++;
10342 xcb_align_to = ALIGNOF(uint8_t);
10343 /* xcb_input_device_class_data_t.touch.num_touches */
10344 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.num_touches;
10345 xcb_block_len += sizeof(uint8_t);
10346 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10347 xcb_parts_idx++;
10348 xcb_align_to = ALIGNOF(uint8_t);
10349 }
10350 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_GESTURE) {
10351 /* xcb_input_device_class_data_t.gesture.num_touches */
10352 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->gesture.num_touches;
10353 xcb_block_len += sizeof(uint8_t);
10354 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10355 xcb_parts_idx++;
10356 xcb_align_to = ALIGNOF(uint8_t);
10357 /* xcb_input_device_class_data_t.gesture.pad2 */
10358 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
10359 xcb_block_len += sizeof(uint8_t);
10360 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10361 xcb_parts_idx++;
10362 xcb_align_to = ALIGNOF(uint8_t);
10363 }
10364 /* insert padding */
10365 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10366 xcb_buffer_len += xcb_block_len + xcb_pad;
10367 if (0 != xcb_pad) {
10368 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10369 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10370 xcb_parts_idx++;
10371 xcb_pad = 0;
10372 }
10373 xcb_block_len = 0;
10374 xcb_padding_offset = 0;
10375
10376 if (NULL == xcb_out) {
10377 /* allocate memory */
10378 xcb_out = malloc(xcb_buffer_len);
10379 *_buffer = xcb_out;
10380 }
10381
10382 xcb_tmp = xcb_out;
10383 for(i=0; i<xcb_parts_idx; i++) {
10384 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
10385 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
10386 if (0 != xcb_parts[i].iov_len)
10387 xcb_tmp += xcb_parts[i].iov_len;
10388 }
10389
10390 return xcb_buffer_len;
10391 }
10392
10393 int
xcb_input_device_class_data_unpack(const void * _buffer,uint16_t type,xcb_input_device_class_data_t * _aux)10394 xcb_input_device_class_data_unpack (const void *_buffer,
10395 uint16_t type,
10396 xcb_input_device_class_data_t *_aux)
10397 {
10398 char *xcb_tmp = (char *)_buffer;
10399 unsigned int xcb_buffer_len = 0;
10400 unsigned int xcb_block_len = 0;
10401 unsigned int xcb_pad = 0;
10402 unsigned int xcb_align_to = 0;
10403 unsigned int xcb_padding_offset = 2;
10404
10405
10406 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) {
10407 /* xcb_input_device_class_data_t.key.num_keys */
10408 _aux->key.num_keys = *(uint16_t *)xcb_tmp;
10409 xcb_block_len += sizeof(uint16_t);
10410 xcb_tmp += sizeof(uint16_t);
10411 xcb_align_to = ALIGNOF(uint16_t);
10412 /* insert padding */
10413 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10414 xcb_buffer_len += xcb_block_len + xcb_pad;
10415 if (0 != xcb_pad) {
10416 xcb_tmp += xcb_pad;
10417 xcb_pad = 0;
10418 }
10419 xcb_block_len = 0;
10420 xcb_padding_offset = 0;
10421 /* keys */
10422 _aux->key.keys = (uint32_t *)xcb_tmp;
10423 xcb_block_len += _aux->key.num_keys * sizeof(uint32_t);
10424 xcb_tmp += xcb_block_len;
10425 xcb_align_to = ALIGNOF(uint32_t);
10426 }
10427 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) {
10428 /* xcb_input_device_class_data_t.button.num_buttons */
10429 _aux->button.num_buttons = *(uint16_t *)xcb_tmp;
10430 xcb_block_len += sizeof(uint16_t);
10431 xcb_tmp += sizeof(uint16_t);
10432 xcb_align_to = ALIGNOF(uint16_t);
10433 /* insert padding */
10434 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10435 xcb_buffer_len += xcb_block_len + xcb_pad;
10436 if (0 != xcb_pad) {
10437 xcb_tmp += xcb_pad;
10438 xcb_pad = 0;
10439 }
10440 xcb_block_len = 0;
10441 xcb_padding_offset = 0;
10442 /* state */
10443 _aux->button.state = (uint32_t *)xcb_tmp;
10444 xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
10445 xcb_tmp += xcb_block_len;
10446 xcb_align_to = ALIGNOF(uint32_t);
10447 /* insert padding */
10448 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10449 xcb_buffer_len += xcb_block_len + xcb_pad;
10450 if (0 != xcb_pad) {
10451 xcb_tmp += xcb_pad;
10452 xcb_pad = 0;
10453 }
10454 xcb_block_len = 0;
10455 xcb_padding_offset = 0;
10456 /* labels */
10457 _aux->button.labels = (xcb_atom_t *)xcb_tmp;
10458 xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t);
10459 xcb_tmp += xcb_block_len;
10460 xcb_align_to = ALIGNOF(xcb_atom_t);
10461 }
10462 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
10463 /* xcb_input_device_class_data_t.valuator.number */
10464 _aux->valuator.number = *(uint16_t *)xcb_tmp;
10465 xcb_block_len += sizeof(uint16_t);
10466 xcb_tmp += sizeof(uint16_t);
10467 xcb_align_to = ALIGNOF(uint16_t);
10468 /* xcb_input_device_class_data_t.valuator.label */
10469 _aux->valuator.label = *(xcb_atom_t *)xcb_tmp;
10470 xcb_block_len += sizeof(xcb_atom_t);
10471 xcb_tmp += sizeof(xcb_atom_t);
10472 xcb_align_to = ALIGNOF(xcb_atom_t);
10473 /* xcb_input_device_class_data_t.valuator.min */
10474 _aux->valuator.min = *(xcb_input_fp3232_t *)xcb_tmp;
10475 xcb_block_len += sizeof(xcb_input_fp3232_t);
10476 xcb_tmp += sizeof(xcb_input_fp3232_t);
10477 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10478 /* xcb_input_device_class_data_t.valuator.max */
10479 _aux->valuator.max = *(xcb_input_fp3232_t *)xcb_tmp;
10480 xcb_block_len += sizeof(xcb_input_fp3232_t);
10481 xcb_tmp += sizeof(xcb_input_fp3232_t);
10482 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10483 /* xcb_input_device_class_data_t.valuator.value */
10484 _aux->valuator.value = *(xcb_input_fp3232_t *)xcb_tmp;
10485 xcb_block_len += sizeof(xcb_input_fp3232_t);
10486 xcb_tmp += sizeof(xcb_input_fp3232_t);
10487 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10488 /* xcb_input_device_class_data_t.valuator.resolution */
10489 _aux->valuator.resolution = *(uint32_t *)xcb_tmp;
10490 xcb_block_len += sizeof(uint32_t);
10491 xcb_tmp += sizeof(uint32_t);
10492 xcb_align_to = ALIGNOF(uint32_t);
10493 /* xcb_input_device_class_data_t.valuator.mode */
10494 _aux->valuator.mode = *(uint8_t *)xcb_tmp;
10495 xcb_block_len += sizeof(uint8_t);
10496 xcb_tmp += sizeof(uint8_t);
10497 xcb_align_to = ALIGNOF(uint8_t);
10498 /* xcb_input_device_class_data_t.valuator.pad0 */
10499 _aux->valuator.pad0[0] = *(uint8_t *)xcb_tmp;
10500 _aux->valuator.pad0[1] = *(uint8_t *)xcb_tmp;
10501 _aux->valuator.pad0[2] = *(uint8_t *)xcb_tmp;
10502 xcb_block_len += sizeof(uint8_t) * 3;
10503 xcb_tmp += sizeof(uint8_t) * 3;
10504 xcb_align_to = ALIGNOF(uint8_t);
10505 }
10506 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) {
10507 /* xcb_input_device_class_data_t.scroll.number */
10508 _aux->scroll.number = *(uint16_t *)xcb_tmp;
10509 xcb_block_len += sizeof(uint16_t);
10510 xcb_tmp += sizeof(uint16_t);
10511 xcb_align_to = ALIGNOF(uint16_t);
10512 /* xcb_input_device_class_data_t.scroll.scroll_type */
10513 _aux->scroll.scroll_type = *(uint16_t *)xcb_tmp;
10514 xcb_block_len += sizeof(uint16_t);
10515 xcb_tmp += sizeof(uint16_t);
10516 xcb_align_to = ALIGNOF(uint16_t);
10517 /* xcb_input_device_class_data_t.scroll.pad1 */
10518 _aux->scroll.pad1[0] = *(uint8_t *)xcb_tmp;
10519 _aux->scroll.pad1[1] = *(uint8_t *)xcb_tmp;
10520 xcb_block_len += sizeof(uint8_t) * 2;
10521 xcb_tmp += sizeof(uint8_t) * 2;
10522 xcb_align_to = ALIGNOF(uint8_t);
10523 /* xcb_input_device_class_data_t.scroll.flags */
10524 _aux->scroll.flags = *(uint32_t *)xcb_tmp;
10525 xcb_block_len += sizeof(uint32_t);
10526 xcb_tmp += sizeof(uint32_t);
10527 xcb_align_to = ALIGNOF(uint32_t);
10528 /* xcb_input_device_class_data_t.scroll.increment */
10529 _aux->scroll.increment = *(xcb_input_fp3232_t *)xcb_tmp;
10530 xcb_block_len += sizeof(xcb_input_fp3232_t);
10531 xcb_tmp += sizeof(xcb_input_fp3232_t);
10532 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
10533 }
10534 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) {
10535 /* xcb_input_device_class_data_t.touch.mode */
10536 _aux->touch.mode = *(uint8_t *)xcb_tmp;
10537 xcb_block_len += sizeof(uint8_t);
10538 xcb_tmp += sizeof(uint8_t);
10539 xcb_align_to = ALIGNOF(uint8_t);
10540 /* xcb_input_device_class_data_t.touch.num_touches */
10541 _aux->touch.num_touches = *(uint8_t *)xcb_tmp;
10542 xcb_block_len += sizeof(uint8_t);
10543 xcb_tmp += sizeof(uint8_t);
10544 xcb_align_to = ALIGNOF(uint8_t);
10545 }
10546 if(type == XCB_INPUT_DEVICE_CLASS_TYPE_GESTURE) {
10547 /* xcb_input_device_class_data_t.gesture.num_touches */
10548 _aux->gesture.num_touches = *(uint8_t *)xcb_tmp;
10549 xcb_block_len += sizeof(uint8_t);
10550 xcb_tmp += sizeof(uint8_t);
10551 xcb_align_to = ALIGNOF(uint8_t);
10552 /* xcb_input_device_class_data_t.gesture.pad2 */
10553 _aux->gesture.pad2 = *(uint8_t *)xcb_tmp;
10554 xcb_block_len += sizeof(uint8_t);
10555 xcb_tmp += sizeof(uint8_t);
10556 xcb_align_to = ALIGNOF(uint8_t);
10557 }
10558 /* insert padding */
10559 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10560 xcb_buffer_len += xcb_block_len + xcb_pad;
10561 if (0 != xcb_pad) {
10562 xcb_tmp += xcb_pad;
10563 xcb_pad = 0;
10564 }
10565 xcb_block_len = 0;
10566 xcb_padding_offset = 0;
10567
10568 return xcb_buffer_len;
10569 }
10570
10571 int
xcb_input_device_class_data_sizeof(const void * _buffer,uint16_t type)10572 xcb_input_device_class_data_sizeof (const void *_buffer,
10573 uint16_t type)
10574 {
10575 xcb_input_device_class_data_t _aux;
10576 return xcb_input_device_class_data_unpack(_buffer, type, &_aux);
10577 }
10578
10579 int
xcb_input_device_class_sizeof(const void * _buffer)10580 xcb_input_device_class_sizeof (const void *_buffer)
10581 {
10582 const xcb_input_device_class_t *_aux = (xcb_input_device_class_t *)_buffer;
10583 return (_aux->len * 4);
10584 }
10585
10586 void *
xcb_input_device_class_data(const xcb_input_device_class_t * R)10587 xcb_input_device_class_data (const xcb_input_device_class_t *R)
10588 {
10589 return (void *) (R + 1);
10590 }
10591
10592 void
xcb_input_device_class_next(xcb_input_device_class_iterator_t * i)10593 xcb_input_device_class_next (xcb_input_device_class_iterator_t *i)
10594 {
10595 xcb_input_device_class_t *R = i->data;
10596 xcb_generic_iterator_t child;
10597 child.data = (xcb_input_device_class_t *)(((char *)R) + xcb_input_device_class_sizeof(R));
10598 i->index = (char *) child.data - (char *) i->data;
10599 --i->rem;
10600 i->data = (xcb_input_device_class_t *) child.data;
10601 }
10602
10603 xcb_generic_iterator_t
xcb_input_device_class_end(xcb_input_device_class_iterator_t i)10604 xcb_input_device_class_end (xcb_input_device_class_iterator_t i)
10605 {
10606 xcb_generic_iterator_t ret;
10607 while(i.rem > 0)
10608 xcb_input_device_class_next(&i);
10609 ret.data = i.data;
10610 ret.rem = i.rem;
10611 ret.index = i.index;
10612 return ret;
10613 }
10614
10615 int
xcb_input_xi_device_info_sizeof(const void * _buffer)10616 xcb_input_xi_device_info_sizeof (const void *_buffer)
10617 {
10618 char *xcb_tmp = (char *)_buffer;
10619 const xcb_input_xi_device_info_t *_aux = (xcb_input_xi_device_info_t *)_buffer;
10620 unsigned int xcb_buffer_len = 0;
10621 unsigned int xcb_block_len = 0;
10622 unsigned int xcb_pad = 0;
10623 unsigned int xcb_align_to = 0;
10624
10625 unsigned int i;
10626 unsigned int xcb_tmp_len;
10627
10628 xcb_block_len += sizeof(xcb_input_xi_device_info_t);
10629 xcb_tmp += xcb_block_len;
10630 xcb_buffer_len += xcb_block_len;
10631 xcb_block_len = 0;
10632 /* name */
10633 xcb_block_len += _aux->name_len * sizeof(char);
10634 xcb_tmp += xcb_block_len;
10635 xcb_align_to = ALIGNOF(char);
10636 xcb_align_to = 4;
10637 /* insert padding */
10638 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10639 xcb_buffer_len += xcb_block_len + xcb_pad;
10640 if (0 != xcb_pad) {
10641 xcb_tmp += xcb_pad;
10642 xcb_pad = 0;
10643 }
10644 xcb_block_len = 0;
10645 /* insert padding */
10646 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10647 xcb_buffer_len += xcb_block_len + xcb_pad;
10648 if (0 != xcb_pad) {
10649 xcb_tmp += xcb_pad;
10650 xcb_pad = 0;
10651 }
10652 xcb_block_len = 0;
10653 /* classes */
10654 for(i=0; i<_aux->num_classes; i++) {
10655 xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp);
10656 xcb_block_len += xcb_tmp_len;
10657 xcb_tmp += xcb_tmp_len;
10658 }
10659 xcb_align_to = ALIGNOF(xcb_input_device_class_t);
10660 /* insert padding */
10661 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10662 xcb_buffer_len += xcb_block_len + xcb_pad;
10663 if (0 != xcb_pad) {
10664 xcb_tmp += xcb_pad;
10665 xcb_pad = 0;
10666 }
10667 xcb_block_len = 0;
10668
10669 return xcb_buffer_len;
10670 }
10671
10672 char *
xcb_input_xi_device_info_name(const xcb_input_xi_device_info_t * R)10673 xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R)
10674 {
10675 return (char *) (R + 1);
10676 }
10677
10678 int
xcb_input_xi_device_info_name_length(const xcb_input_xi_device_info_t * R)10679 xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R)
10680 {
10681 return R->name_len;
10682 }
10683
10684 xcb_generic_iterator_t
xcb_input_xi_device_info_name_end(const xcb_input_xi_device_info_t * R)10685 xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R)
10686 {
10687 xcb_generic_iterator_t i;
10688 i.data = ((char *) (R + 1)) + (R->name_len);
10689 i.rem = 0;
10690 i.index = (char *) i.data - (char *) R;
10691 return i;
10692 }
10693
10694 int
xcb_input_xi_device_info_classes_length(const xcb_input_xi_device_info_t * R)10695 xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R)
10696 {
10697 return R->num_classes;
10698 }
10699
10700 xcb_input_device_class_iterator_t
xcb_input_xi_device_info_classes_iterator(const xcb_input_xi_device_info_t * R)10701 xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R)
10702 {
10703 xcb_input_device_class_iterator_t i;
10704 xcb_generic_iterator_t prev = xcb_input_xi_device_info_name_end(R);
10705 i.data = (xcb_input_device_class_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
10706 i.rem = R->num_classes;
10707 i.index = (char *) i.data - (char *) R;
10708 return i;
10709 }
10710
10711 void
xcb_input_xi_device_info_next(xcb_input_xi_device_info_iterator_t * i)10712 xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i)
10713 {
10714 xcb_input_xi_device_info_t *R = i->data;
10715 xcb_generic_iterator_t child;
10716 child.data = (xcb_input_xi_device_info_t *)(((char *)R) + xcb_input_xi_device_info_sizeof(R));
10717 i->index = (char *) child.data - (char *) i->data;
10718 --i->rem;
10719 i->data = (xcb_input_xi_device_info_t *) child.data;
10720 }
10721
10722 xcb_generic_iterator_t
xcb_input_xi_device_info_end(xcb_input_xi_device_info_iterator_t i)10723 xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i)
10724 {
10725 xcb_generic_iterator_t ret;
10726 while(i.rem > 0)
10727 xcb_input_xi_device_info_next(&i);
10728 ret.data = i.data;
10729 ret.rem = i.rem;
10730 ret.index = i.index;
10731 return ret;
10732 }
10733
10734 int
xcb_input_xi_query_device_sizeof(const void * _buffer)10735 xcb_input_xi_query_device_sizeof (const void *_buffer)
10736 {
10737 char *xcb_tmp = (char *)_buffer;
10738 const xcb_input_xi_query_device_reply_t *_aux = (xcb_input_xi_query_device_reply_t *)_buffer;
10739 unsigned int xcb_buffer_len = 0;
10740 unsigned int xcb_block_len = 0;
10741 unsigned int xcb_pad = 0;
10742 unsigned int xcb_align_to = 0;
10743
10744 unsigned int i;
10745 unsigned int xcb_tmp_len;
10746
10747 xcb_block_len += sizeof(xcb_input_xi_query_device_reply_t);
10748 xcb_tmp += xcb_block_len;
10749 xcb_buffer_len += xcb_block_len;
10750 xcb_block_len = 0;
10751 /* infos */
10752 for(i=0; i<_aux->num_infos; i++) {
10753 xcb_tmp_len = xcb_input_xi_device_info_sizeof(xcb_tmp);
10754 xcb_block_len += xcb_tmp_len;
10755 xcb_tmp += xcb_tmp_len;
10756 }
10757 xcb_align_to = ALIGNOF(xcb_input_xi_device_info_t);
10758 /* insert padding */
10759 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10760 xcb_buffer_len += xcb_block_len + xcb_pad;
10761 if (0 != xcb_pad) {
10762 xcb_tmp += xcb_pad;
10763 xcb_pad = 0;
10764 }
10765 xcb_block_len = 0;
10766
10767 return xcb_buffer_len;
10768 }
10769
10770 xcb_input_xi_query_device_cookie_t
xcb_input_xi_query_device(xcb_connection_t * c,xcb_input_device_id_t deviceid)10771 xcb_input_xi_query_device (xcb_connection_t *c,
10772 xcb_input_device_id_t deviceid)
10773 {
10774 static const xcb_protocol_request_t xcb_req = {
10775 .count = 2,
10776 .ext = &xcb_input_id,
10777 .opcode = XCB_INPUT_XI_QUERY_DEVICE,
10778 .isvoid = 0
10779 };
10780
10781 struct iovec xcb_parts[4];
10782 xcb_input_xi_query_device_cookie_t xcb_ret;
10783 xcb_input_xi_query_device_request_t xcb_out;
10784
10785 xcb_out.deviceid = deviceid;
10786 memset(xcb_out.pad0, 0, 2);
10787
10788 xcb_parts[2].iov_base = (char *) &xcb_out;
10789 xcb_parts[2].iov_len = sizeof(xcb_out);
10790 xcb_parts[3].iov_base = 0;
10791 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10792
10793 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10794 return xcb_ret;
10795 }
10796
10797 xcb_input_xi_query_device_cookie_t
xcb_input_xi_query_device_unchecked(xcb_connection_t * c,xcb_input_device_id_t deviceid)10798 xcb_input_xi_query_device_unchecked (xcb_connection_t *c,
10799 xcb_input_device_id_t deviceid)
10800 {
10801 static const xcb_protocol_request_t xcb_req = {
10802 .count = 2,
10803 .ext = &xcb_input_id,
10804 .opcode = XCB_INPUT_XI_QUERY_DEVICE,
10805 .isvoid = 0
10806 };
10807
10808 struct iovec xcb_parts[4];
10809 xcb_input_xi_query_device_cookie_t xcb_ret;
10810 xcb_input_xi_query_device_request_t xcb_out;
10811
10812 xcb_out.deviceid = deviceid;
10813 memset(xcb_out.pad0, 0, 2);
10814
10815 xcb_parts[2].iov_base = (char *) &xcb_out;
10816 xcb_parts[2].iov_len = sizeof(xcb_out);
10817 xcb_parts[3].iov_base = 0;
10818 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10819
10820 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10821 return xcb_ret;
10822 }
10823
10824 int
xcb_input_xi_query_device_infos_length(const xcb_input_xi_query_device_reply_t * R)10825 xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R)
10826 {
10827 return R->num_infos;
10828 }
10829
10830 xcb_input_xi_device_info_iterator_t
xcb_input_xi_query_device_infos_iterator(const xcb_input_xi_query_device_reply_t * R)10831 xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R)
10832 {
10833 xcb_input_xi_device_info_iterator_t i;
10834 i.data = (xcb_input_xi_device_info_t *) (R + 1);
10835 i.rem = R->num_infos;
10836 i.index = (char *) i.data - (char *) R;
10837 return i;
10838 }
10839
10840 xcb_input_xi_query_device_reply_t *
xcb_input_xi_query_device_reply(xcb_connection_t * c,xcb_input_xi_query_device_cookie_t cookie,xcb_generic_error_t ** e)10841 xcb_input_xi_query_device_reply (xcb_connection_t *c,
10842 xcb_input_xi_query_device_cookie_t cookie /**< */,
10843 xcb_generic_error_t **e)
10844 {
10845 return (xcb_input_xi_query_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
10846 }
10847
10848 xcb_void_cookie_t
xcb_input_xi_set_focus_checked(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t time,xcb_input_device_id_t deviceid)10849 xcb_input_xi_set_focus_checked (xcb_connection_t *c,
10850 xcb_window_t window,
10851 xcb_timestamp_t time,
10852 xcb_input_device_id_t deviceid)
10853 {
10854 static const xcb_protocol_request_t xcb_req = {
10855 .count = 2,
10856 .ext = &xcb_input_id,
10857 .opcode = XCB_INPUT_XI_SET_FOCUS,
10858 .isvoid = 1
10859 };
10860
10861 struct iovec xcb_parts[4];
10862 xcb_void_cookie_t xcb_ret;
10863 xcb_input_xi_set_focus_request_t xcb_out;
10864
10865 xcb_out.window = window;
10866 xcb_out.time = time;
10867 xcb_out.deviceid = deviceid;
10868 memset(xcb_out.pad0, 0, 2);
10869
10870 xcb_parts[2].iov_base = (char *) &xcb_out;
10871 xcb_parts[2].iov_len = sizeof(xcb_out);
10872 xcb_parts[3].iov_base = 0;
10873 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10874
10875 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10876 return xcb_ret;
10877 }
10878
10879 xcb_void_cookie_t
xcb_input_xi_set_focus(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t time,xcb_input_device_id_t deviceid)10880 xcb_input_xi_set_focus (xcb_connection_t *c,
10881 xcb_window_t window,
10882 xcb_timestamp_t time,
10883 xcb_input_device_id_t deviceid)
10884 {
10885 static const xcb_protocol_request_t xcb_req = {
10886 .count = 2,
10887 .ext = &xcb_input_id,
10888 .opcode = XCB_INPUT_XI_SET_FOCUS,
10889 .isvoid = 1
10890 };
10891
10892 struct iovec xcb_parts[4];
10893 xcb_void_cookie_t xcb_ret;
10894 xcb_input_xi_set_focus_request_t xcb_out;
10895
10896 xcb_out.window = window;
10897 xcb_out.time = time;
10898 xcb_out.deviceid = deviceid;
10899 memset(xcb_out.pad0, 0, 2);
10900
10901 xcb_parts[2].iov_base = (char *) &xcb_out;
10902 xcb_parts[2].iov_len = sizeof(xcb_out);
10903 xcb_parts[3].iov_base = 0;
10904 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10905
10906 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10907 return xcb_ret;
10908 }
10909
10910 xcb_input_xi_get_focus_cookie_t
xcb_input_xi_get_focus(xcb_connection_t * c,xcb_input_device_id_t deviceid)10911 xcb_input_xi_get_focus (xcb_connection_t *c,
10912 xcb_input_device_id_t deviceid)
10913 {
10914 static const xcb_protocol_request_t xcb_req = {
10915 .count = 2,
10916 .ext = &xcb_input_id,
10917 .opcode = XCB_INPUT_XI_GET_FOCUS,
10918 .isvoid = 0
10919 };
10920
10921 struct iovec xcb_parts[4];
10922 xcb_input_xi_get_focus_cookie_t xcb_ret;
10923 xcb_input_xi_get_focus_request_t xcb_out;
10924
10925 xcb_out.deviceid = deviceid;
10926 memset(xcb_out.pad0, 0, 2);
10927
10928 xcb_parts[2].iov_base = (char *) &xcb_out;
10929 xcb_parts[2].iov_len = sizeof(xcb_out);
10930 xcb_parts[3].iov_base = 0;
10931 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10932
10933 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
10934 return xcb_ret;
10935 }
10936
10937 xcb_input_xi_get_focus_cookie_t
xcb_input_xi_get_focus_unchecked(xcb_connection_t * c,xcb_input_device_id_t deviceid)10938 xcb_input_xi_get_focus_unchecked (xcb_connection_t *c,
10939 xcb_input_device_id_t deviceid)
10940 {
10941 static const xcb_protocol_request_t xcb_req = {
10942 .count = 2,
10943 .ext = &xcb_input_id,
10944 .opcode = XCB_INPUT_XI_GET_FOCUS,
10945 .isvoid = 0
10946 };
10947
10948 struct iovec xcb_parts[4];
10949 xcb_input_xi_get_focus_cookie_t xcb_ret;
10950 xcb_input_xi_get_focus_request_t xcb_out;
10951
10952 xcb_out.deviceid = deviceid;
10953 memset(xcb_out.pad0, 0, 2);
10954
10955 xcb_parts[2].iov_base = (char *) &xcb_out;
10956 xcb_parts[2].iov_len = sizeof(xcb_out);
10957 xcb_parts[3].iov_base = 0;
10958 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
10959
10960 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
10961 return xcb_ret;
10962 }
10963
10964 xcb_input_xi_get_focus_reply_t *
xcb_input_xi_get_focus_reply(xcb_connection_t * c,xcb_input_xi_get_focus_cookie_t cookie,xcb_generic_error_t ** e)10965 xcb_input_xi_get_focus_reply (xcb_connection_t *c,
10966 xcb_input_xi_get_focus_cookie_t cookie /**< */,
10967 xcb_generic_error_t **e)
10968 {
10969 return (xcb_input_xi_get_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
10970 }
10971
10972 int
xcb_input_xi_grab_device_sizeof(const void * _buffer)10973 xcb_input_xi_grab_device_sizeof (const void *_buffer)
10974 {
10975 char *xcb_tmp = (char *)_buffer;
10976 const xcb_input_xi_grab_device_request_t *_aux = (xcb_input_xi_grab_device_request_t *)_buffer;
10977 unsigned int xcb_buffer_len = 0;
10978 unsigned int xcb_block_len = 0;
10979 unsigned int xcb_pad = 0;
10980 unsigned int xcb_align_to = 0;
10981
10982
10983 xcb_block_len += sizeof(xcb_input_xi_grab_device_request_t);
10984 xcb_tmp += xcb_block_len;
10985 xcb_buffer_len += xcb_block_len;
10986 xcb_block_len = 0;
10987 /* mask */
10988 xcb_block_len += _aux->mask_len * sizeof(uint32_t);
10989 xcb_tmp += xcb_block_len;
10990 xcb_align_to = ALIGNOF(uint32_t);
10991 /* insert padding */
10992 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
10993 xcb_buffer_len += xcb_block_len + xcb_pad;
10994 if (0 != xcb_pad) {
10995 xcb_tmp += xcb_pad;
10996 xcb_pad = 0;
10997 }
10998 xcb_block_len = 0;
10999
11000 return xcb_buffer_len;
11001 }
11002
11003 xcb_input_xi_grab_device_cookie_t
xcb_input_xi_grab_device(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t time,xcb_cursor_t cursor,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t paired_device_mode,uint8_t owner_events,uint16_t mask_len,const uint32_t * mask)11004 xcb_input_xi_grab_device (xcb_connection_t *c,
11005 xcb_window_t window,
11006 xcb_timestamp_t time,
11007 xcb_cursor_t cursor,
11008 xcb_input_device_id_t deviceid,
11009 uint8_t mode,
11010 uint8_t paired_device_mode,
11011 uint8_t owner_events,
11012 uint16_t mask_len,
11013 const uint32_t *mask)
11014 {
11015 static const xcb_protocol_request_t xcb_req = {
11016 .count = 4,
11017 .ext = &xcb_input_id,
11018 .opcode = XCB_INPUT_XI_GRAB_DEVICE,
11019 .isvoid = 0
11020 };
11021
11022 struct iovec xcb_parts[6];
11023 xcb_input_xi_grab_device_cookie_t xcb_ret;
11024 xcb_input_xi_grab_device_request_t xcb_out;
11025
11026 xcb_out.window = window;
11027 xcb_out.time = time;
11028 xcb_out.cursor = cursor;
11029 xcb_out.deviceid = deviceid;
11030 xcb_out.mode = mode;
11031 xcb_out.paired_device_mode = paired_device_mode;
11032 xcb_out.owner_events = owner_events;
11033 xcb_out.pad0 = 0;
11034 xcb_out.mask_len = mask_len;
11035
11036 xcb_parts[2].iov_base = (char *) &xcb_out;
11037 xcb_parts[2].iov_len = sizeof(xcb_out);
11038 xcb_parts[3].iov_base = 0;
11039 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11040 /* uint32_t mask */
11041 xcb_parts[4].iov_base = (char *) mask;
11042 xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
11043 xcb_parts[5].iov_base = 0;
11044 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11045
11046 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11047 return xcb_ret;
11048 }
11049
11050 xcb_input_xi_grab_device_cookie_t
xcb_input_xi_grab_device_unchecked(xcb_connection_t * c,xcb_window_t window,xcb_timestamp_t time,xcb_cursor_t cursor,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t paired_device_mode,uint8_t owner_events,uint16_t mask_len,const uint32_t * mask)11051 xcb_input_xi_grab_device_unchecked (xcb_connection_t *c,
11052 xcb_window_t window,
11053 xcb_timestamp_t time,
11054 xcb_cursor_t cursor,
11055 xcb_input_device_id_t deviceid,
11056 uint8_t mode,
11057 uint8_t paired_device_mode,
11058 uint8_t owner_events,
11059 uint16_t mask_len,
11060 const uint32_t *mask)
11061 {
11062 static const xcb_protocol_request_t xcb_req = {
11063 .count = 4,
11064 .ext = &xcb_input_id,
11065 .opcode = XCB_INPUT_XI_GRAB_DEVICE,
11066 .isvoid = 0
11067 };
11068
11069 struct iovec xcb_parts[6];
11070 xcb_input_xi_grab_device_cookie_t xcb_ret;
11071 xcb_input_xi_grab_device_request_t xcb_out;
11072
11073 xcb_out.window = window;
11074 xcb_out.time = time;
11075 xcb_out.cursor = cursor;
11076 xcb_out.deviceid = deviceid;
11077 xcb_out.mode = mode;
11078 xcb_out.paired_device_mode = paired_device_mode;
11079 xcb_out.owner_events = owner_events;
11080 xcb_out.pad0 = 0;
11081 xcb_out.mask_len = mask_len;
11082
11083 xcb_parts[2].iov_base = (char *) &xcb_out;
11084 xcb_parts[2].iov_len = sizeof(xcb_out);
11085 xcb_parts[3].iov_base = 0;
11086 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11087 /* uint32_t mask */
11088 xcb_parts[4].iov_base = (char *) mask;
11089 xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
11090 xcb_parts[5].iov_base = 0;
11091 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11092
11093 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11094 return xcb_ret;
11095 }
11096
11097 xcb_input_xi_grab_device_reply_t *
xcb_input_xi_grab_device_reply(xcb_connection_t * c,xcb_input_xi_grab_device_cookie_t cookie,xcb_generic_error_t ** e)11098 xcb_input_xi_grab_device_reply (xcb_connection_t *c,
11099 xcb_input_xi_grab_device_cookie_t cookie /**< */,
11100 xcb_generic_error_t **e)
11101 {
11102 return (xcb_input_xi_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11103 }
11104
11105 xcb_void_cookie_t
xcb_input_xi_ungrab_device_checked(xcb_connection_t * c,xcb_timestamp_t time,xcb_input_device_id_t deviceid)11106 xcb_input_xi_ungrab_device_checked (xcb_connection_t *c,
11107 xcb_timestamp_t time,
11108 xcb_input_device_id_t deviceid)
11109 {
11110 static const xcb_protocol_request_t xcb_req = {
11111 .count = 2,
11112 .ext = &xcb_input_id,
11113 .opcode = XCB_INPUT_XI_UNGRAB_DEVICE,
11114 .isvoid = 1
11115 };
11116
11117 struct iovec xcb_parts[4];
11118 xcb_void_cookie_t xcb_ret;
11119 xcb_input_xi_ungrab_device_request_t xcb_out;
11120
11121 xcb_out.time = time;
11122 xcb_out.deviceid = deviceid;
11123 memset(xcb_out.pad0, 0, 2);
11124
11125 xcb_parts[2].iov_base = (char *) &xcb_out;
11126 xcb_parts[2].iov_len = sizeof(xcb_out);
11127 xcb_parts[3].iov_base = 0;
11128 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11129
11130 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11131 return xcb_ret;
11132 }
11133
11134 xcb_void_cookie_t
xcb_input_xi_ungrab_device(xcb_connection_t * c,xcb_timestamp_t time,xcb_input_device_id_t deviceid)11135 xcb_input_xi_ungrab_device (xcb_connection_t *c,
11136 xcb_timestamp_t time,
11137 xcb_input_device_id_t deviceid)
11138 {
11139 static const xcb_protocol_request_t xcb_req = {
11140 .count = 2,
11141 .ext = &xcb_input_id,
11142 .opcode = XCB_INPUT_XI_UNGRAB_DEVICE,
11143 .isvoid = 1
11144 };
11145
11146 struct iovec xcb_parts[4];
11147 xcb_void_cookie_t xcb_ret;
11148 xcb_input_xi_ungrab_device_request_t xcb_out;
11149
11150 xcb_out.time = time;
11151 xcb_out.deviceid = deviceid;
11152 memset(xcb_out.pad0, 0, 2);
11153
11154 xcb_parts[2].iov_base = (char *) &xcb_out;
11155 xcb_parts[2].iov_len = sizeof(xcb_out);
11156 xcb_parts[3].iov_base = 0;
11157 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11158
11159 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11160 return xcb_ret;
11161 }
11162
11163 xcb_void_cookie_t
xcb_input_xi_allow_events_checked(xcb_connection_t * c,xcb_timestamp_t time,xcb_input_device_id_t deviceid,uint8_t event_mode,uint32_t touchid,xcb_window_t grab_window)11164 xcb_input_xi_allow_events_checked (xcb_connection_t *c,
11165 xcb_timestamp_t time,
11166 xcb_input_device_id_t deviceid,
11167 uint8_t event_mode,
11168 uint32_t touchid,
11169 xcb_window_t grab_window)
11170 {
11171 static const xcb_protocol_request_t xcb_req = {
11172 .count = 2,
11173 .ext = &xcb_input_id,
11174 .opcode = XCB_INPUT_XI_ALLOW_EVENTS,
11175 .isvoid = 1
11176 };
11177
11178 struct iovec xcb_parts[4];
11179 xcb_void_cookie_t xcb_ret;
11180 xcb_input_xi_allow_events_request_t xcb_out;
11181
11182 xcb_out.time = time;
11183 xcb_out.deviceid = deviceid;
11184 xcb_out.event_mode = event_mode;
11185 xcb_out.pad0 = 0;
11186 xcb_out.touchid = touchid;
11187 xcb_out.grab_window = grab_window;
11188
11189 xcb_parts[2].iov_base = (char *) &xcb_out;
11190 xcb_parts[2].iov_len = sizeof(xcb_out);
11191 xcb_parts[3].iov_base = 0;
11192 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11193
11194 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11195 return xcb_ret;
11196 }
11197
11198 xcb_void_cookie_t
xcb_input_xi_allow_events(xcb_connection_t * c,xcb_timestamp_t time,xcb_input_device_id_t deviceid,uint8_t event_mode,uint32_t touchid,xcb_window_t grab_window)11199 xcb_input_xi_allow_events (xcb_connection_t *c,
11200 xcb_timestamp_t time,
11201 xcb_input_device_id_t deviceid,
11202 uint8_t event_mode,
11203 uint32_t touchid,
11204 xcb_window_t grab_window)
11205 {
11206 static const xcb_protocol_request_t xcb_req = {
11207 .count = 2,
11208 .ext = &xcb_input_id,
11209 .opcode = XCB_INPUT_XI_ALLOW_EVENTS,
11210 .isvoid = 1
11211 };
11212
11213 struct iovec xcb_parts[4];
11214 xcb_void_cookie_t xcb_ret;
11215 xcb_input_xi_allow_events_request_t xcb_out;
11216
11217 xcb_out.time = time;
11218 xcb_out.deviceid = deviceid;
11219 xcb_out.event_mode = event_mode;
11220 xcb_out.pad0 = 0;
11221 xcb_out.touchid = touchid;
11222 xcb_out.grab_window = grab_window;
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
11229 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11230 return xcb_ret;
11231 }
11232
11233 void
xcb_input_grab_modifier_info_next(xcb_input_grab_modifier_info_iterator_t * i)11234 xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i)
11235 {
11236 --i->rem;
11237 ++i->data;
11238 i->index += sizeof(xcb_input_grab_modifier_info_t);
11239 }
11240
11241 xcb_generic_iterator_t
xcb_input_grab_modifier_info_end(xcb_input_grab_modifier_info_iterator_t i)11242 xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i)
11243 {
11244 xcb_generic_iterator_t ret;
11245 ret.data = i.data + i.rem;
11246 ret.index = i.index + ((char *) ret.data - (char *) i.data);
11247 ret.rem = 0;
11248 return ret;
11249 }
11250
11251 int
xcb_input_xi_passive_grab_device_sizeof(const void * _buffer)11252 xcb_input_xi_passive_grab_device_sizeof (const void *_buffer)
11253 {
11254 char *xcb_tmp = (char *)_buffer;
11255 const xcb_input_xi_passive_grab_device_request_t *_aux = (xcb_input_xi_passive_grab_device_request_t *)_buffer;
11256 unsigned int xcb_buffer_len = 0;
11257 unsigned int xcb_block_len = 0;
11258 unsigned int xcb_pad = 0;
11259 unsigned int xcb_align_to = 0;
11260
11261
11262 xcb_block_len += sizeof(xcb_input_xi_passive_grab_device_request_t);
11263 xcb_tmp += xcb_block_len;
11264 xcb_buffer_len += xcb_block_len;
11265 xcb_block_len = 0;
11266 /* mask */
11267 xcb_block_len += _aux->mask_len * sizeof(uint32_t);
11268 xcb_tmp += xcb_block_len;
11269 xcb_align_to = ALIGNOF(uint32_t);
11270 /* insert padding */
11271 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11272 xcb_buffer_len += xcb_block_len + xcb_pad;
11273 if (0 != xcb_pad) {
11274 xcb_tmp += xcb_pad;
11275 xcb_pad = 0;
11276 }
11277 xcb_block_len = 0;
11278 /* modifiers */
11279 xcb_block_len += _aux->num_modifiers * sizeof(uint32_t);
11280 xcb_tmp += xcb_block_len;
11281 xcb_align_to = ALIGNOF(uint32_t);
11282 /* insert padding */
11283 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11284 xcb_buffer_len += xcb_block_len + xcb_pad;
11285 if (0 != xcb_pad) {
11286 xcb_tmp += xcb_pad;
11287 xcb_pad = 0;
11288 }
11289 xcb_block_len = 0;
11290
11291 return xcb_buffer_len;
11292 }
11293
11294 xcb_input_xi_passive_grab_device_cookie_t
xcb_input_xi_passive_grab_device(xcb_connection_t * c,xcb_timestamp_t time,xcb_window_t grab_window,xcb_cursor_t cursor,uint32_t detail,xcb_input_device_id_t deviceid,uint16_t num_modifiers,uint16_t mask_len,uint8_t grab_type,uint8_t grab_mode,uint8_t paired_device_mode,uint8_t owner_events,const uint32_t * mask,const uint32_t * modifiers)11295 xcb_input_xi_passive_grab_device (xcb_connection_t *c,
11296 xcb_timestamp_t time,
11297 xcb_window_t grab_window,
11298 xcb_cursor_t cursor,
11299 uint32_t detail,
11300 xcb_input_device_id_t deviceid,
11301 uint16_t num_modifiers,
11302 uint16_t mask_len,
11303 uint8_t grab_type,
11304 uint8_t grab_mode,
11305 uint8_t paired_device_mode,
11306 uint8_t owner_events,
11307 const uint32_t *mask,
11308 const uint32_t *modifiers)
11309 {
11310 static const xcb_protocol_request_t xcb_req = {
11311 .count = 6,
11312 .ext = &xcb_input_id,
11313 .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE,
11314 .isvoid = 0
11315 };
11316
11317 struct iovec xcb_parts[8];
11318 xcb_input_xi_passive_grab_device_cookie_t xcb_ret;
11319 xcb_input_xi_passive_grab_device_request_t xcb_out;
11320
11321 xcb_out.time = time;
11322 xcb_out.grab_window = grab_window;
11323 xcb_out.cursor = cursor;
11324 xcb_out.detail = detail;
11325 xcb_out.deviceid = deviceid;
11326 xcb_out.num_modifiers = num_modifiers;
11327 xcb_out.mask_len = mask_len;
11328 xcb_out.grab_type = grab_type;
11329 xcb_out.grab_mode = grab_mode;
11330 xcb_out.paired_device_mode = paired_device_mode;
11331 xcb_out.owner_events = owner_events;
11332 memset(xcb_out.pad0, 0, 2);
11333
11334 xcb_parts[2].iov_base = (char *) &xcb_out;
11335 xcb_parts[2].iov_len = sizeof(xcb_out);
11336 xcb_parts[3].iov_base = 0;
11337 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11338 /* uint32_t mask */
11339 xcb_parts[4].iov_base = (char *) mask;
11340 xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
11341 xcb_parts[5].iov_base = 0;
11342 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11343 /* uint32_t modifiers */
11344 xcb_parts[6].iov_base = (char *) modifiers;
11345 xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t);
11346 xcb_parts[7].iov_base = 0;
11347 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
11348
11349 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11350 return xcb_ret;
11351 }
11352
11353 xcb_input_xi_passive_grab_device_cookie_t
xcb_input_xi_passive_grab_device_unchecked(xcb_connection_t * c,xcb_timestamp_t time,xcb_window_t grab_window,xcb_cursor_t cursor,uint32_t detail,xcb_input_device_id_t deviceid,uint16_t num_modifiers,uint16_t mask_len,uint8_t grab_type,uint8_t grab_mode,uint8_t paired_device_mode,uint8_t owner_events,const uint32_t * mask,const uint32_t * modifiers)11354 xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c,
11355 xcb_timestamp_t time,
11356 xcb_window_t grab_window,
11357 xcb_cursor_t cursor,
11358 uint32_t detail,
11359 xcb_input_device_id_t deviceid,
11360 uint16_t num_modifiers,
11361 uint16_t mask_len,
11362 uint8_t grab_type,
11363 uint8_t grab_mode,
11364 uint8_t paired_device_mode,
11365 uint8_t owner_events,
11366 const uint32_t *mask,
11367 const uint32_t *modifiers)
11368 {
11369 static const xcb_protocol_request_t xcb_req = {
11370 .count = 6,
11371 .ext = &xcb_input_id,
11372 .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE,
11373 .isvoid = 0
11374 };
11375
11376 struct iovec xcb_parts[8];
11377 xcb_input_xi_passive_grab_device_cookie_t xcb_ret;
11378 xcb_input_xi_passive_grab_device_request_t xcb_out;
11379
11380 xcb_out.time = time;
11381 xcb_out.grab_window = grab_window;
11382 xcb_out.cursor = cursor;
11383 xcb_out.detail = detail;
11384 xcb_out.deviceid = deviceid;
11385 xcb_out.num_modifiers = num_modifiers;
11386 xcb_out.mask_len = mask_len;
11387 xcb_out.grab_type = grab_type;
11388 xcb_out.grab_mode = grab_mode;
11389 xcb_out.paired_device_mode = paired_device_mode;
11390 xcb_out.owner_events = owner_events;
11391 memset(xcb_out.pad0, 0, 2);
11392
11393 xcb_parts[2].iov_base = (char *) &xcb_out;
11394 xcb_parts[2].iov_len = sizeof(xcb_out);
11395 xcb_parts[3].iov_base = 0;
11396 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11397 /* uint32_t mask */
11398 xcb_parts[4].iov_base = (char *) mask;
11399 xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
11400 xcb_parts[5].iov_base = 0;
11401 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11402 /* uint32_t modifiers */
11403 xcb_parts[6].iov_base = (char *) modifiers;
11404 xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t);
11405 xcb_parts[7].iov_base = 0;
11406 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
11407
11408 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11409 return xcb_ret;
11410 }
11411
11412 xcb_input_grab_modifier_info_t *
xcb_input_xi_passive_grab_device_modifiers(const xcb_input_xi_passive_grab_device_reply_t * R)11413 xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R)
11414 {
11415 return (xcb_input_grab_modifier_info_t *) (R + 1);
11416 }
11417
11418 int
xcb_input_xi_passive_grab_device_modifiers_length(const xcb_input_xi_passive_grab_device_reply_t * R)11419 xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R)
11420 {
11421 return R->num_modifiers;
11422 }
11423
11424 xcb_input_grab_modifier_info_iterator_t
xcb_input_xi_passive_grab_device_modifiers_iterator(const xcb_input_xi_passive_grab_device_reply_t * R)11425 xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R)
11426 {
11427 xcb_input_grab_modifier_info_iterator_t i;
11428 i.data = (xcb_input_grab_modifier_info_t *) (R + 1);
11429 i.rem = R->num_modifiers;
11430 i.index = (char *) i.data - (char *) R;
11431 return i;
11432 }
11433
11434 xcb_input_xi_passive_grab_device_reply_t *
xcb_input_xi_passive_grab_device_reply(xcb_connection_t * c,xcb_input_xi_passive_grab_device_cookie_t cookie,xcb_generic_error_t ** e)11435 xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c,
11436 xcb_input_xi_passive_grab_device_cookie_t cookie /**< */,
11437 xcb_generic_error_t **e)
11438 {
11439 return (xcb_input_xi_passive_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11440 }
11441
11442 int
xcb_input_xi_passive_ungrab_device_sizeof(const void * _buffer)11443 xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer)
11444 {
11445 char *xcb_tmp = (char *)_buffer;
11446 const xcb_input_xi_passive_ungrab_device_request_t *_aux = (xcb_input_xi_passive_ungrab_device_request_t *)_buffer;
11447 unsigned int xcb_buffer_len = 0;
11448 unsigned int xcb_block_len = 0;
11449 unsigned int xcb_pad = 0;
11450 unsigned int xcb_align_to = 0;
11451
11452
11453 xcb_block_len += sizeof(xcb_input_xi_passive_ungrab_device_request_t);
11454 xcb_tmp += xcb_block_len;
11455 xcb_buffer_len += xcb_block_len;
11456 xcb_block_len = 0;
11457 /* modifiers */
11458 xcb_block_len += _aux->num_modifiers * sizeof(uint32_t);
11459 xcb_tmp += xcb_block_len;
11460 xcb_align_to = ALIGNOF(uint32_t);
11461 /* insert padding */
11462 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11463 xcb_buffer_len += xcb_block_len + xcb_pad;
11464 if (0 != xcb_pad) {
11465 xcb_tmp += xcb_pad;
11466 xcb_pad = 0;
11467 }
11468 xcb_block_len = 0;
11469
11470 return xcb_buffer_len;
11471 }
11472
11473 xcb_void_cookie_t
xcb_input_xi_passive_ungrab_device_checked(xcb_connection_t * c,xcb_window_t grab_window,uint32_t detail,xcb_input_device_id_t deviceid,uint16_t num_modifiers,uint8_t grab_type,const uint32_t * modifiers)11474 xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c,
11475 xcb_window_t grab_window,
11476 uint32_t detail,
11477 xcb_input_device_id_t deviceid,
11478 uint16_t num_modifiers,
11479 uint8_t grab_type,
11480 const uint32_t *modifiers)
11481 {
11482 static const xcb_protocol_request_t xcb_req = {
11483 .count = 4,
11484 .ext = &xcb_input_id,
11485 .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE,
11486 .isvoid = 1
11487 };
11488
11489 struct iovec xcb_parts[6];
11490 xcb_void_cookie_t xcb_ret;
11491 xcb_input_xi_passive_ungrab_device_request_t xcb_out;
11492
11493 xcb_out.grab_window = grab_window;
11494 xcb_out.detail = detail;
11495 xcb_out.deviceid = deviceid;
11496 xcb_out.num_modifiers = num_modifiers;
11497 xcb_out.grab_type = grab_type;
11498 memset(xcb_out.pad0, 0, 3);
11499
11500 xcb_parts[2].iov_base = (char *) &xcb_out;
11501 xcb_parts[2].iov_len = sizeof(xcb_out);
11502 xcb_parts[3].iov_base = 0;
11503 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11504 /* uint32_t modifiers */
11505 xcb_parts[4].iov_base = (char *) modifiers;
11506 xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t);
11507 xcb_parts[5].iov_base = 0;
11508 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11509
11510 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11511 return xcb_ret;
11512 }
11513
11514 xcb_void_cookie_t
xcb_input_xi_passive_ungrab_device(xcb_connection_t * c,xcb_window_t grab_window,uint32_t detail,xcb_input_device_id_t deviceid,uint16_t num_modifiers,uint8_t grab_type,const uint32_t * modifiers)11515 xcb_input_xi_passive_ungrab_device (xcb_connection_t *c,
11516 xcb_window_t grab_window,
11517 uint32_t detail,
11518 xcb_input_device_id_t deviceid,
11519 uint16_t num_modifiers,
11520 uint8_t grab_type,
11521 const uint32_t *modifiers)
11522 {
11523 static const xcb_protocol_request_t xcb_req = {
11524 .count = 4,
11525 .ext = &xcb_input_id,
11526 .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE,
11527 .isvoid = 1
11528 };
11529
11530 struct iovec xcb_parts[6];
11531 xcb_void_cookie_t xcb_ret;
11532 xcb_input_xi_passive_ungrab_device_request_t xcb_out;
11533
11534 xcb_out.grab_window = grab_window;
11535 xcb_out.detail = detail;
11536 xcb_out.deviceid = deviceid;
11537 xcb_out.num_modifiers = num_modifiers;
11538 xcb_out.grab_type = grab_type;
11539 memset(xcb_out.pad0, 0, 3);
11540
11541 xcb_parts[2].iov_base = (char *) &xcb_out;
11542 xcb_parts[2].iov_len = sizeof(xcb_out);
11543 xcb_parts[3].iov_base = 0;
11544 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11545 /* uint32_t modifiers */
11546 xcb_parts[4].iov_base = (char *) modifiers;
11547 xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t);
11548 xcb_parts[5].iov_base = 0;
11549 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11550
11551 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11552 return xcb_ret;
11553 }
11554
11555 uint32_t *
xcb_input_xi_passive_ungrab_device_modifiers(const xcb_input_xi_passive_ungrab_device_request_t * R)11556 xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R)
11557 {
11558 return (uint32_t *) (R + 1);
11559 }
11560
11561 int
xcb_input_xi_passive_ungrab_device_modifiers_length(const xcb_input_xi_passive_ungrab_device_request_t * R)11562 xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R)
11563 {
11564 return R->num_modifiers;
11565 }
11566
11567 xcb_generic_iterator_t
xcb_input_xi_passive_ungrab_device_modifiers_end(const xcb_input_xi_passive_ungrab_device_request_t * R)11568 xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R)
11569 {
11570 xcb_generic_iterator_t i;
11571 i.data = ((uint32_t *) (R + 1)) + (R->num_modifiers);
11572 i.rem = 0;
11573 i.index = (char *) i.data - (char *) R;
11574 return i;
11575 }
11576
11577 int
xcb_input_xi_list_properties_sizeof(const void * _buffer)11578 xcb_input_xi_list_properties_sizeof (const void *_buffer)
11579 {
11580 char *xcb_tmp = (char *)_buffer;
11581 const xcb_input_xi_list_properties_reply_t *_aux = (xcb_input_xi_list_properties_reply_t *)_buffer;
11582 unsigned int xcb_buffer_len = 0;
11583 unsigned int xcb_block_len = 0;
11584 unsigned int xcb_pad = 0;
11585 unsigned int xcb_align_to = 0;
11586
11587
11588 xcb_block_len += sizeof(xcb_input_xi_list_properties_reply_t);
11589 xcb_tmp += xcb_block_len;
11590 xcb_buffer_len += xcb_block_len;
11591 xcb_block_len = 0;
11592 /* properties */
11593 xcb_block_len += _aux->num_properties * sizeof(xcb_atom_t);
11594 xcb_tmp += xcb_block_len;
11595 xcb_align_to = ALIGNOF(xcb_atom_t);
11596 /* insert padding */
11597 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11598 xcb_buffer_len += xcb_block_len + xcb_pad;
11599 if (0 != xcb_pad) {
11600 xcb_tmp += xcb_pad;
11601 xcb_pad = 0;
11602 }
11603 xcb_block_len = 0;
11604
11605 return xcb_buffer_len;
11606 }
11607
11608 xcb_input_xi_list_properties_cookie_t
xcb_input_xi_list_properties(xcb_connection_t * c,xcb_input_device_id_t deviceid)11609 xcb_input_xi_list_properties (xcb_connection_t *c,
11610 xcb_input_device_id_t deviceid)
11611 {
11612 static const xcb_protocol_request_t xcb_req = {
11613 .count = 2,
11614 .ext = &xcb_input_id,
11615 .opcode = XCB_INPUT_XI_LIST_PROPERTIES,
11616 .isvoid = 0
11617 };
11618
11619 struct iovec xcb_parts[4];
11620 xcb_input_xi_list_properties_cookie_t xcb_ret;
11621 xcb_input_xi_list_properties_request_t xcb_out;
11622
11623 xcb_out.deviceid = deviceid;
11624 memset(xcb_out.pad0, 0, 2);
11625
11626 xcb_parts[2].iov_base = (char *) &xcb_out;
11627 xcb_parts[2].iov_len = sizeof(xcb_out);
11628 xcb_parts[3].iov_base = 0;
11629 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11630
11631 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11632 return xcb_ret;
11633 }
11634
11635 xcb_input_xi_list_properties_cookie_t
xcb_input_xi_list_properties_unchecked(xcb_connection_t * c,xcb_input_device_id_t deviceid)11636 xcb_input_xi_list_properties_unchecked (xcb_connection_t *c,
11637 xcb_input_device_id_t deviceid)
11638 {
11639 static const xcb_protocol_request_t xcb_req = {
11640 .count = 2,
11641 .ext = &xcb_input_id,
11642 .opcode = XCB_INPUT_XI_LIST_PROPERTIES,
11643 .isvoid = 0
11644 };
11645
11646 struct iovec xcb_parts[4];
11647 xcb_input_xi_list_properties_cookie_t xcb_ret;
11648 xcb_input_xi_list_properties_request_t xcb_out;
11649
11650 xcb_out.deviceid = deviceid;
11651 memset(xcb_out.pad0, 0, 2);
11652
11653 xcb_parts[2].iov_base = (char *) &xcb_out;
11654 xcb_parts[2].iov_len = sizeof(xcb_out);
11655 xcb_parts[3].iov_base = 0;
11656 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11657
11658 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11659 return xcb_ret;
11660 }
11661
11662 xcb_atom_t *
xcb_input_xi_list_properties_properties(const xcb_input_xi_list_properties_reply_t * R)11663 xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R)
11664 {
11665 return (xcb_atom_t *) (R + 1);
11666 }
11667
11668 int
xcb_input_xi_list_properties_properties_length(const xcb_input_xi_list_properties_reply_t * R)11669 xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R)
11670 {
11671 return R->num_properties;
11672 }
11673
11674 xcb_generic_iterator_t
xcb_input_xi_list_properties_properties_end(const xcb_input_xi_list_properties_reply_t * R)11675 xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R)
11676 {
11677 xcb_generic_iterator_t i;
11678 i.data = ((xcb_atom_t *) (R + 1)) + (R->num_properties);
11679 i.rem = 0;
11680 i.index = (char *) i.data - (char *) R;
11681 return i;
11682 }
11683
11684 xcb_input_xi_list_properties_reply_t *
xcb_input_xi_list_properties_reply(xcb_connection_t * c,xcb_input_xi_list_properties_cookie_t cookie,xcb_generic_error_t ** e)11685 xcb_input_xi_list_properties_reply (xcb_connection_t *c,
11686 xcb_input_xi_list_properties_cookie_t cookie /**< */,
11687 xcb_generic_error_t **e)
11688 {
11689 return (xcb_input_xi_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11690 }
11691
11692 uint8_t *
xcb_input_xi_change_property_items_data_8(const xcb_input_xi_change_property_items_t * S)11693 xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S)
11694 {
11695 return S->data8;
11696 }
11697
11698 int
xcb_input_xi_change_property_items_data_8_length(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11699 xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R,
11700 const xcb_input_xi_change_property_items_t *S)
11701 {
11702 return R->num_items;
11703 }
11704
11705 xcb_generic_iterator_t
xcb_input_xi_change_property_items_data_8_end(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11706 xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R,
11707 const xcb_input_xi_change_property_items_t *S)
11708 {
11709 xcb_generic_iterator_t i;
11710 i.data = S->data8 + R->num_items;
11711 i.rem = 0;
11712 i.index = (char *) i.data - (char *) S;
11713 return i;
11714 }
11715
11716 uint16_t *
xcb_input_xi_change_property_items_data_16(const xcb_input_xi_change_property_items_t * S)11717 xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S)
11718 {
11719 return S->data16;
11720 }
11721
11722 int
xcb_input_xi_change_property_items_data_16_length(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11723 xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R,
11724 const xcb_input_xi_change_property_items_t *S)
11725 {
11726 return R->num_items;
11727 }
11728
11729 xcb_generic_iterator_t
xcb_input_xi_change_property_items_data_16_end(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11730 xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R,
11731 const xcb_input_xi_change_property_items_t *S)
11732 {
11733 xcb_generic_iterator_t i;
11734 i.data = S->data16 + R->num_items;
11735 i.rem = 0;
11736 i.index = (char *) i.data - (char *) S;
11737 return i;
11738 }
11739
11740 uint32_t *
xcb_input_xi_change_property_items_data_32(const xcb_input_xi_change_property_items_t * S)11741 xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S)
11742 {
11743 return S->data32;
11744 }
11745
11746 int
xcb_input_xi_change_property_items_data_32_length(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11747 xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R,
11748 const xcb_input_xi_change_property_items_t *S)
11749 {
11750 return R->num_items;
11751 }
11752
11753 xcb_generic_iterator_t
xcb_input_xi_change_property_items_data_32_end(const xcb_input_xi_change_property_request_t * R,const xcb_input_xi_change_property_items_t * S)11754 xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R,
11755 const xcb_input_xi_change_property_items_t *S)
11756 {
11757 xcb_generic_iterator_t i;
11758 i.data = S->data32 + R->num_items;
11759 i.rem = 0;
11760 i.index = (char *) i.data - (char *) S;
11761 return i;
11762 }
11763
11764 int
xcb_input_xi_change_property_items_serialize(void ** _buffer,uint32_t num_items,uint8_t format,const xcb_input_xi_change_property_items_t * _aux)11765 xcb_input_xi_change_property_items_serialize (void **_buffer,
11766 uint32_t num_items,
11767 uint8_t format,
11768 const xcb_input_xi_change_property_items_t *_aux)
11769 {
11770 char *xcb_out = *_buffer;
11771 unsigned int xcb_buffer_len = 0;
11772 unsigned int xcb_align_to = 0;
11773 unsigned int xcb_padding_offset = 0;
11774
11775 unsigned int xcb_pad = 0;
11776 char xcb_pad0[3] = {0, 0, 0};
11777 struct iovec xcb_parts[9];
11778 unsigned int xcb_parts_idx = 0;
11779 unsigned int xcb_block_len = 0;
11780 unsigned int i;
11781 char *xcb_tmp;
11782
11783 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
11784 /* insert padding */
11785 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11786 xcb_buffer_len += xcb_block_len + xcb_pad;
11787 if (0 != xcb_pad) {
11788 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11789 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11790 xcb_parts_idx++;
11791 xcb_pad = 0;
11792 }
11793 xcb_block_len = 0;
11794 xcb_padding_offset = 0;
11795 /* data8 */
11796 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
11797 xcb_block_len += num_items * sizeof(uint8_t);
11798 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
11799 xcb_parts_idx++;
11800 xcb_align_to = ALIGNOF(uint8_t);
11801 xcb_align_to = 4;
11802 /* insert padding */
11803 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11804 xcb_buffer_len += xcb_block_len + xcb_pad;
11805 if (0 != xcb_pad) {
11806 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11807 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11808 xcb_parts_idx++;
11809 xcb_pad = 0;
11810 }
11811 xcb_block_len = 0;
11812 xcb_padding_offset = 0;
11813 }
11814 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
11815 /* insert padding */
11816 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11817 xcb_buffer_len += xcb_block_len + xcb_pad;
11818 if (0 != xcb_pad) {
11819 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11820 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11821 xcb_parts_idx++;
11822 xcb_pad = 0;
11823 }
11824 xcb_block_len = 0;
11825 xcb_padding_offset = 0;
11826 /* data16 */
11827 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
11828 xcb_block_len += num_items * sizeof(uint16_t);
11829 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
11830 xcb_parts_idx++;
11831 xcb_align_to = ALIGNOF(uint16_t);
11832 xcb_align_to = 4;
11833 /* insert padding */
11834 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11835 xcb_buffer_len += xcb_block_len + xcb_pad;
11836 if (0 != xcb_pad) {
11837 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11838 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11839 xcb_parts_idx++;
11840 xcb_pad = 0;
11841 }
11842 xcb_block_len = 0;
11843 xcb_padding_offset = 0;
11844 }
11845 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
11846 /* insert padding */
11847 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11848 xcb_buffer_len += xcb_block_len + xcb_pad;
11849 if (0 != xcb_pad) {
11850 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11851 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11852 xcb_parts_idx++;
11853 xcb_pad = 0;
11854 }
11855 xcb_block_len = 0;
11856 xcb_padding_offset = 0;
11857 /* data32 */
11858 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
11859 xcb_block_len += num_items * sizeof(uint32_t);
11860 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
11861 xcb_parts_idx++;
11862 xcb_align_to = ALIGNOF(uint32_t);
11863 }
11864 /* insert padding */
11865 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11866 xcb_buffer_len += xcb_block_len + xcb_pad;
11867 if (0 != xcb_pad) {
11868 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
11869 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
11870 xcb_parts_idx++;
11871 xcb_pad = 0;
11872 }
11873 xcb_block_len = 0;
11874 xcb_padding_offset = 0;
11875
11876 if (NULL == xcb_out) {
11877 /* allocate memory */
11878 xcb_out = malloc(xcb_buffer_len);
11879 *_buffer = xcb_out;
11880 }
11881
11882 xcb_tmp = xcb_out;
11883 for(i=0; i<xcb_parts_idx; i++) {
11884 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
11885 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
11886 if (0 != xcb_parts[i].iov_len)
11887 xcb_tmp += xcb_parts[i].iov_len;
11888 }
11889
11890 return xcb_buffer_len;
11891 }
11892
11893 int
xcb_input_xi_change_property_items_unpack(const void * _buffer,uint32_t num_items,uint8_t format,xcb_input_xi_change_property_items_t * _aux)11894 xcb_input_xi_change_property_items_unpack (const void *_buffer,
11895 uint32_t num_items,
11896 uint8_t format,
11897 xcb_input_xi_change_property_items_t *_aux)
11898 {
11899 char *xcb_tmp = (char *)_buffer;
11900 unsigned int xcb_buffer_len = 0;
11901 unsigned int xcb_block_len = 0;
11902 unsigned int xcb_pad = 0;
11903 unsigned int xcb_align_to = 0;
11904 unsigned int xcb_padding_offset = 0;
11905
11906
11907 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
11908 /* insert padding */
11909 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11910 xcb_buffer_len += xcb_block_len + xcb_pad;
11911 if (0 != xcb_pad) {
11912 xcb_tmp += xcb_pad;
11913 xcb_pad = 0;
11914 }
11915 xcb_block_len = 0;
11916 xcb_padding_offset = 0;
11917 /* data8 */
11918 _aux->data8 = (uint8_t *)xcb_tmp;
11919 xcb_block_len += num_items * sizeof(uint8_t);
11920 xcb_tmp += xcb_block_len;
11921 xcb_align_to = ALIGNOF(uint8_t);
11922 xcb_align_to = 4;
11923 /* insert padding */
11924 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11925 xcb_buffer_len += xcb_block_len + xcb_pad;
11926 if (0 != xcb_pad) {
11927 xcb_tmp += xcb_pad;
11928 xcb_pad = 0;
11929 }
11930 xcb_block_len = 0;
11931 xcb_padding_offset = 0;
11932 }
11933 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
11934 /* insert padding */
11935 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11936 xcb_buffer_len += xcb_block_len + xcb_pad;
11937 if (0 != xcb_pad) {
11938 xcb_tmp += xcb_pad;
11939 xcb_pad = 0;
11940 }
11941 xcb_block_len = 0;
11942 xcb_padding_offset = 0;
11943 /* data16 */
11944 _aux->data16 = (uint16_t *)xcb_tmp;
11945 xcb_block_len += num_items * sizeof(uint16_t);
11946 xcb_tmp += xcb_block_len;
11947 xcb_align_to = ALIGNOF(uint16_t);
11948 xcb_align_to = 4;
11949 /* insert padding */
11950 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11951 xcb_buffer_len += xcb_block_len + xcb_pad;
11952 if (0 != xcb_pad) {
11953 xcb_tmp += xcb_pad;
11954 xcb_pad = 0;
11955 }
11956 xcb_block_len = 0;
11957 xcb_padding_offset = 0;
11958 }
11959 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
11960 /* insert padding */
11961 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11962 xcb_buffer_len += xcb_block_len + xcb_pad;
11963 if (0 != xcb_pad) {
11964 xcb_tmp += xcb_pad;
11965 xcb_pad = 0;
11966 }
11967 xcb_block_len = 0;
11968 xcb_padding_offset = 0;
11969 /* data32 */
11970 _aux->data32 = (uint32_t *)xcb_tmp;
11971 xcb_block_len += num_items * sizeof(uint32_t);
11972 xcb_tmp += xcb_block_len;
11973 xcb_align_to = ALIGNOF(uint32_t);
11974 }
11975 /* insert padding */
11976 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
11977 xcb_buffer_len += xcb_block_len + xcb_pad;
11978 if (0 != xcb_pad) {
11979 xcb_tmp += xcb_pad;
11980 xcb_pad = 0;
11981 }
11982 xcb_block_len = 0;
11983 xcb_padding_offset = 0;
11984
11985 return xcb_buffer_len;
11986 }
11987
11988 int
xcb_input_xi_change_property_items_sizeof(const void * _buffer,uint32_t num_items,uint8_t format)11989 xcb_input_xi_change_property_items_sizeof (const void *_buffer,
11990 uint32_t num_items,
11991 uint8_t format)
11992 {
11993 xcb_input_xi_change_property_items_t _aux;
11994 return xcb_input_xi_change_property_items_unpack(_buffer, num_items, format, &_aux);
11995 }
11996
11997 int
xcb_input_xi_change_property_sizeof(const void * _buffer)11998 xcb_input_xi_change_property_sizeof (const void *_buffer)
11999 {
12000 char *xcb_tmp = (char *)_buffer;
12001 const xcb_input_xi_change_property_request_t *_aux = (xcb_input_xi_change_property_request_t *)_buffer;
12002 unsigned int xcb_buffer_len = 0;
12003 unsigned int xcb_block_len = 0;
12004 unsigned int xcb_pad = 0;
12005 unsigned int xcb_align_to = 0;
12006
12007
12008 xcb_block_len += sizeof(xcb_input_xi_change_property_request_t);
12009 xcb_tmp += xcb_block_len;
12010 xcb_buffer_len += xcb_block_len;
12011 xcb_block_len = 0;
12012 /* items */
12013 xcb_block_len += xcb_input_xi_change_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
12014 xcb_tmp += xcb_block_len;
12015 xcb_align_to = ALIGNOF(char);
12016 /* insert padding */
12017 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12018 xcb_buffer_len += xcb_block_len + xcb_pad;
12019 if (0 != xcb_pad) {
12020 xcb_tmp += xcb_pad;
12021 xcb_pad = 0;
12022 }
12023 xcb_block_len = 0;
12024
12025 return xcb_buffer_len;
12026 }
12027
12028 xcb_void_cookie_t
xcb_input_xi_change_property_checked(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t format,xcb_atom_t property,xcb_atom_t type,uint32_t num_items,const void * items)12029 xcb_input_xi_change_property_checked (xcb_connection_t *c,
12030 xcb_input_device_id_t deviceid,
12031 uint8_t mode,
12032 uint8_t format,
12033 xcb_atom_t property,
12034 xcb_atom_t type,
12035 uint32_t num_items,
12036 const void *items)
12037 {
12038 static const xcb_protocol_request_t xcb_req = {
12039 .count = 3,
12040 .ext = &xcb_input_id,
12041 .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
12042 .isvoid = 1
12043 };
12044
12045 struct iovec xcb_parts[5];
12046 xcb_void_cookie_t xcb_ret;
12047 xcb_input_xi_change_property_request_t xcb_out;
12048
12049 xcb_out.deviceid = deviceid;
12050 xcb_out.mode = mode;
12051 xcb_out.format = format;
12052 xcb_out.property = property;
12053 xcb_out.type = type;
12054 xcb_out.num_items = num_items;
12055
12056 xcb_parts[2].iov_base = (char *) &xcb_out;
12057 xcb_parts[2].iov_len = sizeof(xcb_out);
12058 xcb_parts[3].iov_base = 0;
12059 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12060 /* xcb_input_xi_change_property_items_t items */
12061 xcb_parts[4].iov_base = (char *) items;
12062 xcb_parts[4].iov_len =
12063 xcb_input_xi_change_property_items_sizeof (items, num_items, format);
12064
12065 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12066 return xcb_ret;
12067 }
12068
12069 xcb_void_cookie_t
xcb_input_xi_change_property(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t format,xcb_atom_t property,xcb_atom_t type,uint32_t num_items,const void * items)12070 xcb_input_xi_change_property (xcb_connection_t *c,
12071 xcb_input_device_id_t deviceid,
12072 uint8_t mode,
12073 uint8_t format,
12074 xcb_atom_t property,
12075 xcb_atom_t type,
12076 uint32_t num_items,
12077 const void *items)
12078 {
12079 static const xcb_protocol_request_t xcb_req = {
12080 .count = 3,
12081 .ext = &xcb_input_id,
12082 .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
12083 .isvoid = 1
12084 };
12085
12086 struct iovec xcb_parts[5];
12087 xcb_void_cookie_t xcb_ret;
12088 xcb_input_xi_change_property_request_t xcb_out;
12089
12090 xcb_out.deviceid = deviceid;
12091 xcb_out.mode = mode;
12092 xcb_out.format = format;
12093 xcb_out.property = property;
12094 xcb_out.type = type;
12095 xcb_out.num_items = num_items;
12096
12097 xcb_parts[2].iov_base = (char *) &xcb_out;
12098 xcb_parts[2].iov_len = sizeof(xcb_out);
12099 xcb_parts[3].iov_base = 0;
12100 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12101 /* xcb_input_xi_change_property_items_t items */
12102 xcb_parts[4].iov_base = (char *) items;
12103 xcb_parts[4].iov_len =
12104 xcb_input_xi_change_property_items_sizeof (items, num_items, format);
12105
12106 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12107 return xcb_ret;
12108 }
12109
12110 xcb_void_cookie_t
xcb_input_xi_change_property_aux_checked(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t format,xcb_atom_t property,xcb_atom_t type,uint32_t num_items,const xcb_input_xi_change_property_items_t * items)12111 xcb_input_xi_change_property_aux_checked (xcb_connection_t *c,
12112 xcb_input_device_id_t deviceid,
12113 uint8_t mode,
12114 uint8_t format,
12115 xcb_atom_t property,
12116 xcb_atom_t type,
12117 uint32_t num_items,
12118 const xcb_input_xi_change_property_items_t *items)
12119 {
12120 static const xcb_protocol_request_t xcb_req = {
12121 .count = 3,
12122 .ext = &xcb_input_id,
12123 .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
12124 .isvoid = 1
12125 };
12126
12127 struct iovec xcb_parts[5];
12128 xcb_void_cookie_t xcb_ret;
12129 xcb_input_xi_change_property_request_t xcb_out;
12130 void *xcb_aux0 = 0;
12131
12132 xcb_out.deviceid = deviceid;
12133 xcb_out.mode = mode;
12134 xcb_out.format = format;
12135 xcb_out.property = property;
12136 xcb_out.type = type;
12137 xcb_out.num_items = num_items;
12138
12139 xcb_parts[2].iov_base = (char *) &xcb_out;
12140 xcb_parts[2].iov_len = sizeof(xcb_out);
12141 xcb_parts[3].iov_base = 0;
12142 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12143 /* xcb_input_xi_change_property_items_t items */
12144 xcb_parts[4].iov_len =
12145 xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items);
12146 xcb_parts[4].iov_base = xcb_aux0;
12147
12148 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12149 free(xcb_aux0);
12150 return xcb_ret;
12151 }
12152
12153 xcb_void_cookie_t
xcb_input_xi_change_property_aux(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t mode,uint8_t format,xcb_atom_t property,xcb_atom_t type,uint32_t num_items,const xcb_input_xi_change_property_items_t * items)12154 xcb_input_xi_change_property_aux (xcb_connection_t *c,
12155 xcb_input_device_id_t deviceid,
12156 uint8_t mode,
12157 uint8_t format,
12158 xcb_atom_t property,
12159 xcb_atom_t type,
12160 uint32_t num_items,
12161 const xcb_input_xi_change_property_items_t *items)
12162 {
12163 static const xcb_protocol_request_t xcb_req = {
12164 .count = 3,
12165 .ext = &xcb_input_id,
12166 .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
12167 .isvoid = 1
12168 };
12169
12170 struct iovec xcb_parts[5];
12171 xcb_void_cookie_t xcb_ret;
12172 xcb_input_xi_change_property_request_t xcb_out;
12173 void *xcb_aux0 = 0;
12174
12175 xcb_out.deviceid = deviceid;
12176 xcb_out.mode = mode;
12177 xcb_out.format = format;
12178 xcb_out.property = property;
12179 xcb_out.type = type;
12180 xcb_out.num_items = num_items;
12181
12182 xcb_parts[2].iov_base = (char *) &xcb_out;
12183 xcb_parts[2].iov_len = sizeof(xcb_out);
12184 xcb_parts[3].iov_base = 0;
12185 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12186 /* xcb_input_xi_change_property_items_t items */
12187 xcb_parts[4].iov_len =
12188 xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items);
12189 xcb_parts[4].iov_base = xcb_aux0;
12190
12191 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12192 free(xcb_aux0);
12193 return xcb_ret;
12194 }
12195
12196 void *
xcb_input_xi_change_property_items(const xcb_input_xi_change_property_request_t * R)12197 xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R)
12198 {
12199 return (void *) (R + 1);
12200 }
12201
12202 xcb_void_cookie_t
xcb_input_xi_delete_property_checked(xcb_connection_t * c,xcb_input_device_id_t deviceid,xcb_atom_t property)12203 xcb_input_xi_delete_property_checked (xcb_connection_t *c,
12204 xcb_input_device_id_t deviceid,
12205 xcb_atom_t property)
12206 {
12207 static const xcb_protocol_request_t xcb_req = {
12208 .count = 2,
12209 .ext = &xcb_input_id,
12210 .opcode = XCB_INPUT_XI_DELETE_PROPERTY,
12211 .isvoid = 1
12212 };
12213
12214 struct iovec xcb_parts[4];
12215 xcb_void_cookie_t xcb_ret;
12216 xcb_input_xi_delete_property_request_t xcb_out;
12217
12218 xcb_out.deviceid = deviceid;
12219 memset(xcb_out.pad0, 0, 2);
12220 xcb_out.property = property;
12221
12222 xcb_parts[2].iov_base = (char *) &xcb_out;
12223 xcb_parts[2].iov_len = sizeof(xcb_out);
12224 xcb_parts[3].iov_base = 0;
12225 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12226
12227 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12228 return xcb_ret;
12229 }
12230
12231 xcb_void_cookie_t
xcb_input_xi_delete_property(xcb_connection_t * c,xcb_input_device_id_t deviceid,xcb_atom_t property)12232 xcb_input_xi_delete_property (xcb_connection_t *c,
12233 xcb_input_device_id_t deviceid,
12234 xcb_atom_t property)
12235 {
12236 static const xcb_protocol_request_t xcb_req = {
12237 .count = 2,
12238 .ext = &xcb_input_id,
12239 .opcode = XCB_INPUT_XI_DELETE_PROPERTY,
12240 .isvoid = 1
12241 };
12242
12243 struct iovec xcb_parts[4];
12244 xcb_void_cookie_t xcb_ret;
12245 xcb_input_xi_delete_property_request_t xcb_out;
12246
12247 xcb_out.deviceid = deviceid;
12248 memset(xcb_out.pad0, 0, 2);
12249 xcb_out.property = property;
12250
12251 xcb_parts[2].iov_base = (char *) &xcb_out;
12252 xcb_parts[2].iov_len = sizeof(xcb_out);
12253 xcb_parts[3].iov_base = 0;
12254 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12255
12256 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12257 return xcb_ret;
12258 }
12259
12260 uint8_t *
xcb_input_xi_get_property_items_data_8(const xcb_input_xi_get_property_items_t * S)12261 xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S)
12262 {
12263 return S->data8;
12264 }
12265
12266 int
xcb_input_xi_get_property_items_data_8_length(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12267 xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R,
12268 const xcb_input_xi_get_property_items_t *S)
12269 {
12270 return R->num_items;
12271 }
12272
12273 xcb_generic_iterator_t
xcb_input_xi_get_property_items_data_8_end(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12274 xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R,
12275 const xcb_input_xi_get_property_items_t *S)
12276 {
12277 xcb_generic_iterator_t i;
12278 i.data = S->data8 + R->num_items;
12279 i.rem = 0;
12280 i.index = (char *) i.data - (char *) S;
12281 return i;
12282 }
12283
12284 uint16_t *
xcb_input_xi_get_property_items_data_16(const xcb_input_xi_get_property_items_t * S)12285 xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S)
12286 {
12287 return S->data16;
12288 }
12289
12290 int
xcb_input_xi_get_property_items_data_16_length(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12291 xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R,
12292 const xcb_input_xi_get_property_items_t *S)
12293 {
12294 return R->num_items;
12295 }
12296
12297 xcb_generic_iterator_t
xcb_input_xi_get_property_items_data_16_end(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12298 xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R,
12299 const xcb_input_xi_get_property_items_t *S)
12300 {
12301 xcb_generic_iterator_t i;
12302 i.data = S->data16 + R->num_items;
12303 i.rem = 0;
12304 i.index = (char *) i.data - (char *) S;
12305 return i;
12306 }
12307
12308 uint32_t *
xcb_input_xi_get_property_items_data_32(const xcb_input_xi_get_property_items_t * S)12309 xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S)
12310 {
12311 return S->data32;
12312 }
12313
12314 int
xcb_input_xi_get_property_items_data_32_length(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12315 xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R,
12316 const xcb_input_xi_get_property_items_t *S)
12317 {
12318 return R->num_items;
12319 }
12320
12321 xcb_generic_iterator_t
xcb_input_xi_get_property_items_data_32_end(const xcb_input_xi_get_property_reply_t * R,const xcb_input_xi_get_property_items_t * S)12322 xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R,
12323 const xcb_input_xi_get_property_items_t *S)
12324 {
12325 xcb_generic_iterator_t i;
12326 i.data = S->data32 + R->num_items;
12327 i.rem = 0;
12328 i.index = (char *) i.data - (char *) S;
12329 return i;
12330 }
12331
12332 int
xcb_input_xi_get_property_items_serialize(void ** _buffer,uint32_t num_items,uint8_t format,const xcb_input_xi_get_property_items_t * _aux)12333 xcb_input_xi_get_property_items_serialize (void **_buffer,
12334 uint32_t num_items,
12335 uint8_t format,
12336 const xcb_input_xi_get_property_items_t *_aux)
12337 {
12338 char *xcb_out = *_buffer;
12339 unsigned int xcb_buffer_len = 0;
12340 unsigned int xcb_align_to = 0;
12341 unsigned int xcb_padding_offset = 0;
12342
12343 unsigned int xcb_pad = 0;
12344 char xcb_pad0[3] = {0, 0, 0};
12345 struct iovec xcb_parts[9];
12346 unsigned int xcb_parts_idx = 0;
12347 unsigned int xcb_block_len = 0;
12348 unsigned int i;
12349 char *xcb_tmp;
12350
12351 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
12352 /* insert padding */
12353 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12354 xcb_buffer_len += xcb_block_len + xcb_pad;
12355 if (0 != xcb_pad) {
12356 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12357 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12358 xcb_parts_idx++;
12359 xcb_pad = 0;
12360 }
12361 xcb_block_len = 0;
12362 xcb_padding_offset = 0;
12363 /* data8 */
12364 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
12365 xcb_block_len += num_items * sizeof(uint8_t);
12366 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
12367 xcb_parts_idx++;
12368 xcb_align_to = ALIGNOF(uint8_t);
12369 xcb_align_to = 4;
12370 /* insert padding */
12371 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12372 xcb_buffer_len += xcb_block_len + xcb_pad;
12373 if (0 != xcb_pad) {
12374 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12375 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12376 xcb_parts_idx++;
12377 xcb_pad = 0;
12378 }
12379 xcb_block_len = 0;
12380 xcb_padding_offset = 0;
12381 }
12382 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
12383 /* insert padding */
12384 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12385 xcb_buffer_len += xcb_block_len + xcb_pad;
12386 if (0 != xcb_pad) {
12387 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12388 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12389 xcb_parts_idx++;
12390 xcb_pad = 0;
12391 }
12392 xcb_block_len = 0;
12393 xcb_padding_offset = 0;
12394 /* data16 */
12395 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
12396 xcb_block_len += num_items * sizeof(uint16_t);
12397 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
12398 xcb_parts_idx++;
12399 xcb_align_to = ALIGNOF(uint16_t);
12400 xcb_align_to = 4;
12401 /* insert padding */
12402 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12403 xcb_buffer_len += xcb_block_len + xcb_pad;
12404 if (0 != xcb_pad) {
12405 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12406 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12407 xcb_parts_idx++;
12408 xcb_pad = 0;
12409 }
12410 xcb_block_len = 0;
12411 xcb_padding_offset = 0;
12412 }
12413 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
12414 /* insert padding */
12415 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12416 xcb_buffer_len += xcb_block_len + xcb_pad;
12417 if (0 != xcb_pad) {
12418 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12419 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12420 xcb_parts_idx++;
12421 xcb_pad = 0;
12422 }
12423 xcb_block_len = 0;
12424 xcb_padding_offset = 0;
12425 /* data32 */
12426 xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
12427 xcb_block_len += num_items * sizeof(uint32_t);
12428 xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
12429 xcb_parts_idx++;
12430 xcb_align_to = ALIGNOF(uint32_t);
12431 }
12432 /* insert padding */
12433 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12434 xcb_buffer_len += xcb_block_len + xcb_pad;
12435 if (0 != xcb_pad) {
12436 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
12437 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
12438 xcb_parts_idx++;
12439 xcb_pad = 0;
12440 }
12441 xcb_block_len = 0;
12442 xcb_padding_offset = 0;
12443
12444 if (NULL == xcb_out) {
12445 /* allocate memory */
12446 xcb_out = malloc(xcb_buffer_len);
12447 *_buffer = xcb_out;
12448 }
12449
12450 xcb_tmp = xcb_out;
12451 for(i=0; i<xcb_parts_idx; i++) {
12452 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
12453 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
12454 if (0 != xcb_parts[i].iov_len)
12455 xcb_tmp += xcb_parts[i].iov_len;
12456 }
12457
12458 return xcb_buffer_len;
12459 }
12460
12461 int
xcb_input_xi_get_property_items_unpack(const void * _buffer,uint32_t num_items,uint8_t format,xcb_input_xi_get_property_items_t * _aux)12462 xcb_input_xi_get_property_items_unpack (const void *_buffer,
12463 uint32_t num_items,
12464 uint8_t format,
12465 xcb_input_xi_get_property_items_t *_aux)
12466 {
12467 char *xcb_tmp = (char *)_buffer;
12468 unsigned int xcb_buffer_len = 0;
12469 unsigned int xcb_block_len = 0;
12470 unsigned int xcb_pad = 0;
12471 unsigned int xcb_align_to = 0;
12472 unsigned int xcb_padding_offset = 0;
12473
12474
12475 if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
12476 /* insert padding */
12477 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12478 xcb_buffer_len += xcb_block_len + xcb_pad;
12479 if (0 != xcb_pad) {
12480 xcb_tmp += xcb_pad;
12481 xcb_pad = 0;
12482 }
12483 xcb_block_len = 0;
12484 xcb_padding_offset = 0;
12485 /* data8 */
12486 _aux->data8 = (uint8_t *)xcb_tmp;
12487 xcb_block_len += num_items * sizeof(uint8_t);
12488 xcb_tmp += xcb_block_len;
12489 xcb_align_to = ALIGNOF(uint8_t);
12490 xcb_align_to = 4;
12491 /* insert padding */
12492 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12493 xcb_buffer_len += xcb_block_len + xcb_pad;
12494 if (0 != xcb_pad) {
12495 xcb_tmp += xcb_pad;
12496 xcb_pad = 0;
12497 }
12498 xcb_block_len = 0;
12499 xcb_padding_offset = 0;
12500 }
12501 if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
12502 /* insert padding */
12503 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12504 xcb_buffer_len += xcb_block_len + xcb_pad;
12505 if (0 != xcb_pad) {
12506 xcb_tmp += xcb_pad;
12507 xcb_pad = 0;
12508 }
12509 xcb_block_len = 0;
12510 xcb_padding_offset = 0;
12511 /* data16 */
12512 _aux->data16 = (uint16_t *)xcb_tmp;
12513 xcb_block_len += num_items * sizeof(uint16_t);
12514 xcb_tmp += xcb_block_len;
12515 xcb_align_to = ALIGNOF(uint16_t);
12516 xcb_align_to = 4;
12517 /* insert padding */
12518 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12519 xcb_buffer_len += xcb_block_len + xcb_pad;
12520 if (0 != xcb_pad) {
12521 xcb_tmp += xcb_pad;
12522 xcb_pad = 0;
12523 }
12524 xcb_block_len = 0;
12525 xcb_padding_offset = 0;
12526 }
12527 if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
12528 /* insert padding */
12529 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12530 xcb_buffer_len += xcb_block_len + xcb_pad;
12531 if (0 != xcb_pad) {
12532 xcb_tmp += xcb_pad;
12533 xcb_pad = 0;
12534 }
12535 xcb_block_len = 0;
12536 xcb_padding_offset = 0;
12537 /* data32 */
12538 _aux->data32 = (uint32_t *)xcb_tmp;
12539 xcb_block_len += num_items * sizeof(uint32_t);
12540 xcb_tmp += xcb_block_len;
12541 xcb_align_to = ALIGNOF(uint32_t);
12542 }
12543 /* insert padding */
12544 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
12545 xcb_buffer_len += xcb_block_len + xcb_pad;
12546 if (0 != xcb_pad) {
12547 xcb_tmp += xcb_pad;
12548 xcb_pad = 0;
12549 }
12550 xcb_block_len = 0;
12551 xcb_padding_offset = 0;
12552
12553 return xcb_buffer_len;
12554 }
12555
12556 int
xcb_input_xi_get_property_items_sizeof(const void * _buffer,uint32_t num_items,uint8_t format)12557 xcb_input_xi_get_property_items_sizeof (const void *_buffer,
12558 uint32_t num_items,
12559 uint8_t format)
12560 {
12561 xcb_input_xi_get_property_items_t _aux;
12562 return xcb_input_xi_get_property_items_unpack(_buffer, num_items, format, &_aux);
12563 }
12564
12565 int
xcb_input_xi_get_property_sizeof(const void * _buffer)12566 xcb_input_xi_get_property_sizeof (const void *_buffer)
12567 {
12568 char *xcb_tmp = (char *)_buffer;
12569 const xcb_input_xi_get_property_reply_t *_aux = (xcb_input_xi_get_property_reply_t *)_buffer;
12570 unsigned int xcb_buffer_len = 0;
12571 unsigned int xcb_block_len = 0;
12572 unsigned int xcb_pad = 0;
12573 unsigned int xcb_align_to = 0;
12574
12575
12576 xcb_block_len += sizeof(xcb_input_xi_get_property_reply_t);
12577 xcb_tmp += xcb_block_len;
12578 xcb_buffer_len += xcb_block_len;
12579 xcb_block_len = 0;
12580 /* items */
12581 xcb_block_len += xcb_input_xi_get_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
12582 xcb_tmp += xcb_block_len;
12583 xcb_align_to = ALIGNOF(char);
12584 /* insert padding */
12585 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12586 xcb_buffer_len += xcb_block_len + xcb_pad;
12587 if (0 != xcb_pad) {
12588 xcb_tmp += xcb_pad;
12589 xcb_pad = 0;
12590 }
12591 xcb_block_len = 0;
12592
12593 return xcb_buffer_len;
12594 }
12595
12596 xcb_input_xi_get_property_cookie_t
xcb_input_xi_get_property(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t _delete,xcb_atom_t property,xcb_atom_t type,uint32_t offset,uint32_t len)12597 xcb_input_xi_get_property (xcb_connection_t *c,
12598 xcb_input_device_id_t deviceid,
12599 uint8_t _delete,
12600 xcb_atom_t property,
12601 xcb_atom_t type,
12602 uint32_t offset,
12603 uint32_t len)
12604 {
12605 static const xcb_protocol_request_t xcb_req = {
12606 .count = 2,
12607 .ext = &xcb_input_id,
12608 .opcode = XCB_INPUT_XI_GET_PROPERTY,
12609 .isvoid = 0
12610 };
12611
12612 struct iovec xcb_parts[4];
12613 xcb_input_xi_get_property_cookie_t xcb_ret;
12614 xcb_input_xi_get_property_request_t xcb_out;
12615
12616 xcb_out.deviceid = deviceid;
12617 xcb_out._delete = _delete;
12618 xcb_out.pad0 = 0;
12619 xcb_out.property = property;
12620 xcb_out.type = type;
12621 xcb_out.offset = offset;
12622 xcb_out.len = len;
12623
12624 xcb_parts[2].iov_base = (char *) &xcb_out;
12625 xcb_parts[2].iov_len = sizeof(xcb_out);
12626 xcb_parts[3].iov_base = 0;
12627 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12628
12629 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12630 return xcb_ret;
12631 }
12632
12633 xcb_input_xi_get_property_cookie_t
xcb_input_xi_get_property_unchecked(xcb_connection_t * c,xcb_input_device_id_t deviceid,uint8_t _delete,xcb_atom_t property,xcb_atom_t type,uint32_t offset,uint32_t len)12634 xcb_input_xi_get_property_unchecked (xcb_connection_t *c,
12635 xcb_input_device_id_t deviceid,
12636 uint8_t _delete,
12637 xcb_atom_t property,
12638 xcb_atom_t type,
12639 uint32_t offset,
12640 uint32_t len)
12641 {
12642 static const xcb_protocol_request_t xcb_req = {
12643 .count = 2,
12644 .ext = &xcb_input_id,
12645 .opcode = XCB_INPUT_XI_GET_PROPERTY,
12646 .isvoid = 0
12647 };
12648
12649 struct iovec xcb_parts[4];
12650 xcb_input_xi_get_property_cookie_t xcb_ret;
12651 xcb_input_xi_get_property_request_t xcb_out;
12652
12653 xcb_out.deviceid = deviceid;
12654 xcb_out._delete = _delete;
12655 xcb_out.pad0 = 0;
12656 xcb_out.property = property;
12657 xcb_out.type = type;
12658 xcb_out.offset = offset;
12659 xcb_out.len = len;
12660
12661 xcb_parts[2].iov_base = (char *) &xcb_out;
12662 xcb_parts[2].iov_len = sizeof(xcb_out);
12663 xcb_parts[3].iov_base = 0;
12664 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12665
12666 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12667 return xcb_ret;
12668 }
12669
12670 void *
xcb_input_xi_get_property_items(const xcb_input_xi_get_property_reply_t * R)12671 xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R)
12672 {
12673 return (void *) (R + 1);
12674 }
12675
12676 xcb_input_xi_get_property_reply_t *
xcb_input_xi_get_property_reply(xcb_connection_t * c,xcb_input_xi_get_property_cookie_t cookie,xcb_generic_error_t ** e)12677 xcb_input_xi_get_property_reply (xcb_connection_t *c,
12678 xcb_input_xi_get_property_cookie_t cookie /**< */,
12679 xcb_generic_error_t **e)
12680 {
12681 return (xcb_input_xi_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12682 }
12683
12684 int
xcb_input_xi_get_selected_events_sizeof(const void * _buffer)12685 xcb_input_xi_get_selected_events_sizeof (const void *_buffer)
12686 {
12687 char *xcb_tmp = (char *)_buffer;
12688 const xcb_input_xi_get_selected_events_reply_t *_aux = (xcb_input_xi_get_selected_events_reply_t *)_buffer;
12689 unsigned int xcb_buffer_len = 0;
12690 unsigned int xcb_block_len = 0;
12691 unsigned int xcb_pad = 0;
12692 unsigned int xcb_align_to = 0;
12693
12694 unsigned int i;
12695 unsigned int xcb_tmp_len;
12696
12697 xcb_block_len += sizeof(xcb_input_xi_get_selected_events_reply_t);
12698 xcb_tmp += xcb_block_len;
12699 xcb_buffer_len += xcb_block_len;
12700 xcb_block_len = 0;
12701 /* masks */
12702 for(i=0; i<_aux->num_masks; i++) {
12703 xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
12704 xcb_block_len += xcb_tmp_len;
12705 xcb_tmp += xcb_tmp_len;
12706 }
12707 xcb_align_to = ALIGNOF(xcb_input_event_mask_t);
12708 /* insert padding */
12709 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12710 xcb_buffer_len += xcb_block_len + xcb_pad;
12711 if (0 != xcb_pad) {
12712 xcb_tmp += xcb_pad;
12713 xcb_pad = 0;
12714 }
12715 xcb_block_len = 0;
12716
12717 return xcb_buffer_len;
12718 }
12719
12720 xcb_input_xi_get_selected_events_cookie_t
xcb_input_xi_get_selected_events(xcb_connection_t * c,xcb_window_t window)12721 xcb_input_xi_get_selected_events (xcb_connection_t *c,
12722 xcb_window_t window)
12723 {
12724 static const xcb_protocol_request_t xcb_req = {
12725 .count = 2,
12726 .ext = &xcb_input_id,
12727 .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS,
12728 .isvoid = 0
12729 };
12730
12731 struct iovec xcb_parts[4];
12732 xcb_input_xi_get_selected_events_cookie_t xcb_ret;
12733 xcb_input_xi_get_selected_events_request_t xcb_out;
12734
12735 xcb_out.window = window;
12736
12737 xcb_parts[2].iov_base = (char *) &xcb_out;
12738 xcb_parts[2].iov_len = sizeof(xcb_out);
12739 xcb_parts[3].iov_base = 0;
12740 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12741
12742 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12743 return xcb_ret;
12744 }
12745
12746 xcb_input_xi_get_selected_events_cookie_t
xcb_input_xi_get_selected_events_unchecked(xcb_connection_t * c,xcb_window_t window)12747 xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c,
12748 xcb_window_t window)
12749 {
12750 static const xcb_protocol_request_t xcb_req = {
12751 .count = 2,
12752 .ext = &xcb_input_id,
12753 .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS,
12754 .isvoid = 0
12755 };
12756
12757 struct iovec xcb_parts[4];
12758 xcb_input_xi_get_selected_events_cookie_t xcb_ret;
12759 xcb_input_xi_get_selected_events_request_t xcb_out;
12760
12761 xcb_out.window = window;
12762
12763 xcb_parts[2].iov_base = (char *) &xcb_out;
12764 xcb_parts[2].iov_len = sizeof(xcb_out);
12765 xcb_parts[3].iov_base = 0;
12766 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12767
12768 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12769 return xcb_ret;
12770 }
12771
12772 int
xcb_input_xi_get_selected_events_masks_length(const xcb_input_xi_get_selected_events_reply_t * R)12773 xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R)
12774 {
12775 return R->num_masks;
12776 }
12777
12778 xcb_input_event_mask_iterator_t
xcb_input_xi_get_selected_events_masks_iterator(const xcb_input_xi_get_selected_events_reply_t * R)12779 xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R)
12780 {
12781 xcb_input_event_mask_iterator_t i;
12782 i.data = (xcb_input_event_mask_t *) (R + 1);
12783 i.rem = R->num_masks;
12784 i.index = (char *) i.data - (char *) R;
12785 return i;
12786 }
12787
12788 xcb_input_xi_get_selected_events_reply_t *
xcb_input_xi_get_selected_events_reply(xcb_connection_t * c,xcb_input_xi_get_selected_events_cookie_t cookie,xcb_generic_error_t ** e)12789 xcb_input_xi_get_selected_events_reply (xcb_connection_t *c,
12790 xcb_input_xi_get_selected_events_cookie_t cookie /**< */,
12791 xcb_generic_error_t **e)
12792 {
12793 return (xcb_input_xi_get_selected_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
12794 }
12795
12796 void
xcb_input_barrier_release_pointer_info_next(xcb_input_barrier_release_pointer_info_iterator_t * i)12797 xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i)
12798 {
12799 --i->rem;
12800 ++i->data;
12801 i->index += sizeof(xcb_input_barrier_release_pointer_info_t);
12802 }
12803
12804 xcb_generic_iterator_t
xcb_input_barrier_release_pointer_info_end(xcb_input_barrier_release_pointer_info_iterator_t i)12805 xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i)
12806 {
12807 xcb_generic_iterator_t ret;
12808 ret.data = i.data + i.rem;
12809 ret.index = i.index + ((char *) ret.data - (char *) i.data);
12810 ret.rem = 0;
12811 return ret;
12812 }
12813
12814 int
xcb_input_xi_barrier_release_pointer_sizeof(const void * _buffer)12815 xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer)
12816 {
12817 char *xcb_tmp = (char *)_buffer;
12818 const xcb_input_xi_barrier_release_pointer_request_t *_aux = (xcb_input_xi_barrier_release_pointer_request_t *)_buffer;
12819 unsigned int xcb_buffer_len = 0;
12820 unsigned int xcb_block_len = 0;
12821 unsigned int xcb_pad = 0;
12822 unsigned int xcb_align_to = 0;
12823
12824
12825 xcb_block_len += sizeof(xcb_input_xi_barrier_release_pointer_request_t);
12826 xcb_tmp += xcb_block_len;
12827 xcb_buffer_len += xcb_block_len;
12828 xcb_block_len = 0;
12829 /* barriers */
12830 xcb_block_len += _aux->num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
12831 xcb_tmp += xcb_block_len;
12832 xcb_align_to = ALIGNOF(xcb_input_barrier_release_pointer_info_t);
12833 /* insert padding */
12834 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12835 xcb_buffer_len += xcb_block_len + xcb_pad;
12836 if (0 != xcb_pad) {
12837 xcb_tmp += xcb_pad;
12838 xcb_pad = 0;
12839 }
12840 xcb_block_len = 0;
12841
12842 return xcb_buffer_len;
12843 }
12844
12845 xcb_void_cookie_t
xcb_input_xi_barrier_release_pointer_checked(xcb_connection_t * c,uint32_t num_barriers,const xcb_input_barrier_release_pointer_info_t * barriers)12846 xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t *c,
12847 uint32_t num_barriers,
12848 const xcb_input_barrier_release_pointer_info_t *barriers)
12849 {
12850 static const xcb_protocol_request_t xcb_req = {
12851 .count = 4,
12852 .ext = &xcb_input_id,
12853 .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER,
12854 .isvoid = 1
12855 };
12856
12857 struct iovec xcb_parts[6];
12858 xcb_void_cookie_t xcb_ret;
12859 xcb_input_xi_barrier_release_pointer_request_t xcb_out;
12860
12861 xcb_out.num_barriers = num_barriers;
12862
12863 xcb_parts[2].iov_base = (char *) &xcb_out;
12864 xcb_parts[2].iov_len = sizeof(xcb_out);
12865 xcb_parts[3].iov_base = 0;
12866 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12867 /* xcb_input_barrier_release_pointer_info_t barriers */
12868 xcb_parts[4].iov_base = (char *) barriers;
12869 xcb_parts[4].iov_len = num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
12870 xcb_parts[5].iov_base = 0;
12871 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12872
12873 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
12874 return xcb_ret;
12875 }
12876
12877 xcb_void_cookie_t
xcb_input_xi_barrier_release_pointer(xcb_connection_t * c,uint32_t num_barriers,const xcb_input_barrier_release_pointer_info_t * barriers)12878 xcb_input_xi_barrier_release_pointer (xcb_connection_t *c,
12879 uint32_t num_barriers,
12880 const xcb_input_barrier_release_pointer_info_t *barriers)
12881 {
12882 static const xcb_protocol_request_t xcb_req = {
12883 .count = 4,
12884 .ext = &xcb_input_id,
12885 .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER,
12886 .isvoid = 1
12887 };
12888
12889 struct iovec xcb_parts[6];
12890 xcb_void_cookie_t xcb_ret;
12891 xcb_input_xi_barrier_release_pointer_request_t xcb_out;
12892
12893 xcb_out.num_barriers = num_barriers;
12894
12895 xcb_parts[2].iov_base = (char *) &xcb_out;
12896 xcb_parts[2].iov_len = sizeof(xcb_out);
12897 xcb_parts[3].iov_base = 0;
12898 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
12899 /* xcb_input_barrier_release_pointer_info_t barriers */
12900 xcb_parts[4].iov_base = (char *) barriers;
12901 xcb_parts[4].iov_len = num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
12902 xcb_parts[5].iov_base = 0;
12903 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
12904
12905 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
12906 return xcb_ret;
12907 }
12908
12909 xcb_input_barrier_release_pointer_info_t *
xcb_input_xi_barrier_release_pointer_barriers(const xcb_input_xi_barrier_release_pointer_request_t * R)12910 xcb_input_xi_barrier_release_pointer_barriers (const xcb_input_xi_barrier_release_pointer_request_t *R)
12911 {
12912 return (xcb_input_barrier_release_pointer_info_t *) (R + 1);
12913 }
12914
12915 int
xcb_input_xi_barrier_release_pointer_barriers_length(const xcb_input_xi_barrier_release_pointer_request_t * R)12916 xcb_input_xi_barrier_release_pointer_barriers_length (const xcb_input_xi_barrier_release_pointer_request_t *R)
12917 {
12918 return R->num_barriers;
12919 }
12920
12921 xcb_input_barrier_release_pointer_info_iterator_t
xcb_input_xi_barrier_release_pointer_barriers_iterator(const xcb_input_xi_barrier_release_pointer_request_t * R)12922 xcb_input_xi_barrier_release_pointer_barriers_iterator (const xcb_input_xi_barrier_release_pointer_request_t *R)
12923 {
12924 xcb_input_barrier_release_pointer_info_iterator_t i;
12925 i.data = (xcb_input_barrier_release_pointer_info_t *) (R + 1);
12926 i.rem = R->num_barriers;
12927 i.index = (char *) i.data - (char *) R;
12928 return i;
12929 }
12930
12931 int
xcb_input_device_changed_sizeof(const void * _buffer)12932 xcb_input_device_changed_sizeof (const void *_buffer)
12933 {
12934 char *xcb_tmp = (char *)_buffer;
12935 const xcb_input_device_changed_event_t *_aux = (xcb_input_device_changed_event_t *)_buffer;
12936 unsigned int xcb_buffer_len = 0;
12937 unsigned int xcb_block_len = 0;
12938 unsigned int xcb_pad = 0;
12939 unsigned int xcb_align_to = 0;
12940
12941 unsigned int i;
12942 unsigned int xcb_tmp_len;
12943
12944 xcb_block_len += sizeof(xcb_input_device_changed_event_t);
12945 xcb_tmp += xcb_block_len;
12946 xcb_buffer_len += xcb_block_len;
12947 xcb_block_len = 0;
12948 /* classes */
12949 for(i=0; i<_aux->num_classes; i++) {
12950 xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp);
12951 xcb_block_len += xcb_tmp_len;
12952 xcb_tmp += xcb_tmp_len;
12953 }
12954 xcb_align_to = ALIGNOF(xcb_input_device_class_t);
12955 /* insert padding */
12956 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
12957 xcb_buffer_len += xcb_block_len + xcb_pad;
12958 if (0 != xcb_pad) {
12959 xcb_tmp += xcb_pad;
12960 xcb_pad = 0;
12961 }
12962 xcb_block_len = 0;
12963
12964 return xcb_buffer_len;
12965 }
12966
12967 int
xcb_input_device_changed_classes_length(const xcb_input_device_changed_event_t * R)12968 xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R)
12969 {
12970 return R->num_classes;
12971 }
12972
12973 xcb_input_device_class_iterator_t
xcb_input_device_changed_classes_iterator(const xcb_input_device_changed_event_t * R)12974 xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R)
12975 {
12976 xcb_input_device_class_iterator_t i;
12977 i.data = (xcb_input_device_class_t *) (R + 1);
12978 i.rem = R->num_classes;
12979 i.index = (char *) i.data - (char *) R;
12980 return i;
12981 }
12982
12983 int
xcb_input_key_press_sizeof(const void * _buffer)12984 xcb_input_key_press_sizeof (const void *_buffer)
12985 {
12986 char *xcb_tmp = (char *)_buffer;
12987 const xcb_input_key_press_event_t *_aux = (xcb_input_key_press_event_t *)_buffer;
12988 unsigned int xcb_buffer_len = 0;
12989 unsigned int xcb_block_len = 0;
12990 unsigned int xcb_pad = 0;
12991 unsigned int xcb_align_to = 0;
12992
12993 int xcb_pre_tmp_1; /* sumof length */
12994 int xcb_pre_tmp_2; /* sumof loop counter */
12995 int64_t xcb_pre_tmp_3; /* sumof sum */
12996 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
12997
12998 xcb_block_len += sizeof(xcb_input_key_press_event_t);
12999 xcb_tmp += xcb_block_len;
13000 xcb_buffer_len += xcb_block_len;
13001 xcb_block_len = 0;
13002 /* button_mask */
13003 xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
13004 xcb_tmp += xcb_block_len;
13005 xcb_align_to = ALIGNOF(uint32_t);
13006 /* insert padding */
13007 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13008 xcb_buffer_len += xcb_block_len + xcb_pad;
13009 if (0 != xcb_pad) {
13010 xcb_tmp += xcb_pad;
13011 xcb_pad = 0;
13012 }
13013 xcb_block_len = 0;
13014 /* valuator_mask */
13015 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
13016 xcb_tmp += xcb_block_len;
13017 xcb_align_to = ALIGNOF(uint32_t);
13018 /* insert padding */
13019 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13020 xcb_buffer_len += xcb_block_len + xcb_pad;
13021 if (0 != xcb_pad) {
13022 xcb_tmp += xcb_pad;
13023 xcb_pad = 0;
13024 }
13025 xcb_block_len = 0;
13026 /* axisvalues */
13027 /* sumof start */
13028 xcb_pre_tmp_1 = _aux->valuators_len;
13029 xcb_pre_tmp_3 = 0;
13030 xcb_pre_tmp_4 = xcb_input_key_press_valuator_mask(_aux);
13031 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
13032 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
13033 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
13034 xcb_pre_tmp_4++;
13035 }
13036 /* sumof end. Result is in xcb_pre_tmp_3 */
13037 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
13038 xcb_tmp += xcb_block_len;
13039 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13040 /* insert padding */
13041 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13042 xcb_buffer_len += xcb_block_len + xcb_pad;
13043 if (0 != xcb_pad) {
13044 xcb_tmp += xcb_pad;
13045 xcb_pad = 0;
13046 }
13047 xcb_block_len = 0;
13048
13049 return xcb_buffer_len;
13050 }
13051
13052 uint32_t *
xcb_input_key_press_button_mask(const xcb_input_key_press_event_t * R)13053 xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R)
13054 {
13055 return (uint32_t *) (R + 1);
13056 }
13057
13058 int
xcb_input_key_press_button_mask_length(const xcb_input_key_press_event_t * R)13059 xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R)
13060 {
13061 return R->buttons_len;
13062 }
13063
13064 xcb_generic_iterator_t
xcb_input_key_press_button_mask_end(const xcb_input_key_press_event_t * R)13065 xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R)
13066 {
13067 xcb_generic_iterator_t i;
13068 i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
13069 i.rem = 0;
13070 i.index = (char *) i.data - (char *) R;
13071 return i;
13072 }
13073
13074 uint32_t *
xcb_input_key_press_valuator_mask(const xcb_input_key_press_event_t * R)13075 xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R)
13076 {
13077 xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R);
13078 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
13079 }
13080
13081 int
xcb_input_key_press_valuator_mask_length(const xcb_input_key_press_event_t * R)13082 xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R)
13083 {
13084 return R->valuators_len;
13085 }
13086
13087 xcb_generic_iterator_t
xcb_input_key_press_valuator_mask_end(const xcb_input_key_press_event_t * R)13088 xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R)
13089 {
13090 xcb_generic_iterator_t i;
13091 xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R);
13092 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
13093 i.rem = 0;
13094 i.index = (char *) i.data - (char *) R;
13095 return i;
13096 }
13097
13098 xcb_input_fp3232_t *
xcb_input_key_press_axisvalues(const xcb_input_key_press_event_t * R)13099 xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R)
13100 {
13101 xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R);
13102 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13103 }
13104
13105 int
xcb_input_key_press_axisvalues_length(const xcb_input_key_press_event_t * R)13106 xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R)
13107 {
13108 int xcb_pre_tmp_5; /* sumof length */
13109 int xcb_pre_tmp_6; /* sumof loop counter */
13110 int64_t xcb_pre_tmp_7; /* sumof sum */
13111 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
13112 /* sumof start */
13113 xcb_pre_tmp_5 = R->valuators_len;
13114 xcb_pre_tmp_7 = 0;
13115 xcb_pre_tmp_8 = xcb_input_key_press_valuator_mask(R);
13116 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
13117 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
13118 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
13119 xcb_pre_tmp_8++;
13120 }
13121 /* sumof end. Result is in xcb_pre_tmp_7 */
13122 return xcb_pre_tmp_7;
13123 }
13124
13125 xcb_input_fp3232_iterator_t
xcb_input_key_press_axisvalues_iterator(const xcb_input_key_press_event_t * R)13126 xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R)
13127 {
13128 xcb_input_fp3232_iterator_t i;
13129 xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R);
13130 int xcb_pre_tmp_9; /* sumof length */
13131 int xcb_pre_tmp_10; /* sumof loop counter */
13132 int64_t xcb_pre_tmp_11; /* sumof sum */
13133 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
13134 /* sumof start */
13135 xcb_pre_tmp_9 = R->valuators_len;
13136 xcb_pre_tmp_11 = 0;
13137 xcb_pre_tmp_12 = xcb_input_key_press_valuator_mask(R);
13138 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
13139 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
13140 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
13141 xcb_pre_tmp_12++;
13142 }
13143 /* sumof end. Result is in xcb_pre_tmp_11 */
13144 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13145 i.rem = xcb_pre_tmp_11;
13146 i.index = (char *) i.data - (char *) R;
13147 return i;
13148 }
13149
13150 int
xcb_input_key_release_sizeof(const void * _buffer)13151 xcb_input_key_release_sizeof (const void *_buffer /**< */)
13152 {
13153 return xcb_input_key_press_sizeof(_buffer);
13154 }
13155
13156 int
xcb_input_button_press_sizeof(const void * _buffer)13157 xcb_input_button_press_sizeof (const void *_buffer)
13158 {
13159 char *xcb_tmp = (char *)_buffer;
13160 const xcb_input_button_press_event_t *_aux = (xcb_input_button_press_event_t *)_buffer;
13161 unsigned int xcb_buffer_len = 0;
13162 unsigned int xcb_block_len = 0;
13163 unsigned int xcb_pad = 0;
13164 unsigned int xcb_align_to = 0;
13165
13166 int xcb_pre_tmp_1; /* sumof length */
13167 int xcb_pre_tmp_2; /* sumof loop counter */
13168 int64_t xcb_pre_tmp_3; /* sumof sum */
13169 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
13170
13171 xcb_block_len += sizeof(xcb_input_button_press_event_t);
13172 xcb_tmp += xcb_block_len;
13173 xcb_buffer_len += xcb_block_len;
13174 xcb_block_len = 0;
13175 /* button_mask */
13176 xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
13177 xcb_tmp += xcb_block_len;
13178 xcb_align_to = ALIGNOF(uint32_t);
13179 /* insert padding */
13180 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13181 xcb_buffer_len += xcb_block_len + xcb_pad;
13182 if (0 != xcb_pad) {
13183 xcb_tmp += xcb_pad;
13184 xcb_pad = 0;
13185 }
13186 xcb_block_len = 0;
13187 /* valuator_mask */
13188 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
13189 xcb_tmp += xcb_block_len;
13190 xcb_align_to = ALIGNOF(uint32_t);
13191 /* insert padding */
13192 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13193 xcb_buffer_len += xcb_block_len + xcb_pad;
13194 if (0 != xcb_pad) {
13195 xcb_tmp += xcb_pad;
13196 xcb_pad = 0;
13197 }
13198 xcb_block_len = 0;
13199 /* axisvalues */
13200 /* sumof start */
13201 xcb_pre_tmp_1 = _aux->valuators_len;
13202 xcb_pre_tmp_3 = 0;
13203 xcb_pre_tmp_4 = xcb_input_button_press_valuator_mask(_aux);
13204 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
13205 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
13206 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
13207 xcb_pre_tmp_4++;
13208 }
13209 /* sumof end. Result is in xcb_pre_tmp_3 */
13210 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
13211 xcb_tmp += xcb_block_len;
13212 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13213 /* insert padding */
13214 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13215 xcb_buffer_len += xcb_block_len + xcb_pad;
13216 if (0 != xcb_pad) {
13217 xcb_tmp += xcb_pad;
13218 xcb_pad = 0;
13219 }
13220 xcb_block_len = 0;
13221
13222 return xcb_buffer_len;
13223 }
13224
13225 uint32_t *
xcb_input_button_press_button_mask(const xcb_input_button_press_event_t * R)13226 xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R)
13227 {
13228 return (uint32_t *) (R + 1);
13229 }
13230
13231 int
xcb_input_button_press_button_mask_length(const xcb_input_button_press_event_t * R)13232 xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R)
13233 {
13234 return R->buttons_len;
13235 }
13236
13237 xcb_generic_iterator_t
xcb_input_button_press_button_mask_end(const xcb_input_button_press_event_t * R)13238 xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R)
13239 {
13240 xcb_generic_iterator_t i;
13241 i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
13242 i.rem = 0;
13243 i.index = (char *) i.data - (char *) R;
13244 return i;
13245 }
13246
13247 uint32_t *
xcb_input_button_press_valuator_mask(const xcb_input_button_press_event_t * R)13248 xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R)
13249 {
13250 xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R);
13251 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
13252 }
13253
13254 int
xcb_input_button_press_valuator_mask_length(const xcb_input_button_press_event_t * R)13255 xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R)
13256 {
13257 return R->valuators_len;
13258 }
13259
13260 xcb_generic_iterator_t
xcb_input_button_press_valuator_mask_end(const xcb_input_button_press_event_t * R)13261 xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R)
13262 {
13263 xcb_generic_iterator_t i;
13264 xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R);
13265 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
13266 i.rem = 0;
13267 i.index = (char *) i.data - (char *) R;
13268 return i;
13269 }
13270
13271 xcb_input_fp3232_t *
xcb_input_button_press_axisvalues(const xcb_input_button_press_event_t * R)13272 xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R)
13273 {
13274 xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R);
13275 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13276 }
13277
13278 int
xcb_input_button_press_axisvalues_length(const xcb_input_button_press_event_t * R)13279 xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R)
13280 {
13281 int xcb_pre_tmp_5; /* sumof length */
13282 int xcb_pre_tmp_6; /* sumof loop counter */
13283 int64_t xcb_pre_tmp_7; /* sumof sum */
13284 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
13285 /* sumof start */
13286 xcb_pre_tmp_5 = R->valuators_len;
13287 xcb_pre_tmp_7 = 0;
13288 xcb_pre_tmp_8 = xcb_input_button_press_valuator_mask(R);
13289 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
13290 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
13291 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
13292 xcb_pre_tmp_8++;
13293 }
13294 /* sumof end. Result is in xcb_pre_tmp_7 */
13295 return xcb_pre_tmp_7;
13296 }
13297
13298 xcb_input_fp3232_iterator_t
xcb_input_button_press_axisvalues_iterator(const xcb_input_button_press_event_t * R)13299 xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R)
13300 {
13301 xcb_input_fp3232_iterator_t i;
13302 xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R);
13303 int xcb_pre_tmp_9; /* sumof length */
13304 int xcb_pre_tmp_10; /* sumof loop counter */
13305 int64_t xcb_pre_tmp_11; /* sumof sum */
13306 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
13307 /* sumof start */
13308 xcb_pre_tmp_9 = R->valuators_len;
13309 xcb_pre_tmp_11 = 0;
13310 xcb_pre_tmp_12 = xcb_input_button_press_valuator_mask(R);
13311 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
13312 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
13313 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
13314 xcb_pre_tmp_12++;
13315 }
13316 /* sumof end. Result is in xcb_pre_tmp_11 */
13317 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13318 i.rem = xcb_pre_tmp_11;
13319 i.index = (char *) i.data - (char *) R;
13320 return i;
13321 }
13322
13323 int
xcb_input_button_release_sizeof(const void * _buffer)13324 xcb_input_button_release_sizeof (const void *_buffer /**< */)
13325 {
13326 return xcb_input_button_press_sizeof(_buffer);
13327 }
13328
13329 int
xcb_input_motion_sizeof(const void * _buffer)13330 xcb_input_motion_sizeof (const void *_buffer /**< */)
13331 {
13332 return xcb_input_button_press_sizeof(_buffer);
13333 }
13334
13335 int
xcb_input_enter_sizeof(const void * _buffer)13336 xcb_input_enter_sizeof (const void *_buffer)
13337 {
13338 char *xcb_tmp = (char *)_buffer;
13339 const xcb_input_enter_event_t *_aux = (xcb_input_enter_event_t *)_buffer;
13340 unsigned int xcb_buffer_len = 0;
13341 unsigned int xcb_block_len = 0;
13342 unsigned int xcb_pad = 0;
13343 unsigned int xcb_align_to = 0;
13344
13345
13346 xcb_block_len += sizeof(xcb_input_enter_event_t);
13347 xcb_tmp += xcb_block_len;
13348 xcb_buffer_len += xcb_block_len;
13349 xcb_block_len = 0;
13350 /* buttons */
13351 xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
13352 xcb_tmp += xcb_block_len;
13353 xcb_align_to = ALIGNOF(uint32_t);
13354 /* insert padding */
13355 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13356 xcb_buffer_len += xcb_block_len + xcb_pad;
13357 if (0 != xcb_pad) {
13358 xcb_tmp += xcb_pad;
13359 xcb_pad = 0;
13360 }
13361 xcb_block_len = 0;
13362
13363 return xcb_buffer_len;
13364 }
13365
13366 uint32_t *
xcb_input_enter_buttons(const xcb_input_enter_event_t * R)13367 xcb_input_enter_buttons (const xcb_input_enter_event_t *R)
13368 {
13369 return (uint32_t *) (R + 1);
13370 }
13371
13372 int
xcb_input_enter_buttons_length(const xcb_input_enter_event_t * R)13373 xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R)
13374 {
13375 return R->buttons_len;
13376 }
13377
13378 xcb_generic_iterator_t
xcb_input_enter_buttons_end(const xcb_input_enter_event_t * R)13379 xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R)
13380 {
13381 xcb_generic_iterator_t i;
13382 i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
13383 i.rem = 0;
13384 i.index = (char *) i.data - (char *) R;
13385 return i;
13386 }
13387
13388 int
xcb_input_leave_sizeof(const void * _buffer)13389 xcb_input_leave_sizeof (const void *_buffer /**< */)
13390 {
13391 return xcb_input_enter_sizeof(_buffer);
13392 }
13393
13394 int
xcb_input_focus_in_sizeof(const void * _buffer)13395 xcb_input_focus_in_sizeof (const void *_buffer /**< */)
13396 {
13397 return xcb_input_enter_sizeof(_buffer);
13398 }
13399
13400 int
xcb_input_focus_out_sizeof(const void * _buffer)13401 xcb_input_focus_out_sizeof (const void *_buffer /**< */)
13402 {
13403 return xcb_input_enter_sizeof(_buffer);
13404 }
13405
13406 void
xcb_input_hierarchy_info_next(xcb_input_hierarchy_info_iterator_t * i)13407 xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i)
13408 {
13409 --i->rem;
13410 ++i->data;
13411 i->index += sizeof(xcb_input_hierarchy_info_t);
13412 }
13413
13414 xcb_generic_iterator_t
xcb_input_hierarchy_info_end(xcb_input_hierarchy_info_iterator_t i)13415 xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i)
13416 {
13417 xcb_generic_iterator_t ret;
13418 ret.data = i.data + i.rem;
13419 ret.index = i.index + ((char *) ret.data - (char *) i.data);
13420 ret.rem = 0;
13421 return ret;
13422 }
13423
13424 int
xcb_input_hierarchy_sizeof(const void * _buffer)13425 xcb_input_hierarchy_sizeof (const void *_buffer)
13426 {
13427 char *xcb_tmp = (char *)_buffer;
13428 const xcb_input_hierarchy_event_t *_aux = (xcb_input_hierarchy_event_t *)_buffer;
13429 unsigned int xcb_buffer_len = 0;
13430 unsigned int xcb_block_len = 0;
13431 unsigned int xcb_pad = 0;
13432 unsigned int xcb_align_to = 0;
13433
13434
13435 xcb_block_len += sizeof(xcb_input_hierarchy_event_t);
13436 xcb_tmp += xcb_block_len;
13437 xcb_buffer_len += xcb_block_len;
13438 xcb_block_len = 0;
13439 /* infos */
13440 xcb_block_len += _aux->num_infos * sizeof(xcb_input_hierarchy_info_t);
13441 xcb_tmp += xcb_block_len;
13442 xcb_align_to = ALIGNOF(xcb_input_hierarchy_info_t);
13443 /* insert padding */
13444 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13445 xcb_buffer_len += xcb_block_len + xcb_pad;
13446 if (0 != xcb_pad) {
13447 xcb_tmp += xcb_pad;
13448 xcb_pad = 0;
13449 }
13450 xcb_block_len = 0;
13451
13452 return xcb_buffer_len;
13453 }
13454
13455 xcb_input_hierarchy_info_t *
xcb_input_hierarchy_infos(const xcb_input_hierarchy_event_t * R)13456 xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R)
13457 {
13458 return (xcb_input_hierarchy_info_t *) (R + 1);
13459 }
13460
13461 int
xcb_input_hierarchy_infos_length(const xcb_input_hierarchy_event_t * R)13462 xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R)
13463 {
13464 return R->num_infos;
13465 }
13466
13467 xcb_input_hierarchy_info_iterator_t
xcb_input_hierarchy_infos_iterator(const xcb_input_hierarchy_event_t * R)13468 xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R)
13469 {
13470 xcb_input_hierarchy_info_iterator_t i;
13471 i.data = (xcb_input_hierarchy_info_t *) (R + 1);
13472 i.rem = R->num_infos;
13473 i.index = (char *) i.data - (char *) R;
13474 return i;
13475 }
13476
13477 int
xcb_input_raw_key_press_sizeof(const void * _buffer)13478 xcb_input_raw_key_press_sizeof (const void *_buffer)
13479 {
13480 char *xcb_tmp = (char *)_buffer;
13481 const xcb_input_raw_key_press_event_t *_aux = (xcb_input_raw_key_press_event_t *)_buffer;
13482 unsigned int xcb_buffer_len = 0;
13483 unsigned int xcb_block_len = 0;
13484 unsigned int xcb_pad = 0;
13485 unsigned int xcb_align_to = 0;
13486
13487 int xcb_pre_tmp_1; /* sumof length */
13488 int xcb_pre_tmp_2; /* sumof loop counter */
13489 int64_t xcb_pre_tmp_3; /* sumof sum */
13490 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
13491 int xcb_pre_tmp_5; /* sumof length */
13492 int xcb_pre_tmp_6; /* sumof loop counter */
13493 int64_t xcb_pre_tmp_7; /* sumof sum */
13494 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
13495
13496 xcb_block_len += sizeof(xcb_input_raw_key_press_event_t);
13497 xcb_tmp += xcb_block_len;
13498 xcb_buffer_len += xcb_block_len;
13499 xcb_block_len = 0;
13500 /* valuator_mask */
13501 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
13502 xcb_tmp += xcb_block_len;
13503 xcb_align_to = ALIGNOF(uint32_t);
13504 /* insert padding */
13505 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13506 xcb_buffer_len += xcb_block_len + xcb_pad;
13507 if (0 != xcb_pad) {
13508 xcb_tmp += xcb_pad;
13509 xcb_pad = 0;
13510 }
13511 xcb_block_len = 0;
13512 /* axisvalues */
13513 /* sumof start */
13514 xcb_pre_tmp_1 = _aux->valuators_len;
13515 xcb_pre_tmp_3 = 0;
13516 xcb_pre_tmp_4 = xcb_input_raw_key_press_valuator_mask(_aux);
13517 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
13518 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
13519 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
13520 xcb_pre_tmp_4++;
13521 }
13522 /* sumof end. Result is in xcb_pre_tmp_3 */
13523 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
13524 xcb_tmp += xcb_block_len;
13525 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13526 /* insert padding */
13527 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13528 xcb_buffer_len += xcb_block_len + xcb_pad;
13529 if (0 != xcb_pad) {
13530 xcb_tmp += xcb_pad;
13531 xcb_pad = 0;
13532 }
13533 xcb_block_len = 0;
13534 /* axisvalues_raw */
13535 /* sumof start */
13536 xcb_pre_tmp_5 = _aux->valuators_len;
13537 xcb_pre_tmp_7 = 0;
13538 xcb_pre_tmp_8 = xcb_input_raw_key_press_valuator_mask(_aux);
13539 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
13540 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
13541 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
13542 xcb_pre_tmp_8++;
13543 }
13544 /* sumof end. Result is in xcb_pre_tmp_7 */
13545 xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
13546 xcb_tmp += xcb_block_len;
13547 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13548 /* insert padding */
13549 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13550 xcb_buffer_len += xcb_block_len + xcb_pad;
13551 if (0 != xcb_pad) {
13552 xcb_tmp += xcb_pad;
13553 xcb_pad = 0;
13554 }
13555 xcb_block_len = 0;
13556
13557 return xcb_buffer_len;
13558 }
13559
13560 uint32_t *
xcb_input_raw_key_press_valuator_mask(const xcb_input_raw_key_press_event_t * R)13561 xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R)
13562 {
13563 return (uint32_t *) (R + 1);
13564 }
13565
13566 int
xcb_input_raw_key_press_valuator_mask_length(const xcb_input_raw_key_press_event_t * R)13567 xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R)
13568 {
13569 return R->valuators_len;
13570 }
13571
13572 xcb_generic_iterator_t
xcb_input_raw_key_press_valuator_mask_end(const xcb_input_raw_key_press_event_t * R)13573 xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R)
13574 {
13575 xcb_generic_iterator_t i;
13576 i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
13577 i.rem = 0;
13578 i.index = (char *) i.data - (char *) R;
13579 return i;
13580 }
13581
13582 xcb_input_fp3232_t *
xcb_input_raw_key_press_axisvalues(const xcb_input_raw_key_press_event_t * R)13583 xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R)
13584 {
13585 xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R);
13586 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13587 }
13588
13589 int
xcb_input_raw_key_press_axisvalues_length(const xcb_input_raw_key_press_event_t * R)13590 xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R)
13591 {
13592 int xcb_pre_tmp_9; /* sumof length */
13593 int xcb_pre_tmp_10; /* sumof loop counter */
13594 int64_t xcb_pre_tmp_11; /* sumof sum */
13595 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
13596 /* sumof start */
13597 xcb_pre_tmp_9 = R->valuators_len;
13598 xcb_pre_tmp_11 = 0;
13599 xcb_pre_tmp_12 = xcb_input_raw_key_press_valuator_mask(R);
13600 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
13601 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
13602 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
13603 xcb_pre_tmp_12++;
13604 }
13605 /* sumof end. Result is in xcb_pre_tmp_11 */
13606 return xcb_pre_tmp_11;
13607 }
13608
13609 xcb_input_fp3232_iterator_t
xcb_input_raw_key_press_axisvalues_iterator(const xcb_input_raw_key_press_event_t * R)13610 xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R)
13611 {
13612 xcb_input_fp3232_iterator_t i;
13613 xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R);
13614 int xcb_pre_tmp_13; /* sumof length */
13615 int xcb_pre_tmp_14; /* sumof loop counter */
13616 int64_t xcb_pre_tmp_15; /* sumof sum */
13617 const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
13618 /* sumof start */
13619 xcb_pre_tmp_13 = R->valuators_len;
13620 xcb_pre_tmp_15 = 0;
13621 xcb_pre_tmp_16 = xcb_input_raw_key_press_valuator_mask(R);
13622 for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
13623 const uint32_t *xcb_listelement = xcb_pre_tmp_16;
13624 xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
13625 xcb_pre_tmp_16++;
13626 }
13627 /* sumof end. Result is in xcb_pre_tmp_15 */
13628 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13629 i.rem = xcb_pre_tmp_15;
13630 i.index = (char *) i.data - (char *) R;
13631 return i;
13632 }
13633
13634 xcb_input_fp3232_t *
xcb_input_raw_key_press_axisvalues_raw(const xcb_input_raw_key_press_event_t * R)13635 xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R)
13636 {
13637 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R));
13638 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13639 }
13640
13641 int
xcb_input_raw_key_press_axisvalues_raw_length(const xcb_input_raw_key_press_event_t * R)13642 xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R)
13643 {
13644 int xcb_pre_tmp_17; /* sumof length */
13645 int xcb_pre_tmp_18; /* sumof loop counter */
13646 int64_t xcb_pre_tmp_19; /* sumof sum */
13647 const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
13648 /* sumof start */
13649 xcb_pre_tmp_17 = R->valuators_len;
13650 xcb_pre_tmp_19 = 0;
13651 xcb_pre_tmp_20 = xcb_input_raw_key_press_valuator_mask(R);
13652 for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
13653 const uint32_t *xcb_listelement = xcb_pre_tmp_20;
13654 xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
13655 xcb_pre_tmp_20++;
13656 }
13657 /* sumof end. Result is in xcb_pre_tmp_19 */
13658 return xcb_pre_tmp_19;
13659 }
13660
13661 xcb_input_fp3232_iterator_t
xcb_input_raw_key_press_axisvalues_raw_iterator(const xcb_input_raw_key_press_event_t * R)13662 xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R)
13663 {
13664 xcb_input_fp3232_iterator_t i;
13665 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R));
13666 int xcb_pre_tmp_21; /* sumof length */
13667 int xcb_pre_tmp_22; /* sumof loop counter */
13668 int64_t xcb_pre_tmp_23; /* sumof sum */
13669 const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
13670 /* sumof start */
13671 xcb_pre_tmp_21 = R->valuators_len;
13672 xcb_pre_tmp_23 = 0;
13673 xcb_pre_tmp_24 = xcb_input_raw_key_press_valuator_mask(R);
13674 for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
13675 const uint32_t *xcb_listelement = xcb_pre_tmp_24;
13676 xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
13677 xcb_pre_tmp_24++;
13678 }
13679 /* sumof end. Result is in xcb_pre_tmp_23 */
13680 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13681 i.rem = xcb_pre_tmp_23;
13682 i.index = (char *) i.data - (char *) R;
13683 return i;
13684 }
13685
13686 int
xcb_input_raw_key_release_sizeof(const void * _buffer)13687 xcb_input_raw_key_release_sizeof (const void *_buffer /**< */)
13688 {
13689 return xcb_input_raw_key_press_sizeof(_buffer);
13690 }
13691
13692 int
xcb_input_raw_button_press_sizeof(const void * _buffer)13693 xcb_input_raw_button_press_sizeof (const void *_buffer)
13694 {
13695 char *xcb_tmp = (char *)_buffer;
13696 const xcb_input_raw_button_press_event_t *_aux = (xcb_input_raw_button_press_event_t *)_buffer;
13697 unsigned int xcb_buffer_len = 0;
13698 unsigned int xcb_block_len = 0;
13699 unsigned int xcb_pad = 0;
13700 unsigned int xcb_align_to = 0;
13701
13702 int xcb_pre_tmp_1; /* sumof length */
13703 int xcb_pre_tmp_2; /* sumof loop counter */
13704 int64_t xcb_pre_tmp_3; /* sumof sum */
13705 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
13706 int xcb_pre_tmp_5; /* sumof length */
13707 int xcb_pre_tmp_6; /* sumof loop counter */
13708 int64_t xcb_pre_tmp_7; /* sumof sum */
13709 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
13710
13711 xcb_block_len += sizeof(xcb_input_raw_button_press_event_t);
13712 xcb_tmp += xcb_block_len;
13713 xcb_buffer_len += xcb_block_len;
13714 xcb_block_len = 0;
13715 /* valuator_mask */
13716 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
13717 xcb_tmp += xcb_block_len;
13718 xcb_align_to = ALIGNOF(uint32_t);
13719 /* insert padding */
13720 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13721 xcb_buffer_len += xcb_block_len + xcb_pad;
13722 if (0 != xcb_pad) {
13723 xcb_tmp += xcb_pad;
13724 xcb_pad = 0;
13725 }
13726 xcb_block_len = 0;
13727 /* axisvalues */
13728 /* sumof start */
13729 xcb_pre_tmp_1 = _aux->valuators_len;
13730 xcb_pre_tmp_3 = 0;
13731 xcb_pre_tmp_4 = xcb_input_raw_button_press_valuator_mask(_aux);
13732 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
13733 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
13734 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
13735 xcb_pre_tmp_4++;
13736 }
13737 /* sumof end. Result is in xcb_pre_tmp_3 */
13738 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
13739 xcb_tmp += xcb_block_len;
13740 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13741 /* insert padding */
13742 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13743 xcb_buffer_len += xcb_block_len + xcb_pad;
13744 if (0 != xcb_pad) {
13745 xcb_tmp += xcb_pad;
13746 xcb_pad = 0;
13747 }
13748 xcb_block_len = 0;
13749 /* axisvalues_raw */
13750 /* sumof start */
13751 xcb_pre_tmp_5 = _aux->valuators_len;
13752 xcb_pre_tmp_7 = 0;
13753 xcb_pre_tmp_8 = xcb_input_raw_button_press_valuator_mask(_aux);
13754 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
13755 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
13756 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
13757 xcb_pre_tmp_8++;
13758 }
13759 /* sumof end. Result is in xcb_pre_tmp_7 */
13760 xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
13761 xcb_tmp += xcb_block_len;
13762 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13763 /* insert padding */
13764 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13765 xcb_buffer_len += xcb_block_len + xcb_pad;
13766 if (0 != xcb_pad) {
13767 xcb_tmp += xcb_pad;
13768 xcb_pad = 0;
13769 }
13770 xcb_block_len = 0;
13771
13772 return xcb_buffer_len;
13773 }
13774
13775 uint32_t *
xcb_input_raw_button_press_valuator_mask(const xcb_input_raw_button_press_event_t * R)13776 xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R)
13777 {
13778 return (uint32_t *) (R + 1);
13779 }
13780
13781 int
xcb_input_raw_button_press_valuator_mask_length(const xcb_input_raw_button_press_event_t * R)13782 xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R)
13783 {
13784 return R->valuators_len;
13785 }
13786
13787 xcb_generic_iterator_t
xcb_input_raw_button_press_valuator_mask_end(const xcb_input_raw_button_press_event_t * R)13788 xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R)
13789 {
13790 xcb_generic_iterator_t i;
13791 i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
13792 i.rem = 0;
13793 i.index = (char *) i.data - (char *) R;
13794 return i;
13795 }
13796
13797 xcb_input_fp3232_t *
xcb_input_raw_button_press_axisvalues(const xcb_input_raw_button_press_event_t * R)13798 xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R)
13799 {
13800 xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R);
13801 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13802 }
13803
13804 int
xcb_input_raw_button_press_axisvalues_length(const xcb_input_raw_button_press_event_t * R)13805 xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R)
13806 {
13807 int xcb_pre_tmp_9; /* sumof length */
13808 int xcb_pre_tmp_10; /* sumof loop counter */
13809 int64_t xcb_pre_tmp_11; /* sumof sum */
13810 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
13811 /* sumof start */
13812 xcb_pre_tmp_9 = R->valuators_len;
13813 xcb_pre_tmp_11 = 0;
13814 xcb_pre_tmp_12 = xcb_input_raw_button_press_valuator_mask(R);
13815 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
13816 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
13817 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
13818 xcb_pre_tmp_12++;
13819 }
13820 /* sumof end. Result is in xcb_pre_tmp_11 */
13821 return xcb_pre_tmp_11;
13822 }
13823
13824 xcb_input_fp3232_iterator_t
xcb_input_raw_button_press_axisvalues_iterator(const xcb_input_raw_button_press_event_t * R)13825 xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R)
13826 {
13827 xcb_input_fp3232_iterator_t i;
13828 xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R);
13829 int xcb_pre_tmp_13; /* sumof length */
13830 int xcb_pre_tmp_14; /* sumof loop counter */
13831 int64_t xcb_pre_tmp_15; /* sumof sum */
13832 const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
13833 /* sumof start */
13834 xcb_pre_tmp_13 = R->valuators_len;
13835 xcb_pre_tmp_15 = 0;
13836 xcb_pre_tmp_16 = xcb_input_raw_button_press_valuator_mask(R);
13837 for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
13838 const uint32_t *xcb_listelement = xcb_pre_tmp_16;
13839 xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
13840 xcb_pre_tmp_16++;
13841 }
13842 /* sumof end. Result is in xcb_pre_tmp_15 */
13843 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13844 i.rem = xcb_pre_tmp_15;
13845 i.index = (char *) i.data - (char *) R;
13846 return i;
13847 }
13848
13849 xcb_input_fp3232_t *
xcb_input_raw_button_press_axisvalues_raw(const xcb_input_raw_button_press_event_t * R)13850 xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R)
13851 {
13852 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R));
13853 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
13854 }
13855
13856 int
xcb_input_raw_button_press_axisvalues_raw_length(const xcb_input_raw_button_press_event_t * R)13857 xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R)
13858 {
13859 int xcb_pre_tmp_17; /* sumof length */
13860 int xcb_pre_tmp_18; /* sumof loop counter */
13861 int64_t xcb_pre_tmp_19; /* sumof sum */
13862 const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
13863 /* sumof start */
13864 xcb_pre_tmp_17 = R->valuators_len;
13865 xcb_pre_tmp_19 = 0;
13866 xcb_pre_tmp_20 = xcb_input_raw_button_press_valuator_mask(R);
13867 for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
13868 const uint32_t *xcb_listelement = xcb_pre_tmp_20;
13869 xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
13870 xcb_pre_tmp_20++;
13871 }
13872 /* sumof end. Result is in xcb_pre_tmp_19 */
13873 return xcb_pre_tmp_19;
13874 }
13875
13876 xcb_input_fp3232_iterator_t
xcb_input_raw_button_press_axisvalues_raw_iterator(const xcb_input_raw_button_press_event_t * R)13877 xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R)
13878 {
13879 xcb_input_fp3232_iterator_t i;
13880 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R));
13881 int xcb_pre_tmp_21; /* sumof length */
13882 int xcb_pre_tmp_22; /* sumof loop counter */
13883 int64_t xcb_pre_tmp_23; /* sumof sum */
13884 const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
13885 /* sumof start */
13886 xcb_pre_tmp_21 = R->valuators_len;
13887 xcb_pre_tmp_23 = 0;
13888 xcb_pre_tmp_24 = xcb_input_raw_button_press_valuator_mask(R);
13889 for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
13890 const uint32_t *xcb_listelement = xcb_pre_tmp_24;
13891 xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
13892 xcb_pre_tmp_24++;
13893 }
13894 /* sumof end. Result is in xcb_pre_tmp_23 */
13895 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
13896 i.rem = xcb_pre_tmp_23;
13897 i.index = (char *) i.data - (char *) R;
13898 return i;
13899 }
13900
13901 int
xcb_input_raw_button_release_sizeof(const void * _buffer)13902 xcb_input_raw_button_release_sizeof (const void *_buffer /**< */)
13903 {
13904 return xcb_input_raw_button_press_sizeof(_buffer);
13905 }
13906
13907 int
xcb_input_raw_motion_sizeof(const void * _buffer)13908 xcb_input_raw_motion_sizeof (const void *_buffer /**< */)
13909 {
13910 return xcb_input_raw_button_press_sizeof(_buffer);
13911 }
13912
13913 int
xcb_input_touch_begin_sizeof(const void * _buffer)13914 xcb_input_touch_begin_sizeof (const void *_buffer)
13915 {
13916 char *xcb_tmp = (char *)_buffer;
13917 const xcb_input_touch_begin_event_t *_aux = (xcb_input_touch_begin_event_t *)_buffer;
13918 unsigned int xcb_buffer_len = 0;
13919 unsigned int xcb_block_len = 0;
13920 unsigned int xcb_pad = 0;
13921 unsigned int xcb_align_to = 0;
13922
13923 int xcb_pre_tmp_1; /* sumof length */
13924 int xcb_pre_tmp_2; /* sumof loop counter */
13925 int64_t xcb_pre_tmp_3; /* sumof sum */
13926 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
13927
13928 xcb_block_len += sizeof(xcb_input_touch_begin_event_t);
13929 xcb_tmp += xcb_block_len;
13930 xcb_buffer_len += xcb_block_len;
13931 xcb_block_len = 0;
13932 /* button_mask */
13933 xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
13934 xcb_tmp += xcb_block_len;
13935 xcb_align_to = ALIGNOF(uint32_t);
13936 /* insert padding */
13937 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13938 xcb_buffer_len += xcb_block_len + xcb_pad;
13939 if (0 != xcb_pad) {
13940 xcb_tmp += xcb_pad;
13941 xcb_pad = 0;
13942 }
13943 xcb_block_len = 0;
13944 /* valuator_mask */
13945 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
13946 xcb_tmp += xcb_block_len;
13947 xcb_align_to = ALIGNOF(uint32_t);
13948 /* insert padding */
13949 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13950 xcb_buffer_len += xcb_block_len + xcb_pad;
13951 if (0 != xcb_pad) {
13952 xcb_tmp += xcb_pad;
13953 xcb_pad = 0;
13954 }
13955 xcb_block_len = 0;
13956 /* axisvalues */
13957 /* sumof start */
13958 xcb_pre_tmp_1 = _aux->valuators_len;
13959 xcb_pre_tmp_3 = 0;
13960 xcb_pre_tmp_4 = xcb_input_touch_begin_valuator_mask(_aux);
13961 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
13962 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
13963 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
13964 xcb_pre_tmp_4++;
13965 }
13966 /* sumof end. Result is in xcb_pre_tmp_3 */
13967 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
13968 xcb_tmp += xcb_block_len;
13969 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
13970 /* insert padding */
13971 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
13972 xcb_buffer_len += xcb_block_len + xcb_pad;
13973 if (0 != xcb_pad) {
13974 xcb_tmp += xcb_pad;
13975 xcb_pad = 0;
13976 }
13977 xcb_block_len = 0;
13978
13979 return xcb_buffer_len;
13980 }
13981
13982 uint32_t *
xcb_input_touch_begin_button_mask(const xcb_input_touch_begin_event_t * R)13983 xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R)
13984 {
13985 return (uint32_t *) (R + 1);
13986 }
13987
13988 int
xcb_input_touch_begin_button_mask_length(const xcb_input_touch_begin_event_t * R)13989 xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R)
13990 {
13991 return R->buttons_len;
13992 }
13993
13994 xcb_generic_iterator_t
xcb_input_touch_begin_button_mask_end(const xcb_input_touch_begin_event_t * R)13995 xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R)
13996 {
13997 xcb_generic_iterator_t i;
13998 i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
13999 i.rem = 0;
14000 i.index = (char *) i.data - (char *) R;
14001 return i;
14002 }
14003
14004 uint32_t *
xcb_input_touch_begin_valuator_mask(const xcb_input_touch_begin_event_t * R)14005 xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R)
14006 {
14007 xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R);
14008 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
14009 }
14010
14011 int
xcb_input_touch_begin_valuator_mask_length(const xcb_input_touch_begin_event_t * R)14012 xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R)
14013 {
14014 return R->valuators_len;
14015 }
14016
14017 xcb_generic_iterator_t
xcb_input_touch_begin_valuator_mask_end(const xcb_input_touch_begin_event_t * R)14018 xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R)
14019 {
14020 xcb_generic_iterator_t i;
14021 xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R);
14022 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
14023 i.rem = 0;
14024 i.index = (char *) i.data - (char *) R;
14025 return i;
14026 }
14027
14028 xcb_input_fp3232_t *
xcb_input_touch_begin_axisvalues(const xcb_input_touch_begin_event_t * R)14029 xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R)
14030 {
14031 xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R);
14032 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
14033 }
14034
14035 int
xcb_input_touch_begin_axisvalues_length(const xcb_input_touch_begin_event_t * R)14036 xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R)
14037 {
14038 int xcb_pre_tmp_5; /* sumof length */
14039 int xcb_pre_tmp_6; /* sumof loop counter */
14040 int64_t xcb_pre_tmp_7; /* sumof sum */
14041 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
14042 /* sumof start */
14043 xcb_pre_tmp_5 = R->valuators_len;
14044 xcb_pre_tmp_7 = 0;
14045 xcb_pre_tmp_8 = xcb_input_touch_begin_valuator_mask(R);
14046 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
14047 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
14048 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
14049 xcb_pre_tmp_8++;
14050 }
14051 /* sumof end. Result is in xcb_pre_tmp_7 */
14052 return xcb_pre_tmp_7;
14053 }
14054
14055 xcb_input_fp3232_iterator_t
xcb_input_touch_begin_axisvalues_iterator(const xcb_input_touch_begin_event_t * R)14056 xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R)
14057 {
14058 xcb_input_fp3232_iterator_t i;
14059 xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R);
14060 int xcb_pre_tmp_9; /* sumof length */
14061 int xcb_pre_tmp_10; /* sumof loop counter */
14062 int64_t xcb_pre_tmp_11; /* sumof sum */
14063 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
14064 /* sumof start */
14065 xcb_pre_tmp_9 = R->valuators_len;
14066 xcb_pre_tmp_11 = 0;
14067 xcb_pre_tmp_12 = xcb_input_touch_begin_valuator_mask(R);
14068 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
14069 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
14070 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
14071 xcb_pre_tmp_12++;
14072 }
14073 /* sumof end. Result is in xcb_pre_tmp_11 */
14074 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
14075 i.rem = xcb_pre_tmp_11;
14076 i.index = (char *) i.data - (char *) R;
14077 return i;
14078 }
14079
14080 int
xcb_input_touch_update_sizeof(const void * _buffer)14081 xcb_input_touch_update_sizeof (const void *_buffer /**< */)
14082 {
14083 return xcb_input_touch_begin_sizeof(_buffer);
14084 }
14085
14086 int
xcb_input_touch_end_sizeof(const void * _buffer)14087 xcb_input_touch_end_sizeof (const void *_buffer /**< */)
14088 {
14089 return xcb_input_touch_begin_sizeof(_buffer);
14090 }
14091
14092 int
xcb_input_raw_touch_begin_sizeof(const void * _buffer)14093 xcb_input_raw_touch_begin_sizeof (const void *_buffer)
14094 {
14095 char *xcb_tmp = (char *)_buffer;
14096 const xcb_input_raw_touch_begin_event_t *_aux = (xcb_input_raw_touch_begin_event_t *)_buffer;
14097 unsigned int xcb_buffer_len = 0;
14098 unsigned int xcb_block_len = 0;
14099 unsigned int xcb_pad = 0;
14100 unsigned int xcb_align_to = 0;
14101
14102 int xcb_pre_tmp_1; /* sumof length */
14103 int xcb_pre_tmp_2; /* sumof loop counter */
14104 int64_t xcb_pre_tmp_3; /* sumof sum */
14105 const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
14106 int xcb_pre_tmp_5; /* sumof length */
14107 int xcb_pre_tmp_6; /* sumof loop counter */
14108 int64_t xcb_pre_tmp_7; /* sumof sum */
14109 const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
14110
14111 xcb_block_len += sizeof(xcb_input_raw_touch_begin_event_t);
14112 xcb_tmp += xcb_block_len;
14113 xcb_buffer_len += xcb_block_len;
14114 xcb_block_len = 0;
14115 /* valuator_mask */
14116 xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
14117 xcb_tmp += xcb_block_len;
14118 xcb_align_to = ALIGNOF(uint32_t);
14119 /* insert padding */
14120 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14121 xcb_buffer_len += xcb_block_len + xcb_pad;
14122 if (0 != xcb_pad) {
14123 xcb_tmp += xcb_pad;
14124 xcb_pad = 0;
14125 }
14126 xcb_block_len = 0;
14127 /* axisvalues */
14128 /* sumof start */
14129 xcb_pre_tmp_1 = _aux->valuators_len;
14130 xcb_pre_tmp_3 = 0;
14131 xcb_pre_tmp_4 = xcb_input_raw_touch_begin_valuator_mask(_aux);
14132 for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
14133 const uint32_t *xcb_listelement = xcb_pre_tmp_4;
14134 xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
14135 xcb_pre_tmp_4++;
14136 }
14137 /* sumof end. Result is in xcb_pre_tmp_3 */
14138 xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
14139 xcb_tmp += xcb_block_len;
14140 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
14141 /* insert padding */
14142 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14143 xcb_buffer_len += xcb_block_len + xcb_pad;
14144 if (0 != xcb_pad) {
14145 xcb_tmp += xcb_pad;
14146 xcb_pad = 0;
14147 }
14148 xcb_block_len = 0;
14149 /* axisvalues_raw */
14150 /* sumof start */
14151 xcb_pre_tmp_5 = _aux->valuators_len;
14152 xcb_pre_tmp_7 = 0;
14153 xcb_pre_tmp_8 = xcb_input_raw_touch_begin_valuator_mask(_aux);
14154 for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
14155 const uint32_t *xcb_listelement = xcb_pre_tmp_8;
14156 xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
14157 xcb_pre_tmp_8++;
14158 }
14159 /* sumof end. Result is in xcb_pre_tmp_7 */
14160 xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
14161 xcb_tmp += xcb_block_len;
14162 xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
14163 /* insert padding */
14164 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14165 xcb_buffer_len += xcb_block_len + xcb_pad;
14166 if (0 != xcb_pad) {
14167 xcb_tmp += xcb_pad;
14168 xcb_pad = 0;
14169 }
14170 xcb_block_len = 0;
14171
14172 return xcb_buffer_len;
14173 }
14174
14175 uint32_t *
xcb_input_raw_touch_begin_valuator_mask(const xcb_input_raw_touch_begin_event_t * R)14176 xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R)
14177 {
14178 return (uint32_t *) (R + 1);
14179 }
14180
14181 int
xcb_input_raw_touch_begin_valuator_mask_length(const xcb_input_raw_touch_begin_event_t * R)14182 xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R)
14183 {
14184 return R->valuators_len;
14185 }
14186
14187 xcb_generic_iterator_t
xcb_input_raw_touch_begin_valuator_mask_end(const xcb_input_raw_touch_begin_event_t * R)14188 xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R)
14189 {
14190 xcb_generic_iterator_t i;
14191 i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
14192 i.rem = 0;
14193 i.index = (char *) i.data - (char *) R;
14194 return i;
14195 }
14196
14197 xcb_input_fp3232_t *
xcb_input_raw_touch_begin_axisvalues(const xcb_input_raw_touch_begin_event_t * R)14198 xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R)
14199 {
14200 xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R);
14201 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
14202 }
14203
14204 int
xcb_input_raw_touch_begin_axisvalues_length(const xcb_input_raw_touch_begin_event_t * R)14205 xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R)
14206 {
14207 int xcb_pre_tmp_9; /* sumof length */
14208 int xcb_pre_tmp_10; /* sumof loop counter */
14209 int64_t xcb_pre_tmp_11; /* sumof sum */
14210 const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
14211 /* sumof start */
14212 xcb_pre_tmp_9 = R->valuators_len;
14213 xcb_pre_tmp_11 = 0;
14214 xcb_pre_tmp_12 = xcb_input_raw_touch_begin_valuator_mask(R);
14215 for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
14216 const uint32_t *xcb_listelement = xcb_pre_tmp_12;
14217 xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
14218 xcb_pre_tmp_12++;
14219 }
14220 /* sumof end. Result is in xcb_pre_tmp_11 */
14221 return xcb_pre_tmp_11;
14222 }
14223
14224 xcb_input_fp3232_iterator_t
xcb_input_raw_touch_begin_axisvalues_iterator(const xcb_input_raw_touch_begin_event_t * R)14225 xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R)
14226 {
14227 xcb_input_fp3232_iterator_t i;
14228 xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R);
14229 int xcb_pre_tmp_13; /* sumof length */
14230 int xcb_pre_tmp_14; /* sumof loop counter */
14231 int64_t xcb_pre_tmp_15; /* sumof sum */
14232 const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
14233 /* sumof start */
14234 xcb_pre_tmp_13 = R->valuators_len;
14235 xcb_pre_tmp_15 = 0;
14236 xcb_pre_tmp_16 = xcb_input_raw_touch_begin_valuator_mask(R);
14237 for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
14238 const uint32_t *xcb_listelement = xcb_pre_tmp_16;
14239 xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
14240 xcb_pre_tmp_16++;
14241 }
14242 /* sumof end. Result is in xcb_pre_tmp_15 */
14243 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
14244 i.rem = xcb_pre_tmp_15;
14245 i.index = (char *) i.data - (char *) R;
14246 return i;
14247 }
14248
14249 xcb_input_fp3232_t *
xcb_input_raw_touch_begin_axisvalues_raw(const xcb_input_raw_touch_begin_event_t * R)14250 xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R)
14251 {
14252 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R));
14253 return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
14254 }
14255
14256 int
xcb_input_raw_touch_begin_axisvalues_raw_length(const xcb_input_raw_touch_begin_event_t * R)14257 xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R)
14258 {
14259 int xcb_pre_tmp_17; /* sumof length */
14260 int xcb_pre_tmp_18; /* sumof loop counter */
14261 int64_t xcb_pre_tmp_19; /* sumof sum */
14262 const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
14263 /* sumof start */
14264 xcb_pre_tmp_17 = R->valuators_len;
14265 xcb_pre_tmp_19 = 0;
14266 xcb_pre_tmp_20 = xcb_input_raw_touch_begin_valuator_mask(R);
14267 for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
14268 const uint32_t *xcb_listelement = xcb_pre_tmp_20;
14269 xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
14270 xcb_pre_tmp_20++;
14271 }
14272 /* sumof end. Result is in xcb_pre_tmp_19 */
14273 return xcb_pre_tmp_19;
14274 }
14275
14276 xcb_input_fp3232_iterator_t
xcb_input_raw_touch_begin_axisvalues_raw_iterator(const xcb_input_raw_touch_begin_event_t * R)14277 xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R)
14278 {
14279 xcb_input_fp3232_iterator_t i;
14280 xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R));
14281 int xcb_pre_tmp_21; /* sumof length */
14282 int xcb_pre_tmp_22; /* sumof loop counter */
14283 int64_t xcb_pre_tmp_23; /* sumof sum */
14284 const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
14285 /* sumof start */
14286 xcb_pre_tmp_21 = R->valuators_len;
14287 xcb_pre_tmp_23 = 0;
14288 xcb_pre_tmp_24 = xcb_input_raw_touch_begin_valuator_mask(R);
14289 for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
14290 const uint32_t *xcb_listelement = xcb_pre_tmp_24;
14291 xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
14292 xcb_pre_tmp_24++;
14293 }
14294 /* sumof end. Result is in xcb_pre_tmp_23 */
14295 i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
14296 i.rem = xcb_pre_tmp_23;
14297 i.index = (char *) i.data - (char *) R;
14298 return i;
14299 }
14300
14301 int
xcb_input_raw_touch_update_sizeof(const void * _buffer)14302 xcb_input_raw_touch_update_sizeof (const void *_buffer /**< */)
14303 {
14304 return xcb_input_raw_touch_begin_sizeof(_buffer);
14305 }
14306
14307 int
xcb_input_raw_touch_end_sizeof(const void * _buffer)14308 xcb_input_raw_touch_end_sizeof (const void *_buffer /**< */)
14309 {
14310 return xcb_input_raw_touch_begin_sizeof(_buffer);
14311 }
14312
14313 void
xcb_input_event_for_send_next(xcb_input_event_for_send_iterator_t * i)14314 xcb_input_event_for_send_next (xcb_input_event_for_send_iterator_t *i)
14315 {
14316 --i->rem;
14317 ++i->data;
14318 i->index += sizeof(xcb_input_event_for_send_t);
14319 }
14320
14321 xcb_generic_iterator_t
xcb_input_event_for_send_end(xcb_input_event_for_send_iterator_t i)14322 xcb_input_event_for_send_end (xcb_input_event_for_send_iterator_t i)
14323 {
14324 xcb_generic_iterator_t ret;
14325 ret.data = i.data + i.rem;
14326 ret.index = i.index + ((char *) ret.data - (char *) i.data);
14327 ret.rem = 0;
14328 return ret;
14329 }
14330
14331 int
xcb_input_send_extension_event_sizeof(const void * _buffer)14332 xcb_input_send_extension_event_sizeof (const void *_buffer)
14333 {
14334 char *xcb_tmp = (char *)_buffer;
14335 const xcb_input_send_extension_event_request_t *_aux = (xcb_input_send_extension_event_request_t *)_buffer;
14336 unsigned int xcb_buffer_len = 0;
14337 unsigned int xcb_block_len = 0;
14338 unsigned int xcb_pad = 0;
14339 unsigned int xcb_align_to = 0;
14340
14341
14342 xcb_block_len += sizeof(xcb_input_send_extension_event_request_t);
14343 xcb_tmp += xcb_block_len;
14344 xcb_buffer_len += xcb_block_len;
14345 xcb_block_len = 0;
14346 /* events */
14347 xcb_block_len += _aux->num_events * sizeof(xcb_input_event_for_send_t);
14348 xcb_tmp += xcb_block_len;
14349 xcb_align_to = ALIGNOF(xcb_input_event_for_send_t);
14350 /* insert padding */
14351 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14352 xcb_buffer_len += xcb_block_len + xcb_pad;
14353 if (0 != xcb_pad) {
14354 xcb_tmp += xcb_pad;
14355 xcb_pad = 0;
14356 }
14357 xcb_block_len = 0;
14358 /* classes */
14359 xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
14360 xcb_tmp += xcb_block_len;
14361 xcb_align_to = ALIGNOF(xcb_input_event_class_t);
14362 /* insert padding */
14363 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
14364 xcb_buffer_len += xcb_block_len + xcb_pad;
14365 if (0 != xcb_pad) {
14366 xcb_tmp += xcb_pad;
14367 xcb_pad = 0;
14368 }
14369 xcb_block_len = 0;
14370
14371 return xcb_buffer_len;
14372 }
14373
14374 xcb_void_cookie_t
xcb_input_send_extension_event_checked(xcb_connection_t * c,xcb_window_t destination,uint8_t device_id,uint8_t propagate,uint16_t num_classes,uint8_t num_events,const xcb_input_event_for_send_t * events,const xcb_input_event_class_t * classes)14375 xcb_input_send_extension_event_checked (xcb_connection_t *c,
14376 xcb_window_t destination,
14377 uint8_t device_id,
14378 uint8_t propagate,
14379 uint16_t num_classes,
14380 uint8_t num_events,
14381 const xcb_input_event_for_send_t *events,
14382 const xcb_input_event_class_t *classes)
14383 {
14384 static const xcb_protocol_request_t xcb_req = {
14385 .count = 6,
14386 .ext = &xcb_input_id,
14387 .opcode = XCB_INPUT_SEND_EXTENSION_EVENT,
14388 .isvoid = 1
14389 };
14390
14391 struct iovec xcb_parts[8];
14392 xcb_void_cookie_t xcb_ret;
14393 xcb_input_send_extension_event_request_t xcb_out;
14394
14395 xcb_out.destination = destination;
14396 xcb_out.device_id = device_id;
14397 xcb_out.propagate = propagate;
14398 xcb_out.num_classes = num_classes;
14399 xcb_out.num_events = num_events;
14400 memset(xcb_out.pad0, 0, 3);
14401
14402 xcb_parts[2].iov_base = (char *) &xcb_out;
14403 xcb_parts[2].iov_len = sizeof(xcb_out);
14404 xcb_parts[3].iov_base = 0;
14405 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14406 /* xcb_input_event_for_send_t events */
14407 xcb_parts[4].iov_base = (char *) events;
14408 xcb_parts[4].iov_len = num_events * sizeof(xcb_input_event_for_send_t);
14409 xcb_parts[5].iov_base = 0;
14410 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14411 /* xcb_input_event_class_t classes */
14412 xcb_parts[6].iov_base = (char *) classes;
14413 xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t);
14414 xcb_parts[7].iov_base = 0;
14415 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
14416
14417 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
14418 return xcb_ret;
14419 }
14420
14421 xcb_void_cookie_t
xcb_input_send_extension_event(xcb_connection_t * c,xcb_window_t destination,uint8_t device_id,uint8_t propagate,uint16_t num_classes,uint8_t num_events,const xcb_input_event_for_send_t * events,const xcb_input_event_class_t * classes)14422 xcb_input_send_extension_event (xcb_connection_t *c,
14423 xcb_window_t destination,
14424 uint8_t device_id,
14425 uint8_t propagate,
14426 uint16_t num_classes,
14427 uint8_t num_events,
14428 const xcb_input_event_for_send_t *events,
14429 const xcb_input_event_class_t *classes)
14430 {
14431 static const xcb_protocol_request_t xcb_req = {
14432 .count = 6,
14433 .ext = &xcb_input_id,
14434 .opcode = XCB_INPUT_SEND_EXTENSION_EVENT,
14435 .isvoid = 1
14436 };
14437
14438 struct iovec xcb_parts[8];
14439 xcb_void_cookie_t xcb_ret;
14440 xcb_input_send_extension_event_request_t xcb_out;
14441
14442 xcb_out.destination = destination;
14443 xcb_out.device_id = device_id;
14444 xcb_out.propagate = propagate;
14445 xcb_out.num_classes = num_classes;
14446 xcb_out.num_events = num_events;
14447 memset(xcb_out.pad0, 0, 3);
14448
14449 xcb_parts[2].iov_base = (char *) &xcb_out;
14450 xcb_parts[2].iov_len = sizeof(xcb_out);
14451 xcb_parts[3].iov_base = 0;
14452 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
14453 /* xcb_input_event_for_send_t events */
14454 xcb_parts[4].iov_base = (char *) events;
14455 xcb_parts[4].iov_len = num_events * sizeof(xcb_input_event_for_send_t);
14456 xcb_parts[5].iov_base = 0;
14457 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
14458 /* xcb_input_event_class_t classes */
14459 xcb_parts[6].iov_base = (char *) classes;
14460 xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t);
14461 xcb_parts[7].iov_base = 0;
14462 xcb_parts[7].iov_len = -xcb_parts[6].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_input_event_for_send_t *
xcb_input_send_extension_event_events(const xcb_input_send_extension_event_request_t * R)14469 xcb_input_send_extension_event_events (const xcb_input_send_extension_event_request_t *R)
14470 {
14471 return (xcb_input_event_for_send_t *) (R + 1);
14472 }
14473
14474 int
xcb_input_send_extension_event_events_length(const xcb_input_send_extension_event_request_t * R)14475 xcb_input_send_extension_event_events_length (const xcb_input_send_extension_event_request_t *R)
14476 {
14477 return R->num_events;
14478 }
14479
14480 xcb_input_event_for_send_iterator_t
xcb_input_send_extension_event_events_iterator(const xcb_input_send_extension_event_request_t * R)14481 xcb_input_send_extension_event_events_iterator (const xcb_input_send_extension_event_request_t *R)
14482 {
14483 xcb_input_event_for_send_iterator_t i;
14484 i.data = (xcb_input_event_for_send_t *) (R + 1);
14485 i.rem = R->num_events;
14486 i.index = (char *) i.data - (char *) R;
14487 return i;
14488 }
14489
14490 xcb_input_event_class_t *
xcb_input_send_extension_event_classes(const xcb_input_send_extension_event_request_t * R)14491 xcb_input_send_extension_event_classes (const xcb_input_send_extension_event_request_t *R)
14492 {
14493 xcb_generic_iterator_t prev = xcb_input_event_for_send_end(xcb_input_send_extension_event_events_iterator(R));
14494 return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0);
14495 }
14496
14497 int
xcb_input_send_extension_event_classes_length(const xcb_input_send_extension_event_request_t * R)14498 xcb_input_send_extension_event_classes_length (const xcb_input_send_extension_event_request_t *R)
14499 {
14500 return R->num_classes;
14501 }
14502
14503 xcb_generic_iterator_t
xcb_input_send_extension_event_classes_end(const xcb_input_send_extension_event_request_t * R)14504 xcb_input_send_extension_event_classes_end (const xcb_input_send_extension_event_request_t *R)
14505 {
14506 xcb_generic_iterator_t i;
14507 xcb_generic_iterator_t prev = xcb_input_event_for_send_end(xcb_input_send_extension_event_events_iterator(R));
14508 i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_classes);
14509 i.rem = 0;
14510 i.index = (char *) i.data - (char *) R;
14511 return i;
14512 }
14513
14514