1 /* 2 * This file generated automatically from xinput.xml by c_client.py. 3 * Edit at your peril. 4 */ 5 6 #include <string.h> 7 #include <assert.h> 8 #include "xcbext.h" 9 #include "xinput.h" 10 #include "xproto.h" 11 12 xcb_extension_t xcb_input_id = { "XInputExtension", 0 }; 13 14 15 /***************************************************************************** 16 ** 17 ** void xcb_input_key_code_next 18 ** 19 ** @param xcb_input_key_code_iterator_t *i 20 ** @returns void 21 ** 22 *****************************************************************************/ 23 24 void 25 xcb_input_key_code_next (xcb_input_key_code_iterator_t *i /**< */) 26 { 27 --i->rem; 28 ++i->data; 29 i->index += sizeof(xcb_input_key_code_t); 30 } 31 32 33 /***************************************************************************** 34 ** 35 ** xcb_generic_iterator_t xcb_input_key_code_end 36 ** 37 ** @param xcb_input_key_code_iterator_t i 38 ** @returns xcb_generic_iterator_t 39 ** 40 *****************************************************************************/ 41 42 xcb_generic_iterator_t 43 xcb_input_key_code_end (xcb_input_key_code_iterator_t i /**< */) 44 { 45 xcb_generic_iterator_t ret; 46 ret.data = i.data + i.rem; 47 ret.index = i.index + ((char *) ret.data - (char *) i.data); 48 ret.rem = 0; 49 return ret; 50 } 51 52 53 /***************************************************************************** 54 ** 55 ** void xcb_input_event_class_next 56 ** 57 ** @param xcb_input_event_class_iterator_t *i 58 ** @returns void 59 ** 60 *****************************************************************************/ 61 62 void 63 xcb_input_event_class_next (xcb_input_event_class_iterator_t *i /**< */) 64 { 65 --i->rem; 66 ++i->data; 67 i->index += sizeof(xcb_input_event_class_t); 68 } 69 70 71 /***************************************************************************** 72 ** 73 ** xcb_generic_iterator_t xcb_input_event_class_end 74 ** 75 ** @param xcb_input_event_class_iterator_t i 76 ** @returns xcb_generic_iterator_t 77 ** 78 *****************************************************************************/ 79 80 xcb_generic_iterator_t 81 xcb_input_event_class_end (xcb_input_event_class_iterator_t i /**< */) 82 { 83 xcb_generic_iterator_t ret; 84 ret.data = i.data + i.rem; 85 ret.index = i.index + ((char *) ret.data - (char *) i.data); 86 ret.rem = 0; 87 return ret; 88 } 89 90 91 /***************************************************************************** 92 ** 93 ** xcb_input_get_extension_version_cookie_t xcb_input_get_extension_version 94 ** 95 ** @param xcb_connection_t *c 96 ** @param uint16_t name_len 97 ** @param const char *name 98 ** @returns xcb_input_get_extension_version_cookie_t 99 ** 100 *****************************************************************************/ 101 102 xcb_input_get_extension_version_cookie_t 103 xcb_input_get_extension_version (xcb_connection_t *c /**< */, 104 uint16_t name_len /**< */, 105 const char *name /**< */) 106 { 107 static const xcb_protocol_request_t xcb_req = { 108 /* count */ 4, 109 /* ext */ &xcb_input_id, 110 /* opcode */ XCB_INPUT_GET_EXTENSION_VERSION, 111 /* isvoid */ 0 112 }; 113 114 struct iovec xcb_parts[6]; 115 xcb_input_get_extension_version_cookie_t xcb_ret; 116 xcb_input_get_extension_version_request_t xcb_out; 117 118 xcb_out.name_len = name_len; 119 memset(xcb_out.pad0, 0, 2); 120 121 xcb_parts[2].iov_base = (char *) &xcb_out; 122 xcb_parts[2].iov_len = sizeof(xcb_out); 123 xcb_parts[3].iov_base = 0; 124 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 125 xcb_parts[4].iov_base = (char *) name; 126 xcb_parts[4].iov_len = name_len * sizeof(char); 127 xcb_parts[5].iov_base = 0; 128 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 129 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 130 return xcb_ret; 131 } 132 133 134 /***************************************************************************** 135 ** 136 ** xcb_input_get_extension_version_cookie_t xcb_input_get_extension_version_unchecked 137 ** 138 ** @param xcb_connection_t *c 139 ** @param uint16_t name_len 140 ** @param const char *name 141 ** @returns xcb_input_get_extension_version_cookie_t 142 ** 143 *****************************************************************************/ 144 145 xcb_input_get_extension_version_cookie_t 146 xcb_input_get_extension_version_unchecked (xcb_connection_t *c /**< */, 147 uint16_t name_len /**< */, 148 const char *name /**< */) 149 { 150 static const xcb_protocol_request_t xcb_req = { 151 /* count */ 4, 152 /* ext */ &xcb_input_id, 153 /* opcode */ XCB_INPUT_GET_EXTENSION_VERSION, 154 /* isvoid */ 0 155 }; 156 157 struct iovec xcb_parts[6]; 158 xcb_input_get_extension_version_cookie_t xcb_ret; 159 xcb_input_get_extension_version_request_t xcb_out; 160 161 xcb_out.name_len = name_len; 162 memset(xcb_out.pad0, 0, 2); 163 164 xcb_parts[2].iov_base = (char *) &xcb_out; 165 xcb_parts[2].iov_len = sizeof(xcb_out); 166 xcb_parts[3].iov_base = 0; 167 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 168 xcb_parts[4].iov_base = (char *) name; 169 xcb_parts[4].iov_len = name_len * sizeof(char); 170 xcb_parts[5].iov_base = 0; 171 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 172 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 173 return xcb_ret; 174 } 175 176 177 /***************************************************************************** 178 ** 179 ** xcb_input_get_extension_version_reply_t * xcb_input_get_extension_version_reply 180 ** 181 ** @param xcb_connection_t *c 182 ** @param xcb_input_get_extension_version_cookie_t cookie 183 ** @param xcb_generic_error_t **e 184 ** @returns xcb_input_get_extension_version_reply_t * 185 ** 186 *****************************************************************************/ 187 188 xcb_input_get_extension_version_reply_t * 189 xcb_input_get_extension_version_reply (xcb_connection_t *c /**< */, 190 xcb_input_get_extension_version_cookie_t cookie /**< */, 191 xcb_generic_error_t **e /**< */) 192 { 193 return (xcb_input_get_extension_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 194 } 195 196 197 /***************************************************************************** 198 ** 199 ** void xcb_input_device_info_next 200 ** 201 ** @param xcb_input_device_info_iterator_t *i 202 ** @returns void 203 ** 204 *****************************************************************************/ 205 206 void 207 xcb_input_device_info_next (xcb_input_device_info_iterator_t *i /**< */) 208 { 209 --i->rem; 210 ++i->data; 211 i->index += sizeof(xcb_input_device_info_t); 212 } 213 214 215 /***************************************************************************** 216 ** 217 ** xcb_generic_iterator_t xcb_input_device_info_end 218 ** 219 ** @param xcb_input_device_info_iterator_t i 220 ** @returns xcb_generic_iterator_t 221 ** 222 *****************************************************************************/ 223 224 xcb_generic_iterator_t 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 235 /***************************************************************************** 236 ** 237 ** xcb_input_list_input_devices_cookie_t xcb_input_list_input_devices 238 ** 239 ** @param xcb_connection_t *c 240 ** @returns xcb_input_list_input_devices_cookie_t 241 ** 242 *****************************************************************************/ 243 244 xcb_input_list_input_devices_cookie_t 245 xcb_input_list_input_devices (xcb_connection_t *c /**< */) 246 { 247 static const xcb_protocol_request_t xcb_req = { 248 /* count */ 2, 249 /* ext */ &xcb_input_id, 250 /* opcode */ XCB_INPUT_LIST_INPUT_DEVICES, 251 /* isvoid */ 0 252 }; 253 254 struct iovec xcb_parts[4]; 255 xcb_input_list_input_devices_cookie_t xcb_ret; 256 xcb_input_list_input_devices_request_t xcb_out; 257 258 259 xcb_parts[2].iov_base = (char *) &xcb_out; 260 xcb_parts[2].iov_len = sizeof(xcb_out); 261 xcb_parts[3].iov_base = 0; 262 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 263 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 264 return xcb_ret; 265 } 266 267 268 /***************************************************************************** 269 ** 270 ** xcb_input_list_input_devices_cookie_t xcb_input_list_input_devices_unchecked 271 ** 272 ** @param xcb_connection_t *c 273 ** @returns xcb_input_list_input_devices_cookie_t 274 ** 275 *****************************************************************************/ 276 277 xcb_input_list_input_devices_cookie_t 278 xcb_input_list_input_devices_unchecked (xcb_connection_t *c /**< */) 279 { 280 static const xcb_protocol_request_t xcb_req = { 281 /* count */ 2, 282 /* ext */ &xcb_input_id, 283 /* opcode */ XCB_INPUT_LIST_INPUT_DEVICES, 284 /* isvoid */ 0 285 }; 286 287 struct iovec xcb_parts[4]; 288 xcb_input_list_input_devices_cookie_t xcb_ret; 289 xcb_input_list_input_devices_request_t xcb_out; 290 291 292 xcb_parts[2].iov_base = (char *) &xcb_out; 293 xcb_parts[2].iov_len = sizeof(xcb_out); 294 xcb_parts[3].iov_base = 0; 295 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 296 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 297 return xcb_ret; 298 } 299 300 301 /***************************************************************************** 302 ** 303 ** xcb_input_device_info_t * xcb_input_list_input_devices_devices 304 ** 305 ** @param const xcb_input_list_input_devices_reply_t *R 306 ** @returns xcb_input_device_info_t * 307 ** 308 *****************************************************************************/ 309 310 xcb_input_device_info_t * 311 xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R /**< */) 312 { 313 return (xcb_input_device_info_t *) (R + 1); 314 } 315 316 317 /***************************************************************************** 318 ** 319 ** int xcb_input_list_input_devices_devices_length 320 ** 321 ** @param const xcb_input_list_input_devices_reply_t *R 322 ** @returns int 323 ** 324 *****************************************************************************/ 325 326 int 327 xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R /**< */) 328 { 329 return R->devices_len; 330 } 331 332 333 /***************************************************************************** 334 ** 335 ** xcb_input_device_info_iterator_t xcb_input_list_input_devices_devices_iterator 336 ** 337 ** @param const xcb_input_list_input_devices_reply_t *R 338 ** @returns xcb_input_device_info_iterator_t 339 ** 340 *****************************************************************************/ 341 342 xcb_input_device_info_iterator_t 343 xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R /**< */) 344 { 345 xcb_input_device_info_iterator_t i; 346 i.data = (xcb_input_device_info_t *) (R + 1); 347 i.rem = R->devices_len; 348 i.index = (char *) i.data - (char *) R; 349 return i; 350 } 351 352 353 /***************************************************************************** 354 ** 355 ** xcb_input_list_input_devices_reply_t * xcb_input_list_input_devices_reply 356 ** 357 ** @param xcb_connection_t *c 358 ** @param xcb_input_list_input_devices_cookie_t cookie 359 ** @param xcb_generic_error_t **e 360 ** @returns xcb_input_list_input_devices_reply_t * 361 ** 362 *****************************************************************************/ 363 364 xcb_input_list_input_devices_reply_t * 365 xcb_input_list_input_devices_reply (xcb_connection_t *c /**< */, 366 xcb_input_list_input_devices_cookie_t cookie /**< */, 367 xcb_generic_error_t **e /**< */) 368 { 369 return (xcb_input_list_input_devices_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 370 } 371 372 373 /***************************************************************************** 374 ** 375 ** void xcb_input_input_info_next 376 ** 377 ** @param xcb_input_input_info_iterator_t *i 378 ** @returns void 379 ** 380 *****************************************************************************/ 381 382 void 383 xcb_input_input_info_next (xcb_input_input_info_iterator_t *i /**< */) 384 { 385 --i->rem; 386 ++i->data; 387 i->index += sizeof(xcb_input_input_info_t); 388 } 389 390 391 /***************************************************************************** 392 ** 393 ** xcb_generic_iterator_t xcb_input_input_info_end 394 ** 395 ** @param xcb_input_input_info_iterator_t i 396 ** @returns xcb_generic_iterator_t 397 ** 398 *****************************************************************************/ 399 400 xcb_generic_iterator_t 401 xcb_input_input_info_end (xcb_input_input_info_iterator_t i /**< */) 402 { 403 xcb_generic_iterator_t ret; 404 ret.data = i.data + i.rem; 405 ret.index = i.index + ((char *) ret.data - (char *) i.data); 406 ret.rem = 0; 407 return ret; 408 } 409 410 411 /***************************************************************************** 412 ** 413 ** void xcb_input_key_info_next 414 ** 415 ** @param xcb_input_key_info_iterator_t *i 416 ** @returns void 417 ** 418 *****************************************************************************/ 419 420 void 421 xcb_input_key_info_next (xcb_input_key_info_iterator_t *i /**< */) 422 { 423 --i->rem; 424 ++i->data; 425 i->index += sizeof(xcb_input_key_info_t); 426 } 427 428 429 /***************************************************************************** 430 ** 431 ** xcb_generic_iterator_t xcb_input_key_info_end 432 ** 433 ** @param xcb_input_key_info_iterator_t i 434 ** @returns xcb_generic_iterator_t 435 ** 436 *****************************************************************************/ 437 438 xcb_generic_iterator_t 439 xcb_input_key_info_end (xcb_input_key_info_iterator_t i /**< */) 440 { 441 xcb_generic_iterator_t ret; 442 ret.data = i.data + i.rem; 443 ret.index = i.index + ((char *) ret.data - (char *) i.data); 444 ret.rem = 0; 445 return ret; 446 } 447 448 449 /***************************************************************************** 450 ** 451 ** void xcb_input_button_info_next 452 ** 453 ** @param xcb_input_button_info_iterator_t *i 454 ** @returns void 455 ** 456 *****************************************************************************/ 457 458 void 459 xcb_input_button_info_next (xcb_input_button_info_iterator_t *i /**< */) 460 { 461 --i->rem; 462 ++i->data; 463 i->index += sizeof(xcb_input_button_info_t); 464 } 465 466 467 /***************************************************************************** 468 ** 469 ** xcb_generic_iterator_t xcb_input_button_info_end 470 ** 471 ** @param xcb_input_button_info_iterator_t i 472 ** @returns xcb_generic_iterator_t 473 ** 474 *****************************************************************************/ 475 476 xcb_generic_iterator_t 477 xcb_input_button_info_end (xcb_input_button_info_iterator_t i /**< */) 478 { 479 xcb_generic_iterator_t ret; 480 ret.data = i.data + i.rem; 481 ret.index = i.index + ((char *) ret.data - (char *) i.data); 482 ret.rem = 0; 483 return ret; 484 } 485 486 487 /***************************************************************************** 488 ** 489 ** void xcb_input_axis_info_next 490 ** 491 ** @param xcb_input_axis_info_iterator_t *i 492 ** @returns void 493 ** 494 *****************************************************************************/ 495 496 void 497 xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i /**< */) 498 { 499 --i->rem; 500 ++i->data; 501 i->index += sizeof(xcb_input_axis_info_t); 502 } 503 504 505 /***************************************************************************** 506 ** 507 ** xcb_generic_iterator_t xcb_input_axis_info_end 508 ** 509 ** @param xcb_input_axis_info_iterator_t i 510 ** @returns xcb_generic_iterator_t 511 ** 512 *****************************************************************************/ 513 514 xcb_generic_iterator_t 515 xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i /**< */) 516 { 517 xcb_generic_iterator_t ret; 518 ret.data = i.data + i.rem; 519 ret.index = i.index + ((char *) ret.data - (char *) i.data); 520 ret.rem = 0; 521 return ret; 522 } 523 524 525 /***************************************************************************** 526 ** 527 ** xcb_input_axis_info_t * xcb_input_valuator_info_axes 528 ** 529 ** @param const xcb_input_valuator_info_t *R 530 ** @returns xcb_input_axis_info_t * 531 ** 532 *****************************************************************************/ 533 534 xcb_input_axis_info_t * 535 xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R /**< */) 536 { 537 return (xcb_input_axis_info_t *) (R + 1); 538 } 539 540 541 /***************************************************************************** 542 ** 543 ** int xcb_input_valuator_info_axes_length 544 ** 545 ** @param const xcb_input_valuator_info_t *R 546 ** @returns int 547 ** 548 *****************************************************************************/ 549 550 int 551 xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R /**< */) 552 { 553 return R->axes_len; 554 } 555 556 557 /***************************************************************************** 558 ** 559 ** xcb_input_axis_info_iterator_t xcb_input_valuator_info_axes_iterator 560 ** 561 ** @param const xcb_input_valuator_info_t *R 562 ** @returns xcb_input_axis_info_iterator_t 563 ** 564 *****************************************************************************/ 565 566 xcb_input_axis_info_iterator_t 567 xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R /**< */) 568 { 569 xcb_input_axis_info_iterator_t i; 570 i.data = (xcb_input_axis_info_t *) (R + 1); 571 i.rem = R->axes_len; 572 i.index = (char *) i.data - (char *) R; 573 return i; 574 } 575 576 577 /***************************************************************************** 578 ** 579 ** void xcb_input_valuator_info_next 580 ** 581 ** @param xcb_input_valuator_info_iterator_t *i 582 ** @returns void 583 ** 584 *****************************************************************************/ 585 586 void 587 xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i /**< */) 588 { 589 xcb_input_valuator_info_t *R = i->data; 590 xcb_generic_iterator_t child = xcb_input_axis_info_end(xcb_input_valuator_info_axes_iterator(R)); 591 --i->rem; 592 i->data = (xcb_input_valuator_info_t *) child.data; 593 i->index = child.index; 594 } 595 596 597 /***************************************************************************** 598 ** 599 ** xcb_generic_iterator_t xcb_input_valuator_info_end 600 ** 601 ** @param xcb_input_valuator_info_iterator_t i 602 ** @returns xcb_generic_iterator_t 603 ** 604 *****************************************************************************/ 605 606 xcb_generic_iterator_t 607 xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i /**< */) 608 { 609 xcb_generic_iterator_t ret; 610 while(i.rem > 0) 611 xcb_input_valuator_info_next(&i); 612 ret.data = i.data; 613 ret.rem = i.rem; 614 ret.index = i.index; 615 return ret; 616 } 617 618 619 /***************************************************************************** 620 ** 621 ** void xcb_input_input_class_info_next 622 ** 623 ** @param xcb_input_input_class_info_iterator_t *i 624 ** @returns void 625 ** 626 *****************************************************************************/ 627 628 void 629 xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i /**< */) 630 { 631 --i->rem; 632 ++i->data; 633 i->index += sizeof(xcb_input_input_class_info_t); 634 } 635 636 637 /***************************************************************************** 638 ** 639 ** xcb_generic_iterator_t xcb_input_input_class_info_end 640 ** 641 ** @param xcb_input_input_class_info_iterator_t i 642 ** @returns xcb_generic_iterator_t 643 ** 644 *****************************************************************************/ 645 646 xcb_generic_iterator_t 647 xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i /**< */) 648 { 649 xcb_generic_iterator_t ret; 650 ret.data = i.data + i.rem; 651 ret.index = i.index + ((char *) ret.data - (char *) i.data); 652 ret.rem = 0; 653 return ret; 654 } 655 656 657 /***************************************************************************** 658 ** 659 ** xcb_input_open_device_cookie_t xcb_input_open_device 660 ** 661 ** @param xcb_connection_t *c 662 ** @param uint8_t device_id 663 ** @returns xcb_input_open_device_cookie_t 664 ** 665 *****************************************************************************/ 666 667 xcb_input_open_device_cookie_t 668 xcb_input_open_device (xcb_connection_t *c /**< */, 669 uint8_t device_id /**< */) 670 { 671 static const xcb_protocol_request_t xcb_req = { 672 /* count */ 2, 673 /* ext */ &xcb_input_id, 674 /* opcode */ XCB_INPUT_OPEN_DEVICE, 675 /* isvoid */ 0 676 }; 677 678 struct iovec xcb_parts[4]; 679 xcb_input_open_device_cookie_t xcb_ret; 680 xcb_input_open_device_request_t xcb_out; 681 682 xcb_out.device_id = device_id; 683 memset(xcb_out.pad0, 0, 3); 684 685 xcb_parts[2].iov_base = (char *) &xcb_out; 686 xcb_parts[2].iov_len = sizeof(xcb_out); 687 xcb_parts[3].iov_base = 0; 688 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 689 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 690 return xcb_ret; 691 } 692 693 694 /***************************************************************************** 695 ** 696 ** xcb_input_open_device_cookie_t xcb_input_open_device_unchecked 697 ** 698 ** @param xcb_connection_t *c 699 ** @param uint8_t device_id 700 ** @returns xcb_input_open_device_cookie_t 701 ** 702 *****************************************************************************/ 703 704 xcb_input_open_device_cookie_t 705 xcb_input_open_device_unchecked (xcb_connection_t *c /**< */, 706 uint8_t device_id /**< */) 707 { 708 static const xcb_protocol_request_t xcb_req = { 709 /* count */ 2, 710 /* ext */ &xcb_input_id, 711 /* opcode */ XCB_INPUT_OPEN_DEVICE, 712 /* isvoid */ 0 713 }; 714 715 struct iovec xcb_parts[4]; 716 xcb_input_open_device_cookie_t xcb_ret; 717 xcb_input_open_device_request_t xcb_out; 718 719 xcb_out.device_id = device_id; 720 memset(xcb_out.pad0, 0, 3); 721 722 xcb_parts[2].iov_base = (char *) &xcb_out; 723 xcb_parts[2].iov_len = sizeof(xcb_out); 724 xcb_parts[3].iov_base = 0; 725 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 726 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 727 return xcb_ret; 728 } 729 730 731 /***************************************************************************** 732 ** 733 ** xcb_input_input_class_info_t * xcb_input_open_device_class_info 734 ** 735 ** @param const xcb_input_open_device_reply_t *R 736 ** @returns xcb_input_input_class_info_t * 737 ** 738 *****************************************************************************/ 739 740 xcb_input_input_class_info_t * 741 xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R /**< */) 742 { 743 return (xcb_input_input_class_info_t *) (R + 1); 744 } 745 746 747 /***************************************************************************** 748 ** 749 ** int xcb_input_open_device_class_info_length 750 ** 751 ** @param const xcb_input_open_device_reply_t *R 752 ** @returns int 753 ** 754 *****************************************************************************/ 755 756 int 757 xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R /**< */) 758 { 759 return R->num_classes; 760 } 761 762 763 /***************************************************************************** 764 ** 765 ** xcb_input_input_class_info_iterator_t xcb_input_open_device_class_info_iterator 766 ** 767 ** @param const xcb_input_open_device_reply_t *R 768 ** @returns xcb_input_input_class_info_iterator_t 769 ** 770 *****************************************************************************/ 771 772 xcb_input_input_class_info_iterator_t 773 xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R /**< */) 774 { 775 xcb_input_input_class_info_iterator_t i; 776 i.data = (xcb_input_input_class_info_t *) (R + 1); 777 i.rem = R->num_classes; 778 i.index = (char *) i.data - (char *) R; 779 return i; 780 } 781 782 783 /***************************************************************************** 784 ** 785 ** xcb_input_open_device_reply_t * xcb_input_open_device_reply 786 ** 787 ** @param xcb_connection_t *c 788 ** @param xcb_input_open_device_cookie_t cookie 789 ** @param xcb_generic_error_t **e 790 ** @returns xcb_input_open_device_reply_t * 791 ** 792 *****************************************************************************/ 793 794 xcb_input_open_device_reply_t * 795 xcb_input_open_device_reply (xcb_connection_t *c /**< */, 796 xcb_input_open_device_cookie_t cookie /**< */, 797 xcb_generic_error_t **e /**< */) 798 { 799 return (xcb_input_open_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 800 } 801 802 803 /***************************************************************************** 804 ** 805 ** xcb_void_cookie_t xcb_input_close_device_checked 806 ** 807 ** @param xcb_connection_t *c 808 ** @param uint8_t device_id 809 ** @returns xcb_void_cookie_t 810 ** 811 *****************************************************************************/ 812 813 xcb_void_cookie_t 814 xcb_input_close_device_checked (xcb_connection_t *c /**< */, 815 uint8_t device_id /**< */) 816 { 817 static const xcb_protocol_request_t xcb_req = { 818 /* count */ 2, 819 /* ext */ &xcb_input_id, 820 /* opcode */ XCB_INPUT_CLOSE_DEVICE, 821 /* isvoid */ 1 822 }; 823 824 struct iovec xcb_parts[4]; 825 xcb_void_cookie_t xcb_ret; 826 xcb_input_close_device_request_t xcb_out; 827 828 xcb_out.device_id = device_id; 829 memset(xcb_out.pad0, 0, 3); 830 831 xcb_parts[2].iov_base = (char *) &xcb_out; 832 xcb_parts[2].iov_len = sizeof(xcb_out); 833 xcb_parts[3].iov_base = 0; 834 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 835 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 836 return xcb_ret; 837 } 838 839 840 /***************************************************************************** 841 ** 842 ** xcb_void_cookie_t xcb_input_close_device 843 ** 844 ** @param xcb_connection_t *c 845 ** @param uint8_t device_id 846 ** @returns xcb_void_cookie_t 847 ** 848 *****************************************************************************/ 849 850 xcb_void_cookie_t 851 xcb_input_close_device (xcb_connection_t *c /**< */, 852 uint8_t device_id /**< */) 853 { 854 static const xcb_protocol_request_t xcb_req = { 855 /* count */ 2, 856 /* ext */ &xcb_input_id, 857 /* opcode */ XCB_INPUT_CLOSE_DEVICE, 858 /* isvoid */ 1 859 }; 860 861 struct iovec xcb_parts[4]; 862 xcb_void_cookie_t xcb_ret; 863 xcb_input_close_device_request_t xcb_out; 864 865 xcb_out.device_id = device_id; 866 memset(xcb_out.pad0, 0, 3); 867 868 xcb_parts[2].iov_base = (char *) &xcb_out; 869 xcb_parts[2].iov_len = sizeof(xcb_out); 870 xcb_parts[3].iov_base = 0; 871 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 872 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 873 return xcb_ret; 874 } 875 876 877 /***************************************************************************** 878 ** 879 ** xcb_input_set_device_mode_cookie_t xcb_input_set_device_mode 880 ** 881 ** @param xcb_connection_t *c 882 ** @param uint8_t device_id 883 ** @param uint8_t mode 884 ** @returns xcb_input_set_device_mode_cookie_t 885 ** 886 *****************************************************************************/ 887 888 xcb_input_set_device_mode_cookie_t 889 xcb_input_set_device_mode (xcb_connection_t *c /**< */, 890 uint8_t device_id /**< */, 891 uint8_t mode /**< */) 892 { 893 static const xcb_protocol_request_t xcb_req = { 894 /* count */ 2, 895 /* ext */ &xcb_input_id, 896 /* opcode */ XCB_INPUT_SET_DEVICE_MODE, 897 /* isvoid */ 0 898 }; 899 900 struct iovec xcb_parts[4]; 901 xcb_input_set_device_mode_cookie_t xcb_ret; 902 xcb_input_set_device_mode_request_t xcb_out; 903 904 xcb_out.device_id = device_id; 905 xcb_out.mode = mode; 906 memset(xcb_out.pad0, 0, 2); 907 908 xcb_parts[2].iov_base = (char *) &xcb_out; 909 xcb_parts[2].iov_len = sizeof(xcb_out); 910 xcb_parts[3].iov_base = 0; 911 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 912 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 913 return xcb_ret; 914 } 915 916 917 /***************************************************************************** 918 ** 919 ** xcb_input_set_device_mode_cookie_t xcb_input_set_device_mode_unchecked 920 ** 921 ** @param xcb_connection_t *c 922 ** @param uint8_t device_id 923 ** @param uint8_t mode 924 ** @returns xcb_input_set_device_mode_cookie_t 925 ** 926 *****************************************************************************/ 927 928 xcb_input_set_device_mode_cookie_t 929 xcb_input_set_device_mode_unchecked (xcb_connection_t *c /**< */, 930 uint8_t device_id /**< */, 931 uint8_t mode /**< */) 932 { 933 static const xcb_protocol_request_t xcb_req = { 934 /* count */ 2, 935 /* ext */ &xcb_input_id, 936 /* opcode */ XCB_INPUT_SET_DEVICE_MODE, 937 /* isvoid */ 0 938 }; 939 940 struct iovec xcb_parts[4]; 941 xcb_input_set_device_mode_cookie_t xcb_ret; 942 xcb_input_set_device_mode_request_t xcb_out; 943 944 xcb_out.device_id = device_id; 945 xcb_out.mode = mode; 946 memset(xcb_out.pad0, 0, 2); 947 948 xcb_parts[2].iov_base = (char *) &xcb_out; 949 xcb_parts[2].iov_len = sizeof(xcb_out); 950 xcb_parts[3].iov_base = 0; 951 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 952 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 953 return xcb_ret; 954 } 955 956 957 /***************************************************************************** 958 ** 959 ** xcb_input_set_device_mode_reply_t * xcb_input_set_device_mode_reply 960 ** 961 ** @param xcb_connection_t *c 962 ** @param xcb_input_set_device_mode_cookie_t cookie 963 ** @param xcb_generic_error_t **e 964 ** @returns xcb_input_set_device_mode_reply_t * 965 ** 966 *****************************************************************************/ 967 968 xcb_input_set_device_mode_reply_t * 969 xcb_input_set_device_mode_reply (xcb_connection_t *c /**< */, 970 xcb_input_set_device_mode_cookie_t cookie /**< */, 971 xcb_generic_error_t **e /**< */) 972 { 973 return (xcb_input_set_device_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 974 } 975 976 977 /***************************************************************************** 978 ** 979 ** xcb_void_cookie_t xcb_input_select_extension_event_checked 980 ** 981 ** @param xcb_connection_t *c 982 ** @param xcb_window_t window 983 ** @param uint16_t num_classes 984 ** @param const xcb_input_event_class_t *classes 985 ** @returns xcb_void_cookie_t 986 ** 987 *****************************************************************************/ 988 989 xcb_void_cookie_t 990 xcb_input_select_extension_event_checked (xcb_connection_t *c /**< */, 991 xcb_window_t window /**< */, 992 uint16_t num_classes /**< */, 993 const xcb_input_event_class_t *classes /**< */) 994 { 995 static const xcb_protocol_request_t xcb_req = { 996 /* count */ 4, 997 /* ext */ &xcb_input_id, 998 /* opcode */ XCB_INPUT_SELECT_EXTENSION_EVENT, 999 /* isvoid */ 1 1000 }; 1001 1002 struct iovec xcb_parts[6]; 1003 xcb_void_cookie_t xcb_ret; 1004 xcb_input_select_extension_event_request_t xcb_out; 1005 1006 xcb_out.window = window; 1007 xcb_out.num_classes = num_classes; 1008 memset(xcb_out.pad0, 0, 2); 1009 1010 xcb_parts[2].iov_base = (char *) &xcb_out; 1011 xcb_parts[2].iov_len = sizeof(xcb_out); 1012 xcb_parts[3].iov_base = 0; 1013 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1014 xcb_parts[4].iov_base = (char *) classes; 1015 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 1016 xcb_parts[5].iov_base = 0; 1017 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1018 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1019 return xcb_ret; 1020 } 1021 1022 1023 /***************************************************************************** 1024 ** 1025 ** xcb_void_cookie_t xcb_input_select_extension_event 1026 ** 1027 ** @param xcb_connection_t *c 1028 ** @param xcb_window_t window 1029 ** @param uint16_t num_classes 1030 ** @param const xcb_input_event_class_t *classes 1031 ** @returns xcb_void_cookie_t 1032 ** 1033 *****************************************************************************/ 1034 1035 xcb_void_cookie_t 1036 xcb_input_select_extension_event (xcb_connection_t *c /**< */, 1037 xcb_window_t window /**< */, 1038 uint16_t num_classes /**< */, 1039 const xcb_input_event_class_t *classes /**< */) 1040 { 1041 static const xcb_protocol_request_t xcb_req = { 1042 /* count */ 4, 1043 /* ext */ &xcb_input_id, 1044 /* opcode */ XCB_INPUT_SELECT_EXTENSION_EVENT, 1045 /* isvoid */ 1 1046 }; 1047 1048 struct iovec xcb_parts[6]; 1049 xcb_void_cookie_t xcb_ret; 1050 xcb_input_select_extension_event_request_t xcb_out; 1051 1052 xcb_out.window = window; 1053 xcb_out.num_classes = num_classes; 1054 memset(xcb_out.pad0, 0, 2); 1055 1056 xcb_parts[2].iov_base = (char *) &xcb_out; 1057 xcb_parts[2].iov_len = sizeof(xcb_out); 1058 xcb_parts[3].iov_base = 0; 1059 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1060 xcb_parts[4].iov_base = (char *) classes; 1061 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 1062 xcb_parts[5].iov_base = 0; 1063 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1064 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1065 return xcb_ret; 1066 } 1067 1068 1069 /***************************************************************************** 1070 ** 1071 ** xcb_input_get_selected_extension_events_cookie_t xcb_input_get_selected_extension_events 1072 ** 1073 ** @param xcb_connection_t *c 1074 ** @param xcb_window_t window 1075 ** @returns xcb_input_get_selected_extension_events_cookie_t 1076 ** 1077 *****************************************************************************/ 1078 1079 xcb_input_get_selected_extension_events_cookie_t 1080 xcb_input_get_selected_extension_events (xcb_connection_t *c /**< */, 1081 xcb_window_t window /**< */) 1082 { 1083 static const xcb_protocol_request_t xcb_req = { 1084 /* count */ 2, 1085 /* ext */ &xcb_input_id, 1086 /* opcode */ XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, 1087 /* isvoid */ 0 1088 }; 1089 1090 struct iovec xcb_parts[4]; 1091 xcb_input_get_selected_extension_events_cookie_t xcb_ret; 1092 xcb_input_get_selected_extension_events_request_t xcb_out; 1093 1094 xcb_out.window = window; 1095 1096 xcb_parts[2].iov_base = (char *) &xcb_out; 1097 xcb_parts[2].iov_len = sizeof(xcb_out); 1098 xcb_parts[3].iov_base = 0; 1099 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1100 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1101 return xcb_ret; 1102 } 1103 1104 1105 /***************************************************************************** 1106 ** 1107 ** xcb_input_get_selected_extension_events_cookie_t xcb_input_get_selected_extension_events_unchecked 1108 ** 1109 ** @param xcb_connection_t *c 1110 ** @param xcb_window_t window 1111 ** @returns xcb_input_get_selected_extension_events_cookie_t 1112 ** 1113 *****************************************************************************/ 1114 1115 xcb_input_get_selected_extension_events_cookie_t 1116 xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c /**< */, 1117 xcb_window_t window /**< */) 1118 { 1119 static const xcb_protocol_request_t xcb_req = { 1120 /* count */ 2, 1121 /* ext */ &xcb_input_id, 1122 /* opcode */ XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, 1123 /* isvoid */ 0 1124 }; 1125 1126 struct iovec xcb_parts[4]; 1127 xcb_input_get_selected_extension_events_cookie_t xcb_ret; 1128 xcb_input_get_selected_extension_events_request_t xcb_out; 1129 1130 xcb_out.window = window; 1131 1132 xcb_parts[2].iov_base = (char *) &xcb_out; 1133 xcb_parts[2].iov_len = sizeof(xcb_out); 1134 xcb_parts[3].iov_base = 0; 1135 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1136 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1137 return xcb_ret; 1138 } 1139 1140 1141 /***************************************************************************** 1142 ** 1143 ** xcb_input_event_class_t * xcb_input_get_selected_extension_events_this_classes 1144 ** 1145 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1146 ** @returns xcb_input_event_class_t * 1147 ** 1148 *****************************************************************************/ 1149 1150 xcb_input_event_class_t * 1151 xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1152 { 1153 return (xcb_input_event_class_t *) (R + 1); 1154 } 1155 1156 1157 /***************************************************************************** 1158 ** 1159 ** int xcb_input_get_selected_extension_events_this_classes_length 1160 ** 1161 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1162 ** @returns int 1163 ** 1164 *****************************************************************************/ 1165 1166 int 1167 xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1168 { 1169 return R->num_this_classes; 1170 } 1171 1172 1173 /***************************************************************************** 1174 ** 1175 ** xcb_generic_iterator_t xcb_input_get_selected_extension_events_this_classes_end 1176 ** 1177 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1178 ** @returns xcb_generic_iterator_t 1179 ** 1180 *****************************************************************************/ 1181 1182 xcb_generic_iterator_t 1183 xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1184 { 1185 xcb_generic_iterator_t i; 1186 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_this_classes); 1187 i.rem = 0; 1188 i.index = (char *) i.data - (char *) R; 1189 return i; 1190 } 1191 1192 1193 /***************************************************************************** 1194 ** 1195 ** xcb_input_event_class_t * xcb_input_get_selected_extension_events_all_classes 1196 ** 1197 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1198 ** @returns xcb_input_event_class_t * 1199 ** 1200 *****************************************************************************/ 1201 1202 xcb_input_event_class_t * 1203 xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1204 { 1205 xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R); 1206 return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0); 1207 } 1208 1209 1210 /***************************************************************************** 1211 ** 1212 ** int xcb_input_get_selected_extension_events_all_classes_length 1213 ** 1214 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1215 ** @returns int 1216 ** 1217 *****************************************************************************/ 1218 1219 int 1220 xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1221 { 1222 return R->num_all_classes; 1223 } 1224 1225 1226 /***************************************************************************** 1227 ** 1228 ** xcb_generic_iterator_t xcb_input_get_selected_extension_events_all_classes_end 1229 ** 1230 ** @param const xcb_input_get_selected_extension_events_reply_t *R 1231 ** @returns xcb_generic_iterator_t 1232 ** 1233 *****************************************************************************/ 1234 1235 xcb_generic_iterator_t 1236 xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */) 1237 { 1238 xcb_generic_iterator_t i; 1239 xcb_generic_iterator_t child = xcb_input_get_selected_extension_events_this_classes_end(R); 1240 i.data = ((xcb_input_event_class_t *) child.data) + (R->num_all_classes); 1241 i.rem = 0; 1242 i.index = (char *) i.data - (char *) R; 1243 return i; 1244 } 1245 1246 1247 /***************************************************************************** 1248 ** 1249 ** xcb_input_get_selected_extension_events_reply_t * xcb_input_get_selected_extension_events_reply 1250 ** 1251 ** @param xcb_connection_t *c 1252 ** @param xcb_input_get_selected_extension_events_cookie_t cookie 1253 ** @param xcb_generic_error_t **e 1254 ** @returns xcb_input_get_selected_extension_events_reply_t * 1255 ** 1256 *****************************************************************************/ 1257 1258 xcb_input_get_selected_extension_events_reply_t * 1259 xcb_input_get_selected_extension_events_reply (xcb_connection_t *c /**< */, 1260 xcb_input_get_selected_extension_events_cookie_t cookie /**< */, 1261 xcb_generic_error_t **e /**< */) 1262 { 1263 return (xcb_input_get_selected_extension_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1264 } 1265 1266 1267 /***************************************************************************** 1268 ** 1269 ** xcb_void_cookie_t xcb_input_change_device_dont_propagate_list_checked 1270 ** 1271 ** @param xcb_connection_t *c 1272 ** @param xcb_window_t window 1273 ** @param uint16_t num_classes 1274 ** @param uint8_t mode 1275 ** @param const xcb_input_event_class_t *classes 1276 ** @returns xcb_void_cookie_t 1277 ** 1278 *****************************************************************************/ 1279 1280 xcb_void_cookie_t 1281 xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c /**< */, 1282 xcb_window_t window /**< */, 1283 uint16_t num_classes /**< */, 1284 uint8_t mode /**< */, 1285 const xcb_input_event_class_t *classes /**< */) 1286 { 1287 static const xcb_protocol_request_t xcb_req = { 1288 /* count */ 4, 1289 /* ext */ &xcb_input_id, 1290 /* opcode */ XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, 1291 /* isvoid */ 1 1292 }; 1293 1294 struct iovec xcb_parts[6]; 1295 xcb_void_cookie_t xcb_ret; 1296 xcb_input_change_device_dont_propagate_list_request_t xcb_out; 1297 1298 xcb_out.window = window; 1299 xcb_out.num_classes = num_classes; 1300 xcb_out.mode = mode; 1301 xcb_out.pad0 = 0; 1302 1303 xcb_parts[2].iov_base = (char *) &xcb_out; 1304 xcb_parts[2].iov_len = sizeof(xcb_out); 1305 xcb_parts[3].iov_base = 0; 1306 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1307 xcb_parts[4].iov_base = (char *) classes; 1308 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 1309 xcb_parts[5].iov_base = 0; 1310 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1311 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1312 return xcb_ret; 1313 } 1314 1315 1316 /***************************************************************************** 1317 ** 1318 ** xcb_void_cookie_t xcb_input_change_device_dont_propagate_list 1319 ** 1320 ** @param xcb_connection_t *c 1321 ** @param xcb_window_t window 1322 ** @param uint16_t num_classes 1323 ** @param uint8_t mode 1324 ** @param const xcb_input_event_class_t *classes 1325 ** @returns xcb_void_cookie_t 1326 ** 1327 *****************************************************************************/ 1328 1329 xcb_void_cookie_t 1330 xcb_input_change_device_dont_propagate_list (xcb_connection_t *c /**< */, 1331 xcb_window_t window /**< */, 1332 uint16_t num_classes /**< */, 1333 uint8_t mode /**< */, 1334 const xcb_input_event_class_t *classes /**< */) 1335 { 1336 static const xcb_protocol_request_t xcb_req = { 1337 /* count */ 4, 1338 /* ext */ &xcb_input_id, 1339 /* opcode */ XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, 1340 /* isvoid */ 1 1341 }; 1342 1343 struct iovec xcb_parts[6]; 1344 xcb_void_cookie_t xcb_ret; 1345 xcb_input_change_device_dont_propagate_list_request_t xcb_out; 1346 1347 xcb_out.window = window; 1348 xcb_out.num_classes = num_classes; 1349 xcb_out.mode = mode; 1350 xcb_out.pad0 = 0; 1351 1352 xcb_parts[2].iov_base = (char *) &xcb_out; 1353 xcb_parts[2].iov_len = sizeof(xcb_out); 1354 xcb_parts[3].iov_base = 0; 1355 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1356 xcb_parts[4].iov_base = (char *) classes; 1357 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 1358 xcb_parts[5].iov_base = 0; 1359 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1360 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1361 return xcb_ret; 1362 } 1363 1364 1365 /***************************************************************************** 1366 ** 1367 ** xcb_input_get_device_dont_propagate_list_cookie_t xcb_input_get_device_dont_propagate_list 1368 ** 1369 ** @param xcb_connection_t *c 1370 ** @param xcb_window_t window 1371 ** @returns xcb_input_get_device_dont_propagate_list_cookie_t 1372 ** 1373 *****************************************************************************/ 1374 1375 xcb_input_get_device_dont_propagate_list_cookie_t 1376 xcb_input_get_device_dont_propagate_list (xcb_connection_t *c /**< */, 1377 xcb_window_t window /**< */) 1378 { 1379 static const xcb_protocol_request_t xcb_req = { 1380 /* count */ 2, 1381 /* ext */ &xcb_input_id, 1382 /* opcode */ XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, 1383 /* isvoid */ 0 1384 }; 1385 1386 struct iovec xcb_parts[4]; 1387 xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret; 1388 xcb_input_get_device_dont_propagate_list_request_t xcb_out; 1389 1390 xcb_out.window = window; 1391 1392 xcb_parts[2].iov_base = (char *) &xcb_out; 1393 xcb_parts[2].iov_len = sizeof(xcb_out); 1394 xcb_parts[3].iov_base = 0; 1395 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1396 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1397 return xcb_ret; 1398 } 1399 1400 1401 /***************************************************************************** 1402 ** 1403 ** xcb_input_get_device_dont_propagate_list_cookie_t xcb_input_get_device_dont_propagate_list_unchecked 1404 ** 1405 ** @param xcb_connection_t *c 1406 ** @param xcb_window_t window 1407 ** @returns xcb_input_get_device_dont_propagate_list_cookie_t 1408 ** 1409 *****************************************************************************/ 1410 1411 xcb_input_get_device_dont_propagate_list_cookie_t 1412 xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c /**< */, 1413 xcb_window_t window /**< */) 1414 { 1415 static const xcb_protocol_request_t xcb_req = { 1416 /* count */ 2, 1417 /* ext */ &xcb_input_id, 1418 /* opcode */ XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, 1419 /* isvoid */ 0 1420 }; 1421 1422 struct iovec xcb_parts[4]; 1423 xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret; 1424 xcb_input_get_device_dont_propagate_list_request_t xcb_out; 1425 1426 xcb_out.window = window; 1427 1428 xcb_parts[2].iov_base = (char *) &xcb_out; 1429 xcb_parts[2].iov_len = sizeof(xcb_out); 1430 xcb_parts[3].iov_base = 0; 1431 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1432 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1433 return xcb_ret; 1434 } 1435 1436 1437 /***************************************************************************** 1438 ** 1439 ** xcb_input_event_class_t * xcb_input_get_device_dont_propagate_list_classes 1440 ** 1441 ** @param const xcb_input_get_device_dont_propagate_list_reply_t *R 1442 ** @returns xcb_input_event_class_t * 1443 ** 1444 *****************************************************************************/ 1445 1446 xcb_input_event_class_t * 1447 xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) 1448 { 1449 return (xcb_input_event_class_t *) (R + 1); 1450 } 1451 1452 1453 /***************************************************************************** 1454 ** 1455 ** int xcb_input_get_device_dont_propagate_list_classes_length 1456 ** 1457 ** @param const xcb_input_get_device_dont_propagate_list_reply_t *R 1458 ** @returns int 1459 ** 1460 *****************************************************************************/ 1461 1462 int 1463 xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) 1464 { 1465 return R->num_classes; 1466 } 1467 1468 1469 /***************************************************************************** 1470 ** 1471 ** xcb_generic_iterator_t xcb_input_get_device_dont_propagate_list_classes_end 1472 ** 1473 ** @param const xcb_input_get_device_dont_propagate_list_reply_t *R 1474 ** @returns xcb_generic_iterator_t 1475 ** 1476 *****************************************************************************/ 1477 1478 xcb_generic_iterator_t 1479 xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) 1480 { 1481 xcb_generic_iterator_t i; 1482 i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); 1483 i.rem = 0; 1484 i.index = (char *) i.data - (char *) R; 1485 return i; 1486 } 1487 1488 1489 /***************************************************************************** 1490 ** 1491 ** xcb_input_get_device_dont_propagate_list_reply_t * xcb_input_get_device_dont_propagate_list_reply 1492 ** 1493 ** @param xcb_connection_t *c 1494 ** @param xcb_input_get_device_dont_propagate_list_cookie_t cookie 1495 ** @param xcb_generic_error_t **e 1496 ** @returns xcb_input_get_device_dont_propagate_list_reply_t * 1497 ** 1498 *****************************************************************************/ 1499 1500 xcb_input_get_device_dont_propagate_list_reply_t * 1501 xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t *c /**< */, 1502 xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */, 1503 xcb_generic_error_t **e /**< */) 1504 { 1505 return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1506 } 1507 1508 1509 /***************************************************************************** 1510 ** 1511 ** xcb_input_get_device_motion_events_cookie_t xcb_input_get_device_motion_events 1512 ** 1513 ** @param xcb_connection_t *c 1514 ** @param xcb_timestamp_t start 1515 ** @param xcb_timestamp_t stop 1516 ** @param uint8_t device_id 1517 ** @returns xcb_input_get_device_motion_events_cookie_t 1518 ** 1519 *****************************************************************************/ 1520 1521 xcb_input_get_device_motion_events_cookie_t 1522 xcb_input_get_device_motion_events (xcb_connection_t *c /**< */, 1523 xcb_timestamp_t start /**< */, 1524 xcb_timestamp_t stop /**< */, 1525 uint8_t device_id /**< */) 1526 { 1527 static const xcb_protocol_request_t xcb_req = { 1528 /* count */ 2, 1529 /* ext */ &xcb_input_id, 1530 /* opcode */ XCB_INPUT_GET_DEVICE_MOTION_EVENTS, 1531 /* isvoid */ 0 1532 }; 1533 1534 struct iovec xcb_parts[4]; 1535 xcb_input_get_device_motion_events_cookie_t xcb_ret; 1536 xcb_input_get_device_motion_events_request_t xcb_out; 1537 1538 xcb_out.start = start; 1539 xcb_out.stop = stop; 1540 xcb_out.device_id = device_id; 1541 1542 xcb_parts[2].iov_base = (char *) &xcb_out; 1543 xcb_parts[2].iov_len = sizeof(xcb_out); 1544 xcb_parts[3].iov_base = 0; 1545 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1546 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1547 return xcb_ret; 1548 } 1549 1550 1551 /***************************************************************************** 1552 ** 1553 ** xcb_input_get_device_motion_events_cookie_t xcb_input_get_device_motion_events_unchecked 1554 ** 1555 ** @param xcb_connection_t *c 1556 ** @param xcb_timestamp_t start 1557 ** @param xcb_timestamp_t stop 1558 ** @param uint8_t device_id 1559 ** @returns xcb_input_get_device_motion_events_cookie_t 1560 ** 1561 *****************************************************************************/ 1562 1563 xcb_input_get_device_motion_events_cookie_t 1564 xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c /**< */, 1565 xcb_timestamp_t start /**< */, 1566 xcb_timestamp_t stop /**< */, 1567 uint8_t device_id /**< */) 1568 { 1569 static const xcb_protocol_request_t xcb_req = { 1570 /* count */ 2, 1571 /* ext */ &xcb_input_id, 1572 /* opcode */ XCB_INPUT_GET_DEVICE_MOTION_EVENTS, 1573 /* isvoid */ 0 1574 }; 1575 1576 struct iovec xcb_parts[4]; 1577 xcb_input_get_device_motion_events_cookie_t xcb_ret; 1578 xcb_input_get_device_motion_events_request_t xcb_out; 1579 1580 xcb_out.start = start; 1581 xcb_out.stop = stop; 1582 xcb_out.device_id = device_id; 1583 1584 xcb_parts[2].iov_base = (char *) &xcb_out; 1585 xcb_parts[2].iov_len = sizeof(xcb_out); 1586 xcb_parts[3].iov_base = 0; 1587 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1588 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1589 return xcb_ret; 1590 } 1591 1592 1593 /***************************************************************************** 1594 ** 1595 ** xcb_input_get_device_motion_events_reply_t * xcb_input_get_device_motion_events_reply 1596 ** 1597 ** @param xcb_connection_t *c 1598 ** @param xcb_input_get_device_motion_events_cookie_t cookie 1599 ** @param xcb_generic_error_t **e 1600 ** @returns xcb_input_get_device_motion_events_reply_t * 1601 ** 1602 *****************************************************************************/ 1603 1604 xcb_input_get_device_motion_events_reply_t * 1605 xcb_input_get_device_motion_events_reply (xcb_connection_t *c /**< */, 1606 xcb_input_get_device_motion_events_cookie_t cookie /**< */, 1607 xcb_generic_error_t **e /**< */) 1608 { 1609 return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1610 } 1611 1612 1613 /***************************************************************************** 1614 ** 1615 ** void xcb_input_device_time_coord_next 1616 ** 1617 ** @param xcb_input_device_time_coord_iterator_t *i 1618 ** @returns void 1619 ** 1620 *****************************************************************************/ 1621 1622 void 1623 xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i /**< */) 1624 { 1625 --i->rem; 1626 ++i->data; 1627 i->index += sizeof(xcb_input_device_time_coord_t); 1628 } 1629 1630 1631 /***************************************************************************** 1632 ** 1633 ** xcb_generic_iterator_t xcb_input_device_time_coord_end 1634 ** 1635 ** @param xcb_input_device_time_coord_iterator_t i 1636 ** @returns xcb_generic_iterator_t 1637 ** 1638 *****************************************************************************/ 1639 1640 xcb_generic_iterator_t 1641 xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i /**< */) 1642 { 1643 xcb_generic_iterator_t ret; 1644 ret.data = i.data + i.rem; 1645 ret.index = i.index + ((char *) ret.data - (char *) i.data); 1646 ret.rem = 0; 1647 return ret; 1648 } 1649 1650 1651 /***************************************************************************** 1652 ** 1653 ** xcb_input_change_keyboard_device_cookie_t xcb_input_change_keyboard_device 1654 ** 1655 ** @param xcb_connection_t *c 1656 ** @param uint8_t device_id 1657 ** @returns xcb_input_change_keyboard_device_cookie_t 1658 ** 1659 *****************************************************************************/ 1660 1661 xcb_input_change_keyboard_device_cookie_t 1662 xcb_input_change_keyboard_device (xcb_connection_t *c /**< */, 1663 uint8_t device_id /**< */) 1664 { 1665 static const xcb_protocol_request_t xcb_req = { 1666 /* count */ 2, 1667 /* ext */ &xcb_input_id, 1668 /* opcode */ XCB_INPUT_CHANGE_KEYBOARD_DEVICE, 1669 /* isvoid */ 0 1670 }; 1671 1672 struct iovec xcb_parts[4]; 1673 xcb_input_change_keyboard_device_cookie_t xcb_ret; 1674 xcb_input_change_keyboard_device_request_t xcb_out; 1675 1676 xcb_out.device_id = device_id; 1677 memset(xcb_out.pad0, 0, 3); 1678 1679 xcb_parts[2].iov_base = (char *) &xcb_out; 1680 xcb_parts[2].iov_len = sizeof(xcb_out); 1681 xcb_parts[3].iov_base = 0; 1682 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1683 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1684 return xcb_ret; 1685 } 1686 1687 1688 /***************************************************************************** 1689 ** 1690 ** xcb_input_change_keyboard_device_cookie_t xcb_input_change_keyboard_device_unchecked 1691 ** 1692 ** @param xcb_connection_t *c 1693 ** @param uint8_t device_id 1694 ** @returns xcb_input_change_keyboard_device_cookie_t 1695 ** 1696 *****************************************************************************/ 1697 1698 xcb_input_change_keyboard_device_cookie_t 1699 xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c /**< */, 1700 uint8_t device_id /**< */) 1701 { 1702 static const xcb_protocol_request_t xcb_req = { 1703 /* count */ 2, 1704 /* ext */ &xcb_input_id, 1705 /* opcode */ XCB_INPUT_CHANGE_KEYBOARD_DEVICE, 1706 /* isvoid */ 0 1707 }; 1708 1709 struct iovec xcb_parts[4]; 1710 xcb_input_change_keyboard_device_cookie_t xcb_ret; 1711 xcb_input_change_keyboard_device_request_t xcb_out; 1712 1713 xcb_out.device_id = device_id; 1714 memset(xcb_out.pad0, 0, 3); 1715 1716 xcb_parts[2].iov_base = (char *) &xcb_out; 1717 xcb_parts[2].iov_len = sizeof(xcb_out); 1718 xcb_parts[3].iov_base = 0; 1719 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1720 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1721 return xcb_ret; 1722 } 1723 1724 1725 /***************************************************************************** 1726 ** 1727 ** xcb_input_change_keyboard_device_reply_t * xcb_input_change_keyboard_device_reply 1728 ** 1729 ** @param xcb_connection_t *c 1730 ** @param xcb_input_change_keyboard_device_cookie_t cookie 1731 ** @param xcb_generic_error_t **e 1732 ** @returns xcb_input_change_keyboard_device_reply_t * 1733 ** 1734 *****************************************************************************/ 1735 1736 xcb_input_change_keyboard_device_reply_t * 1737 xcb_input_change_keyboard_device_reply (xcb_connection_t *c /**< */, 1738 xcb_input_change_keyboard_device_cookie_t cookie /**< */, 1739 xcb_generic_error_t **e /**< */) 1740 { 1741 return (xcb_input_change_keyboard_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1742 } 1743 1744 1745 /***************************************************************************** 1746 ** 1747 ** xcb_input_change_pointer_device_cookie_t xcb_input_change_pointer_device 1748 ** 1749 ** @param xcb_connection_t *c 1750 ** @param uint8_t x_axis 1751 ** @param uint8_t y_axis 1752 ** @param uint8_t device_id 1753 ** @returns xcb_input_change_pointer_device_cookie_t 1754 ** 1755 *****************************************************************************/ 1756 1757 xcb_input_change_pointer_device_cookie_t 1758 xcb_input_change_pointer_device (xcb_connection_t *c /**< */, 1759 uint8_t x_axis /**< */, 1760 uint8_t y_axis /**< */, 1761 uint8_t device_id /**< */) 1762 { 1763 static const xcb_protocol_request_t xcb_req = { 1764 /* count */ 2, 1765 /* ext */ &xcb_input_id, 1766 /* opcode */ XCB_INPUT_CHANGE_POINTER_DEVICE, 1767 /* isvoid */ 0 1768 }; 1769 1770 struct iovec xcb_parts[4]; 1771 xcb_input_change_pointer_device_cookie_t xcb_ret; 1772 xcb_input_change_pointer_device_request_t xcb_out; 1773 1774 xcb_out.x_axis = x_axis; 1775 xcb_out.y_axis = y_axis; 1776 xcb_out.device_id = device_id; 1777 xcb_out.pad0 = 0; 1778 1779 xcb_parts[2].iov_base = (char *) &xcb_out; 1780 xcb_parts[2].iov_len = sizeof(xcb_out); 1781 xcb_parts[3].iov_base = 0; 1782 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1783 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1784 return xcb_ret; 1785 } 1786 1787 1788 /***************************************************************************** 1789 ** 1790 ** xcb_input_change_pointer_device_cookie_t xcb_input_change_pointer_device_unchecked 1791 ** 1792 ** @param xcb_connection_t *c 1793 ** @param uint8_t x_axis 1794 ** @param uint8_t y_axis 1795 ** @param uint8_t device_id 1796 ** @returns xcb_input_change_pointer_device_cookie_t 1797 ** 1798 *****************************************************************************/ 1799 1800 xcb_input_change_pointer_device_cookie_t 1801 xcb_input_change_pointer_device_unchecked (xcb_connection_t *c /**< */, 1802 uint8_t x_axis /**< */, 1803 uint8_t y_axis /**< */, 1804 uint8_t device_id /**< */) 1805 { 1806 static const xcb_protocol_request_t xcb_req = { 1807 /* count */ 2, 1808 /* ext */ &xcb_input_id, 1809 /* opcode */ XCB_INPUT_CHANGE_POINTER_DEVICE, 1810 /* isvoid */ 0 1811 }; 1812 1813 struct iovec xcb_parts[4]; 1814 xcb_input_change_pointer_device_cookie_t xcb_ret; 1815 xcb_input_change_pointer_device_request_t xcb_out; 1816 1817 xcb_out.x_axis = x_axis; 1818 xcb_out.y_axis = y_axis; 1819 xcb_out.device_id = device_id; 1820 xcb_out.pad0 = 0; 1821 1822 xcb_parts[2].iov_base = (char *) &xcb_out; 1823 xcb_parts[2].iov_len = sizeof(xcb_out); 1824 xcb_parts[3].iov_base = 0; 1825 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1826 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1827 return xcb_ret; 1828 } 1829 1830 1831 /***************************************************************************** 1832 ** 1833 ** xcb_input_change_pointer_device_reply_t * xcb_input_change_pointer_device_reply 1834 ** 1835 ** @param xcb_connection_t *c 1836 ** @param xcb_input_change_pointer_device_cookie_t cookie 1837 ** @param xcb_generic_error_t **e 1838 ** @returns xcb_input_change_pointer_device_reply_t * 1839 ** 1840 *****************************************************************************/ 1841 1842 xcb_input_change_pointer_device_reply_t * 1843 xcb_input_change_pointer_device_reply (xcb_connection_t *c /**< */, 1844 xcb_input_change_pointer_device_cookie_t cookie /**< */, 1845 xcb_generic_error_t **e /**< */) 1846 { 1847 return (xcb_input_change_pointer_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1848 } 1849 1850 1851 /***************************************************************************** 1852 ** 1853 ** xcb_input_grab_device_cookie_t xcb_input_grab_device 1854 ** 1855 ** @param xcb_connection_t *c 1856 ** @param xcb_window_t grab_window 1857 ** @param xcb_timestamp_t time 1858 ** @param uint16_t num_classes 1859 ** @param uint8_t this_device_mode 1860 ** @param uint8_t other_device_mode 1861 ** @param uint8_t owner_events 1862 ** @param uint8_t device_id 1863 ** @param const xcb_input_event_class_t *classes 1864 ** @returns xcb_input_grab_device_cookie_t 1865 ** 1866 *****************************************************************************/ 1867 1868 xcb_input_grab_device_cookie_t 1869 xcb_input_grab_device (xcb_connection_t *c /**< */, 1870 xcb_window_t grab_window /**< */, 1871 xcb_timestamp_t time /**< */, 1872 uint16_t num_classes /**< */, 1873 uint8_t this_device_mode /**< */, 1874 uint8_t other_device_mode /**< */, 1875 uint8_t owner_events /**< */, 1876 uint8_t device_id /**< */, 1877 const xcb_input_event_class_t *classes /**< */) 1878 { 1879 static const xcb_protocol_request_t xcb_req = { 1880 /* count */ 4, 1881 /* ext */ &xcb_input_id, 1882 /* opcode */ XCB_INPUT_GRAB_DEVICE, 1883 /* isvoid */ 0 1884 }; 1885 1886 struct iovec xcb_parts[6]; 1887 xcb_input_grab_device_cookie_t xcb_ret; 1888 xcb_input_grab_device_request_t xcb_out; 1889 1890 xcb_out.grab_window = grab_window; 1891 xcb_out.time = time; 1892 xcb_out.num_classes = num_classes; 1893 xcb_out.this_device_mode = this_device_mode; 1894 xcb_out.other_device_mode = other_device_mode; 1895 xcb_out.owner_events = owner_events; 1896 xcb_out.device_id = device_id; 1897 memset(xcb_out.pad0, 0, 2); 1898 1899 xcb_parts[2].iov_base = (char *) &xcb_out; 1900 xcb_parts[2].iov_len = sizeof(xcb_out); 1901 xcb_parts[3].iov_base = 0; 1902 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1903 xcb_parts[4].iov_base = (char *) classes; 1904 xcb_parts[4].iov_len = num_classes * sizeof(uint32_t); 1905 xcb_parts[5].iov_base = 0; 1906 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1907 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1908 return xcb_ret; 1909 } 1910 1911 1912 /***************************************************************************** 1913 ** 1914 ** xcb_input_grab_device_cookie_t xcb_input_grab_device_unchecked 1915 ** 1916 ** @param xcb_connection_t *c 1917 ** @param xcb_window_t grab_window 1918 ** @param xcb_timestamp_t time 1919 ** @param uint16_t num_classes 1920 ** @param uint8_t this_device_mode 1921 ** @param uint8_t other_device_mode 1922 ** @param uint8_t owner_events 1923 ** @param uint8_t device_id 1924 ** @param const xcb_input_event_class_t *classes 1925 ** @returns xcb_input_grab_device_cookie_t 1926 ** 1927 *****************************************************************************/ 1928 1929 xcb_input_grab_device_cookie_t 1930 xcb_input_grab_device_unchecked (xcb_connection_t *c /**< */, 1931 xcb_window_t grab_window /**< */, 1932 xcb_timestamp_t time /**< */, 1933 uint16_t num_classes /**< */, 1934 uint8_t this_device_mode /**< */, 1935 uint8_t other_device_mode /**< */, 1936 uint8_t owner_events /**< */, 1937 uint8_t device_id /**< */, 1938 const xcb_input_event_class_t *classes /**< */) 1939 { 1940 static const xcb_protocol_request_t xcb_req = { 1941 /* count */ 4, 1942 /* ext */ &xcb_input_id, 1943 /* opcode */ XCB_INPUT_GRAB_DEVICE, 1944 /* isvoid */ 0 1945 }; 1946 1947 struct iovec xcb_parts[6]; 1948 xcb_input_grab_device_cookie_t xcb_ret; 1949 xcb_input_grab_device_request_t xcb_out; 1950 1951 xcb_out.grab_window = grab_window; 1952 xcb_out.time = time; 1953 xcb_out.num_classes = num_classes; 1954 xcb_out.this_device_mode = this_device_mode; 1955 xcb_out.other_device_mode = other_device_mode; 1956 xcb_out.owner_events = owner_events; 1957 xcb_out.device_id = device_id; 1958 memset(xcb_out.pad0, 0, 2); 1959 1960 xcb_parts[2].iov_base = (char *) &xcb_out; 1961 xcb_parts[2].iov_len = sizeof(xcb_out); 1962 xcb_parts[3].iov_base = 0; 1963 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1964 xcb_parts[4].iov_base = (char *) classes; 1965 xcb_parts[4].iov_len = num_classes * sizeof(uint32_t); 1966 xcb_parts[5].iov_base = 0; 1967 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1968 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1969 return xcb_ret; 1970 } 1971 1972 1973 /***************************************************************************** 1974 ** 1975 ** xcb_input_grab_device_reply_t * xcb_input_grab_device_reply 1976 ** 1977 ** @param xcb_connection_t *c 1978 ** @param xcb_input_grab_device_cookie_t cookie 1979 ** @param xcb_generic_error_t **e 1980 ** @returns xcb_input_grab_device_reply_t * 1981 ** 1982 *****************************************************************************/ 1983 1984 xcb_input_grab_device_reply_t * 1985 xcb_input_grab_device_reply (xcb_connection_t *c /**< */, 1986 xcb_input_grab_device_cookie_t cookie /**< */, 1987 xcb_generic_error_t **e /**< */) 1988 { 1989 return (xcb_input_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1990 } 1991 1992 1993 /***************************************************************************** 1994 ** 1995 ** xcb_void_cookie_t xcb_input_ungrab_device_checked 1996 ** 1997 ** @param xcb_connection_t *c 1998 ** @param xcb_timestamp_t time 1999 ** @param uint8_t device_id 2000 ** @returns xcb_void_cookie_t 2001 ** 2002 *****************************************************************************/ 2003 2004 xcb_void_cookie_t 2005 xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, 2006 xcb_timestamp_t time /**< */, 2007 uint8_t device_id /**< */) 2008 { 2009 static const xcb_protocol_request_t xcb_req = { 2010 /* count */ 2, 2011 /* ext */ &xcb_input_id, 2012 /* opcode */ XCB_INPUT_UNGRAB_DEVICE, 2013 /* isvoid */ 1 2014 }; 2015 2016 struct iovec xcb_parts[4]; 2017 xcb_void_cookie_t xcb_ret; 2018 xcb_input_ungrab_device_request_t xcb_out; 2019 2020 xcb_out.time = time; 2021 xcb_out.device_id = device_id; 2022 2023 xcb_parts[2].iov_base = (char *) &xcb_out; 2024 xcb_parts[2].iov_len = sizeof(xcb_out); 2025 xcb_parts[3].iov_base = 0; 2026 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2027 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2028 return xcb_ret; 2029 } 2030 2031 2032 /***************************************************************************** 2033 ** 2034 ** xcb_void_cookie_t xcb_input_ungrab_device 2035 ** 2036 ** @param xcb_connection_t *c 2037 ** @param xcb_timestamp_t time 2038 ** @param uint8_t device_id 2039 ** @returns xcb_void_cookie_t 2040 ** 2041 *****************************************************************************/ 2042 2043 xcb_void_cookie_t 2044 xcb_input_ungrab_device (xcb_connection_t *c /**< */, 2045 xcb_timestamp_t time /**< */, 2046 uint8_t device_id /**< */) 2047 { 2048 static const xcb_protocol_request_t xcb_req = { 2049 /* count */ 2, 2050 /* ext */ &xcb_input_id, 2051 /* opcode */ XCB_INPUT_UNGRAB_DEVICE, 2052 /* isvoid */ 1 2053 }; 2054 2055 struct iovec xcb_parts[4]; 2056 xcb_void_cookie_t xcb_ret; 2057 xcb_input_ungrab_device_request_t xcb_out; 2058 2059 xcb_out.time = time; 2060 xcb_out.device_id = device_id; 2061 2062 xcb_parts[2].iov_base = (char *) &xcb_out; 2063 xcb_parts[2].iov_len = sizeof(xcb_out); 2064 xcb_parts[3].iov_base = 0; 2065 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2066 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2067 return xcb_ret; 2068 } 2069 2070 2071 /***************************************************************************** 2072 ** 2073 ** xcb_void_cookie_t xcb_input_grab_device_key_checked 2074 ** 2075 ** @param xcb_connection_t *c 2076 ** @param xcb_window_t grab_window 2077 ** @param uint16_t num_classes 2078 ** @param uint16_t modifiers 2079 ** @param uint8_t modifier_device 2080 ** @param uint8_t grabbed_device 2081 ** @param uint8_t key 2082 ** @param uint8_t this_device_mode 2083 ** @param uint8_t other_device_mode 2084 ** @param uint8_t owner_events 2085 ** @param const xcb_input_event_class_t *classes 2086 ** @returns xcb_void_cookie_t 2087 ** 2088 *****************************************************************************/ 2089 2090 xcb_void_cookie_t 2091 xcb_input_grab_device_key_checked (xcb_connection_t *c /**< */, 2092 xcb_window_t grab_window /**< */, 2093 uint16_t num_classes /**< */, 2094 uint16_t modifiers /**< */, 2095 uint8_t modifier_device /**< */, 2096 uint8_t grabbed_device /**< */, 2097 uint8_t key /**< */, 2098 uint8_t this_device_mode /**< */, 2099 uint8_t other_device_mode /**< */, 2100 uint8_t owner_events /**< */, 2101 const xcb_input_event_class_t *classes /**< */) 2102 { 2103 static const xcb_protocol_request_t xcb_req = { 2104 /* count */ 4, 2105 /* ext */ &xcb_input_id, 2106 /* opcode */ XCB_INPUT_GRAB_DEVICE_KEY, 2107 /* isvoid */ 1 2108 }; 2109 2110 struct iovec xcb_parts[6]; 2111 xcb_void_cookie_t xcb_ret; 2112 xcb_input_grab_device_key_request_t xcb_out; 2113 2114 xcb_out.grab_window = grab_window; 2115 xcb_out.num_classes = num_classes; 2116 xcb_out.modifiers = modifiers; 2117 xcb_out.modifier_device = modifier_device; 2118 xcb_out.grabbed_device = grabbed_device; 2119 xcb_out.key = key; 2120 xcb_out.this_device_mode = this_device_mode; 2121 xcb_out.other_device_mode = other_device_mode; 2122 xcb_out.owner_events = owner_events; 2123 memset(xcb_out.pad0, 0, 2); 2124 2125 xcb_parts[2].iov_base = (char *) &xcb_out; 2126 xcb_parts[2].iov_len = sizeof(xcb_out); 2127 xcb_parts[3].iov_base = 0; 2128 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2129 xcb_parts[4].iov_base = (char *) classes; 2130 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 2131 xcb_parts[5].iov_base = 0; 2132 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2133 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2134 return xcb_ret; 2135 } 2136 2137 2138 /***************************************************************************** 2139 ** 2140 ** xcb_void_cookie_t xcb_input_grab_device_key 2141 ** 2142 ** @param xcb_connection_t *c 2143 ** @param xcb_window_t grab_window 2144 ** @param uint16_t num_classes 2145 ** @param uint16_t modifiers 2146 ** @param uint8_t modifier_device 2147 ** @param uint8_t grabbed_device 2148 ** @param uint8_t key 2149 ** @param uint8_t this_device_mode 2150 ** @param uint8_t other_device_mode 2151 ** @param uint8_t owner_events 2152 ** @param const xcb_input_event_class_t *classes 2153 ** @returns xcb_void_cookie_t 2154 ** 2155 *****************************************************************************/ 2156 2157 xcb_void_cookie_t 2158 xcb_input_grab_device_key (xcb_connection_t *c /**< */, 2159 xcb_window_t grab_window /**< */, 2160 uint16_t num_classes /**< */, 2161 uint16_t modifiers /**< */, 2162 uint8_t modifier_device /**< */, 2163 uint8_t grabbed_device /**< */, 2164 uint8_t key /**< */, 2165 uint8_t this_device_mode /**< */, 2166 uint8_t other_device_mode /**< */, 2167 uint8_t owner_events /**< */, 2168 const xcb_input_event_class_t *classes /**< */) 2169 { 2170 static const xcb_protocol_request_t xcb_req = { 2171 /* count */ 4, 2172 /* ext */ &xcb_input_id, 2173 /* opcode */ XCB_INPUT_GRAB_DEVICE_KEY, 2174 /* isvoid */ 1 2175 }; 2176 2177 struct iovec xcb_parts[6]; 2178 xcb_void_cookie_t xcb_ret; 2179 xcb_input_grab_device_key_request_t xcb_out; 2180 2181 xcb_out.grab_window = grab_window; 2182 xcb_out.num_classes = num_classes; 2183 xcb_out.modifiers = modifiers; 2184 xcb_out.modifier_device = modifier_device; 2185 xcb_out.grabbed_device = grabbed_device; 2186 xcb_out.key = key; 2187 xcb_out.this_device_mode = this_device_mode; 2188 xcb_out.other_device_mode = other_device_mode; 2189 xcb_out.owner_events = owner_events; 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_parts[4].iov_base = (char *) classes; 2197 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 2198 xcb_parts[5].iov_base = 0; 2199 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2200 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2201 return xcb_ret; 2202 } 2203 2204 2205 /***************************************************************************** 2206 ** 2207 ** xcb_void_cookie_t xcb_input_ungrab_device_key_checked 2208 ** 2209 ** @param xcb_connection_t *c 2210 ** @param xcb_window_t grabWindow 2211 ** @param uint16_t modifiers 2212 ** @param uint8_t modifier_device 2213 ** @param uint8_t key 2214 ** @param uint8_t grabbed_device 2215 ** @returns xcb_void_cookie_t 2216 ** 2217 *****************************************************************************/ 2218 2219 xcb_void_cookie_t 2220 xcb_input_ungrab_device_key_checked (xcb_connection_t *c /**< */, 2221 xcb_window_t grabWindow /**< */, 2222 uint16_t modifiers /**< */, 2223 uint8_t modifier_device /**< */, 2224 uint8_t key /**< */, 2225 uint8_t grabbed_device /**< */) 2226 { 2227 static const xcb_protocol_request_t xcb_req = { 2228 /* count */ 2, 2229 /* ext */ &xcb_input_id, 2230 /* opcode */ XCB_INPUT_UNGRAB_DEVICE_KEY, 2231 /* isvoid */ 1 2232 }; 2233 2234 struct iovec xcb_parts[4]; 2235 xcb_void_cookie_t xcb_ret; 2236 xcb_input_ungrab_device_key_request_t xcb_out; 2237 2238 xcb_out.grabWindow = grabWindow; 2239 xcb_out.modifiers = modifiers; 2240 xcb_out.modifier_device = modifier_device; 2241 xcb_out.key = key; 2242 xcb_out.grabbed_device = grabbed_device; 2243 2244 xcb_parts[2].iov_base = (char *) &xcb_out; 2245 xcb_parts[2].iov_len = sizeof(xcb_out); 2246 xcb_parts[3].iov_base = 0; 2247 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2248 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2249 return xcb_ret; 2250 } 2251 2252 2253 /***************************************************************************** 2254 ** 2255 ** xcb_void_cookie_t xcb_input_ungrab_device_key 2256 ** 2257 ** @param xcb_connection_t *c 2258 ** @param xcb_window_t grabWindow 2259 ** @param uint16_t modifiers 2260 ** @param uint8_t modifier_device 2261 ** @param uint8_t key 2262 ** @param uint8_t grabbed_device 2263 ** @returns xcb_void_cookie_t 2264 ** 2265 *****************************************************************************/ 2266 2267 xcb_void_cookie_t 2268 xcb_input_ungrab_device_key (xcb_connection_t *c /**< */, 2269 xcb_window_t grabWindow /**< */, 2270 uint16_t modifiers /**< */, 2271 uint8_t modifier_device /**< */, 2272 uint8_t key /**< */, 2273 uint8_t grabbed_device /**< */) 2274 { 2275 static const xcb_protocol_request_t xcb_req = { 2276 /* count */ 2, 2277 /* ext */ &xcb_input_id, 2278 /* opcode */ XCB_INPUT_UNGRAB_DEVICE_KEY, 2279 /* isvoid */ 1 2280 }; 2281 2282 struct iovec xcb_parts[4]; 2283 xcb_void_cookie_t xcb_ret; 2284 xcb_input_ungrab_device_key_request_t xcb_out; 2285 2286 xcb_out.grabWindow = grabWindow; 2287 xcb_out.modifiers = modifiers; 2288 xcb_out.modifier_device = modifier_device; 2289 xcb_out.key = key; 2290 xcb_out.grabbed_device = grabbed_device; 2291 2292 xcb_parts[2].iov_base = (char *) &xcb_out; 2293 xcb_parts[2].iov_len = sizeof(xcb_out); 2294 xcb_parts[3].iov_base = 0; 2295 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2296 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2297 return xcb_ret; 2298 } 2299 2300 2301 /***************************************************************************** 2302 ** 2303 ** xcb_void_cookie_t xcb_input_grab_device_button_checked 2304 ** 2305 ** @param xcb_connection_t *c 2306 ** @param xcb_window_t grab_window 2307 ** @param uint8_t grabbed_device 2308 ** @param uint8_t modifier_device 2309 ** @param uint16_t num_classes 2310 ** @param uint16_t modifiers 2311 ** @param uint8_t this_device_mode 2312 ** @param uint8_t other_device_mode 2313 ** @param uint8_t button 2314 ** @param uint8_t owner_events 2315 ** @param const xcb_input_event_class_t *classes 2316 ** @returns xcb_void_cookie_t 2317 ** 2318 *****************************************************************************/ 2319 2320 xcb_void_cookie_t 2321 xcb_input_grab_device_button_checked (xcb_connection_t *c /**< */, 2322 xcb_window_t grab_window /**< */, 2323 uint8_t grabbed_device /**< */, 2324 uint8_t modifier_device /**< */, 2325 uint16_t num_classes /**< */, 2326 uint16_t modifiers /**< */, 2327 uint8_t this_device_mode /**< */, 2328 uint8_t other_device_mode /**< */, 2329 uint8_t button /**< */, 2330 uint8_t owner_events /**< */, 2331 const xcb_input_event_class_t *classes /**< */) 2332 { 2333 static const xcb_protocol_request_t xcb_req = { 2334 /* count */ 4, 2335 /* ext */ &xcb_input_id, 2336 /* opcode */ XCB_INPUT_GRAB_DEVICE_BUTTON, 2337 /* isvoid */ 1 2338 }; 2339 2340 struct iovec xcb_parts[6]; 2341 xcb_void_cookie_t xcb_ret; 2342 xcb_input_grab_device_button_request_t xcb_out; 2343 2344 xcb_out.grab_window = grab_window; 2345 xcb_out.grabbed_device = grabbed_device; 2346 xcb_out.modifier_device = modifier_device; 2347 xcb_out.num_classes = num_classes; 2348 xcb_out.modifiers = modifiers; 2349 xcb_out.this_device_mode = this_device_mode; 2350 xcb_out.other_device_mode = other_device_mode; 2351 xcb_out.button = button; 2352 xcb_out.owner_events = owner_events; 2353 memset(xcb_out.pad0, 0, 2); 2354 2355 xcb_parts[2].iov_base = (char *) &xcb_out; 2356 xcb_parts[2].iov_len = sizeof(xcb_out); 2357 xcb_parts[3].iov_base = 0; 2358 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2359 xcb_parts[4].iov_base = (char *) classes; 2360 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 2361 xcb_parts[5].iov_base = 0; 2362 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2363 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2364 return xcb_ret; 2365 } 2366 2367 2368 /***************************************************************************** 2369 ** 2370 ** xcb_void_cookie_t xcb_input_grab_device_button 2371 ** 2372 ** @param xcb_connection_t *c 2373 ** @param xcb_window_t grab_window 2374 ** @param uint8_t grabbed_device 2375 ** @param uint8_t modifier_device 2376 ** @param uint16_t num_classes 2377 ** @param uint16_t modifiers 2378 ** @param uint8_t this_device_mode 2379 ** @param uint8_t other_device_mode 2380 ** @param uint8_t button 2381 ** @param uint8_t owner_events 2382 ** @param const xcb_input_event_class_t *classes 2383 ** @returns xcb_void_cookie_t 2384 ** 2385 *****************************************************************************/ 2386 2387 xcb_void_cookie_t 2388 xcb_input_grab_device_button (xcb_connection_t *c /**< */, 2389 xcb_window_t grab_window /**< */, 2390 uint8_t grabbed_device /**< */, 2391 uint8_t modifier_device /**< */, 2392 uint16_t num_classes /**< */, 2393 uint16_t modifiers /**< */, 2394 uint8_t this_device_mode /**< */, 2395 uint8_t other_device_mode /**< */, 2396 uint8_t button /**< */, 2397 uint8_t owner_events /**< */, 2398 const xcb_input_event_class_t *classes /**< */) 2399 { 2400 static const xcb_protocol_request_t xcb_req = { 2401 /* count */ 4, 2402 /* ext */ &xcb_input_id, 2403 /* opcode */ XCB_INPUT_GRAB_DEVICE_BUTTON, 2404 /* isvoid */ 1 2405 }; 2406 2407 struct iovec xcb_parts[6]; 2408 xcb_void_cookie_t xcb_ret; 2409 xcb_input_grab_device_button_request_t xcb_out; 2410 2411 xcb_out.grab_window = grab_window; 2412 xcb_out.grabbed_device = grabbed_device; 2413 xcb_out.modifier_device = modifier_device; 2414 xcb_out.num_classes = num_classes; 2415 xcb_out.modifiers = modifiers; 2416 xcb_out.this_device_mode = this_device_mode; 2417 xcb_out.other_device_mode = other_device_mode; 2418 xcb_out.button = button; 2419 xcb_out.owner_events = owner_events; 2420 memset(xcb_out.pad0, 0, 2); 2421 2422 xcb_parts[2].iov_base = (char *) &xcb_out; 2423 xcb_parts[2].iov_len = sizeof(xcb_out); 2424 xcb_parts[3].iov_base = 0; 2425 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2426 xcb_parts[4].iov_base = (char *) classes; 2427 xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t); 2428 xcb_parts[5].iov_base = 0; 2429 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2430 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2431 return xcb_ret; 2432 } 2433 2434 2435 /***************************************************************************** 2436 ** 2437 ** xcb_void_cookie_t xcb_input_ungrab_device_button_checked 2438 ** 2439 ** @param xcb_connection_t *c 2440 ** @param xcb_window_t grab_window 2441 ** @param uint16_t modifiers 2442 ** @param uint8_t modifier_device 2443 ** @param uint8_t button 2444 ** @param uint8_t grabbed_device 2445 ** @returns xcb_void_cookie_t 2446 ** 2447 *****************************************************************************/ 2448 2449 xcb_void_cookie_t 2450 xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, 2451 xcb_window_t grab_window /**< */, 2452 uint16_t modifiers /**< */, 2453 uint8_t modifier_device /**< */, 2454 uint8_t button /**< */, 2455 uint8_t grabbed_device /**< */) 2456 { 2457 static const xcb_protocol_request_t xcb_req = { 2458 /* count */ 2, 2459 /* ext */ &xcb_input_id, 2460 /* opcode */ XCB_INPUT_UNGRAB_DEVICE_BUTTON, 2461 /* isvoid */ 1 2462 }; 2463 2464 struct iovec xcb_parts[4]; 2465 xcb_void_cookie_t xcb_ret; 2466 xcb_input_ungrab_device_button_request_t xcb_out; 2467 2468 xcb_out.grab_window = grab_window; 2469 xcb_out.modifiers = modifiers; 2470 xcb_out.modifier_device = modifier_device; 2471 xcb_out.button = button; 2472 xcb_out.grabbed_device = grabbed_device; 2473 2474 xcb_parts[2].iov_base = (char *) &xcb_out; 2475 xcb_parts[2].iov_len = sizeof(xcb_out); 2476 xcb_parts[3].iov_base = 0; 2477 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2478 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2479 return xcb_ret; 2480 } 2481 2482 2483 /***************************************************************************** 2484 ** 2485 ** xcb_void_cookie_t xcb_input_ungrab_device_button 2486 ** 2487 ** @param xcb_connection_t *c 2488 ** @param xcb_window_t grab_window 2489 ** @param uint16_t modifiers 2490 ** @param uint8_t modifier_device 2491 ** @param uint8_t button 2492 ** @param uint8_t grabbed_device 2493 ** @returns xcb_void_cookie_t 2494 ** 2495 *****************************************************************************/ 2496 2497 xcb_void_cookie_t 2498 xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, 2499 xcb_window_t grab_window /**< */, 2500 uint16_t modifiers /**< */, 2501 uint8_t modifier_device /**< */, 2502 uint8_t button /**< */, 2503 uint8_t grabbed_device /**< */) 2504 { 2505 static const xcb_protocol_request_t xcb_req = { 2506 /* count */ 2, 2507 /* ext */ &xcb_input_id, 2508 /* opcode */ XCB_INPUT_UNGRAB_DEVICE_BUTTON, 2509 /* isvoid */ 1 2510 }; 2511 2512 struct iovec xcb_parts[4]; 2513 xcb_void_cookie_t xcb_ret; 2514 xcb_input_ungrab_device_button_request_t xcb_out; 2515 2516 xcb_out.grab_window = grab_window; 2517 xcb_out.modifiers = modifiers; 2518 xcb_out.modifier_device = modifier_device; 2519 xcb_out.button = button; 2520 xcb_out.grabbed_device = grabbed_device; 2521 2522 xcb_parts[2].iov_base = (char *) &xcb_out; 2523 xcb_parts[2].iov_len = sizeof(xcb_out); 2524 xcb_parts[3].iov_base = 0; 2525 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2526 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2527 return xcb_ret; 2528 } 2529 2530 2531 /***************************************************************************** 2532 ** 2533 ** xcb_void_cookie_t xcb_input_allow_device_events_checked 2534 ** 2535 ** @param xcb_connection_t *c 2536 ** @param xcb_timestamp_t time 2537 ** @param uint8_t mode 2538 ** @param uint8_t device_id 2539 ** @returns xcb_void_cookie_t 2540 ** 2541 *****************************************************************************/ 2542 2543 xcb_void_cookie_t 2544 xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, 2545 xcb_timestamp_t time /**< */, 2546 uint8_t mode /**< */, 2547 uint8_t device_id /**< */) 2548 { 2549 static const xcb_protocol_request_t xcb_req = { 2550 /* count */ 2, 2551 /* ext */ &xcb_input_id, 2552 /* opcode */ XCB_INPUT_ALLOW_DEVICE_EVENTS, 2553 /* isvoid */ 1 2554 }; 2555 2556 struct iovec xcb_parts[4]; 2557 xcb_void_cookie_t xcb_ret; 2558 xcb_input_allow_device_events_request_t xcb_out; 2559 2560 xcb_out.time = time; 2561 xcb_out.mode = mode; 2562 xcb_out.device_id = device_id; 2563 2564 xcb_parts[2].iov_base = (char *) &xcb_out; 2565 xcb_parts[2].iov_len = sizeof(xcb_out); 2566 xcb_parts[3].iov_base = 0; 2567 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2568 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2569 return xcb_ret; 2570 } 2571 2572 2573 /***************************************************************************** 2574 ** 2575 ** xcb_void_cookie_t xcb_input_allow_device_events 2576 ** 2577 ** @param xcb_connection_t *c 2578 ** @param xcb_timestamp_t time 2579 ** @param uint8_t mode 2580 ** @param uint8_t device_id 2581 ** @returns xcb_void_cookie_t 2582 ** 2583 *****************************************************************************/ 2584 2585 xcb_void_cookie_t 2586 xcb_input_allow_device_events (xcb_connection_t *c /**< */, 2587 xcb_timestamp_t time /**< */, 2588 uint8_t mode /**< */, 2589 uint8_t device_id /**< */) 2590 { 2591 static const xcb_protocol_request_t xcb_req = { 2592 /* count */ 2, 2593 /* ext */ &xcb_input_id, 2594 /* opcode */ XCB_INPUT_ALLOW_DEVICE_EVENTS, 2595 /* isvoid */ 1 2596 }; 2597 2598 struct iovec xcb_parts[4]; 2599 xcb_void_cookie_t xcb_ret; 2600 xcb_input_allow_device_events_request_t xcb_out; 2601 2602 xcb_out.time = time; 2603 xcb_out.mode = mode; 2604 xcb_out.device_id = device_id; 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_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2611 return xcb_ret; 2612 } 2613 2614 2615 /***************************************************************************** 2616 ** 2617 ** xcb_input_get_device_focus_cookie_t xcb_input_get_device_focus 2618 ** 2619 ** @param xcb_connection_t *c 2620 ** @param uint8_t device_id 2621 ** @returns xcb_input_get_device_focus_cookie_t 2622 ** 2623 *****************************************************************************/ 2624 2625 xcb_input_get_device_focus_cookie_t 2626 xcb_input_get_device_focus (xcb_connection_t *c /**< */, 2627 uint8_t device_id /**< */) 2628 { 2629 static const xcb_protocol_request_t xcb_req = { 2630 /* count */ 2, 2631 /* ext */ &xcb_input_id, 2632 /* opcode */ XCB_INPUT_GET_DEVICE_FOCUS, 2633 /* isvoid */ 0 2634 }; 2635 2636 struct iovec xcb_parts[4]; 2637 xcb_input_get_device_focus_cookie_t xcb_ret; 2638 xcb_input_get_device_focus_request_t xcb_out; 2639 2640 xcb_out.device_id = device_id; 2641 memset(xcb_out.pad0, 0, 3); 2642 2643 xcb_parts[2].iov_base = (char *) &xcb_out; 2644 xcb_parts[2].iov_len = sizeof(xcb_out); 2645 xcb_parts[3].iov_base = 0; 2646 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2647 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2648 return xcb_ret; 2649 } 2650 2651 2652 /***************************************************************************** 2653 ** 2654 ** xcb_input_get_device_focus_cookie_t xcb_input_get_device_focus_unchecked 2655 ** 2656 ** @param xcb_connection_t *c 2657 ** @param uint8_t device_id 2658 ** @returns xcb_input_get_device_focus_cookie_t 2659 ** 2660 *****************************************************************************/ 2661 2662 xcb_input_get_device_focus_cookie_t 2663 xcb_input_get_device_focus_unchecked (xcb_connection_t *c /**< */, 2664 uint8_t device_id /**< */) 2665 { 2666 static const xcb_protocol_request_t xcb_req = { 2667 /* count */ 2, 2668 /* ext */ &xcb_input_id, 2669 /* opcode */ XCB_INPUT_GET_DEVICE_FOCUS, 2670 /* isvoid */ 0 2671 }; 2672 2673 struct iovec xcb_parts[4]; 2674 xcb_input_get_device_focus_cookie_t xcb_ret; 2675 xcb_input_get_device_focus_request_t xcb_out; 2676 2677 xcb_out.device_id = device_id; 2678 memset(xcb_out.pad0, 0, 3); 2679 2680 xcb_parts[2].iov_base = (char *) &xcb_out; 2681 xcb_parts[2].iov_len = sizeof(xcb_out); 2682 xcb_parts[3].iov_base = 0; 2683 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2684 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2685 return xcb_ret; 2686 } 2687 2688 2689 /***************************************************************************** 2690 ** 2691 ** xcb_input_get_device_focus_reply_t * xcb_input_get_device_focus_reply 2692 ** 2693 ** @param xcb_connection_t *c 2694 ** @param xcb_input_get_device_focus_cookie_t cookie 2695 ** @param xcb_generic_error_t **e 2696 ** @returns xcb_input_get_device_focus_reply_t * 2697 ** 2698 *****************************************************************************/ 2699 2700 xcb_input_get_device_focus_reply_t * 2701 xcb_input_get_device_focus_reply (xcb_connection_t *c /**< */, 2702 xcb_input_get_device_focus_cookie_t cookie /**< */, 2703 xcb_generic_error_t **e /**< */) 2704 { 2705 return (xcb_input_get_device_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2706 } 2707 2708 2709 /***************************************************************************** 2710 ** 2711 ** xcb_void_cookie_t xcb_input_set_device_focus_checked 2712 ** 2713 ** @param xcb_connection_t *c 2714 ** @param xcb_window_t focus 2715 ** @param xcb_timestamp_t time 2716 ** @param uint8_t revert_to 2717 ** @param uint8_t device_id 2718 ** @returns xcb_void_cookie_t 2719 ** 2720 *****************************************************************************/ 2721 2722 xcb_void_cookie_t 2723 xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, 2724 xcb_window_t focus /**< */, 2725 xcb_timestamp_t time /**< */, 2726 uint8_t revert_to /**< */, 2727 uint8_t device_id /**< */) 2728 { 2729 static const xcb_protocol_request_t xcb_req = { 2730 /* count */ 2, 2731 /* ext */ &xcb_input_id, 2732 /* opcode */ XCB_INPUT_SET_DEVICE_FOCUS, 2733 /* isvoid */ 1 2734 }; 2735 2736 struct iovec xcb_parts[4]; 2737 xcb_void_cookie_t xcb_ret; 2738 xcb_input_set_device_focus_request_t xcb_out; 2739 2740 xcb_out.focus = focus; 2741 xcb_out.time = time; 2742 xcb_out.revert_to = revert_to; 2743 xcb_out.device_id = device_id; 2744 2745 xcb_parts[2].iov_base = (char *) &xcb_out; 2746 xcb_parts[2].iov_len = sizeof(xcb_out); 2747 xcb_parts[3].iov_base = 0; 2748 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2749 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2750 return xcb_ret; 2751 } 2752 2753 2754 /***************************************************************************** 2755 ** 2756 ** xcb_void_cookie_t xcb_input_set_device_focus 2757 ** 2758 ** @param xcb_connection_t *c 2759 ** @param xcb_window_t focus 2760 ** @param xcb_timestamp_t time 2761 ** @param uint8_t revert_to 2762 ** @param uint8_t device_id 2763 ** @returns xcb_void_cookie_t 2764 ** 2765 *****************************************************************************/ 2766 2767 xcb_void_cookie_t 2768 xcb_input_set_device_focus (xcb_connection_t *c /**< */, 2769 xcb_window_t focus /**< */, 2770 xcb_timestamp_t time /**< */, 2771 uint8_t revert_to /**< */, 2772 uint8_t device_id /**< */) 2773 { 2774 static const xcb_protocol_request_t xcb_req = { 2775 /* count */ 2, 2776 /* ext */ &xcb_input_id, 2777 /* opcode */ XCB_INPUT_SET_DEVICE_FOCUS, 2778 /* isvoid */ 1 2779 }; 2780 2781 struct iovec xcb_parts[4]; 2782 xcb_void_cookie_t xcb_ret; 2783 xcb_input_set_device_focus_request_t xcb_out; 2784 2785 xcb_out.focus = focus; 2786 xcb_out.time = time; 2787 xcb_out.revert_to = revert_to; 2788 xcb_out.device_id = device_id; 2789 2790 xcb_parts[2].iov_base = (char *) &xcb_out; 2791 xcb_parts[2].iov_len = sizeof(xcb_out); 2792 xcb_parts[3].iov_base = 0; 2793 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2794 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2795 return xcb_ret; 2796 } 2797 2798 2799 /***************************************************************************** 2800 ** 2801 ** xcb_input_get_feedback_control_cookie_t xcb_input_get_feedback_control 2802 ** 2803 ** @param xcb_connection_t *c 2804 ** @param uint8_t device_id 2805 ** @returns xcb_input_get_feedback_control_cookie_t 2806 ** 2807 *****************************************************************************/ 2808 2809 xcb_input_get_feedback_control_cookie_t 2810 xcb_input_get_feedback_control (xcb_connection_t *c /**< */, 2811 uint8_t device_id /**< */) 2812 { 2813 static const xcb_protocol_request_t xcb_req = { 2814 /* count */ 2, 2815 /* ext */ &xcb_input_id, 2816 /* opcode */ XCB_INPUT_GET_FEEDBACK_CONTROL, 2817 /* isvoid */ 0 2818 }; 2819 2820 struct iovec xcb_parts[4]; 2821 xcb_input_get_feedback_control_cookie_t xcb_ret; 2822 xcb_input_get_feedback_control_request_t xcb_out; 2823 2824 xcb_out.device_id = device_id; 2825 memset(xcb_out.pad0, 0, 3); 2826 2827 xcb_parts[2].iov_base = (char *) &xcb_out; 2828 xcb_parts[2].iov_len = sizeof(xcb_out); 2829 xcb_parts[3].iov_base = 0; 2830 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2831 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2832 return xcb_ret; 2833 } 2834 2835 2836 /***************************************************************************** 2837 ** 2838 ** xcb_input_get_feedback_control_cookie_t xcb_input_get_feedback_control_unchecked 2839 ** 2840 ** @param xcb_connection_t *c 2841 ** @param uint8_t device_id 2842 ** @returns xcb_input_get_feedback_control_cookie_t 2843 ** 2844 *****************************************************************************/ 2845 2846 xcb_input_get_feedback_control_cookie_t 2847 xcb_input_get_feedback_control_unchecked (xcb_connection_t *c /**< */, 2848 uint8_t device_id /**< */) 2849 { 2850 static const xcb_protocol_request_t xcb_req = { 2851 /* count */ 2, 2852 /* ext */ &xcb_input_id, 2853 /* opcode */ XCB_INPUT_GET_FEEDBACK_CONTROL, 2854 /* isvoid */ 0 2855 }; 2856 2857 struct iovec xcb_parts[4]; 2858 xcb_input_get_feedback_control_cookie_t xcb_ret; 2859 xcb_input_get_feedback_control_request_t xcb_out; 2860 2861 xcb_out.device_id = device_id; 2862 memset(xcb_out.pad0, 0, 3); 2863 2864 xcb_parts[2].iov_base = (char *) &xcb_out; 2865 xcb_parts[2].iov_len = sizeof(xcb_out); 2866 xcb_parts[3].iov_base = 0; 2867 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2868 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2869 return xcb_ret; 2870 } 2871 2872 2873 /***************************************************************************** 2874 ** 2875 ** xcb_input_get_feedback_control_reply_t * xcb_input_get_feedback_control_reply 2876 ** 2877 ** @param xcb_connection_t *c 2878 ** @param xcb_input_get_feedback_control_cookie_t cookie 2879 ** @param xcb_generic_error_t **e 2880 ** @returns xcb_input_get_feedback_control_reply_t * 2881 ** 2882 *****************************************************************************/ 2883 2884 xcb_input_get_feedback_control_reply_t * 2885 xcb_input_get_feedback_control_reply (xcb_connection_t *c /**< */, 2886 xcb_input_get_feedback_control_cookie_t cookie /**< */, 2887 xcb_generic_error_t **e /**< */) 2888 { 2889 return (xcb_input_get_feedback_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2890 } 2891 2892 2893 /***************************************************************************** 2894 ** 2895 ** void xcb_input_feedback_state_next 2896 ** 2897 ** @param xcb_input_feedback_state_iterator_t *i 2898 ** @returns void 2899 ** 2900 *****************************************************************************/ 2901 2902 void 2903 xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i /**< */) 2904 { 2905 --i->rem; 2906 ++i->data; 2907 i->index += sizeof(xcb_input_feedback_state_t); 2908 } 2909 2910 2911 /***************************************************************************** 2912 ** 2913 ** xcb_generic_iterator_t xcb_input_feedback_state_end 2914 ** 2915 ** @param xcb_input_feedback_state_iterator_t i 2916 ** @returns xcb_generic_iterator_t 2917 ** 2918 *****************************************************************************/ 2919 2920 xcb_generic_iterator_t 2921 xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i /**< */) 2922 { 2923 xcb_generic_iterator_t ret; 2924 ret.data = i.data + i.rem; 2925 ret.index = i.index + ((char *) ret.data - (char *) i.data); 2926 ret.rem = 0; 2927 return ret; 2928 } 2929 2930 2931 /***************************************************************************** 2932 ** 2933 ** void xcb_input_kbd_feedback_state_next 2934 ** 2935 ** @param xcb_input_kbd_feedback_state_iterator_t *i 2936 ** @returns void 2937 ** 2938 *****************************************************************************/ 2939 2940 void 2941 xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i /**< */) 2942 { 2943 --i->rem; 2944 ++i->data; 2945 i->index += sizeof(xcb_input_kbd_feedback_state_t); 2946 } 2947 2948 2949 /***************************************************************************** 2950 ** 2951 ** xcb_generic_iterator_t xcb_input_kbd_feedback_state_end 2952 ** 2953 ** @param xcb_input_kbd_feedback_state_iterator_t i 2954 ** @returns xcb_generic_iterator_t 2955 ** 2956 *****************************************************************************/ 2957 2958 xcb_generic_iterator_t 2959 xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i /**< */) 2960 { 2961 xcb_generic_iterator_t ret; 2962 ret.data = i.data + i.rem; 2963 ret.index = i.index + ((char *) ret.data - (char *) i.data); 2964 ret.rem = 0; 2965 return ret; 2966 } 2967 2968 2969 /***************************************************************************** 2970 ** 2971 ** void xcb_input_ptr_feedback_state_next 2972 ** 2973 ** @param xcb_input_ptr_feedback_state_iterator_t *i 2974 ** @returns void 2975 ** 2976 *****************************************************************************/ 2977 2978 void 2979 xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i /**< */) 2980 { 2981 --i->rem; 2982 ++i->data; 2983 i->index += sizeof(xcb_input_ptr_feedback_state_t); 2984 } 2985 2986 2987 /***************************************************************************** 2988 ** 2989 ** xcb_generic_iterator_t xcb_input_ptr_feedback_state_end 2990 ** 2991 ** @param xcb_input_ptr_feedback_state_iterator_t i 2992 ** @returns xcb_generic_iterator_t 2993 ** 2994 *****************************************************************************/ 2995 2996 xcb_generic_iterator_t 2997 xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i /**< */) 2998 { 2999 xcb_generic_iterator_t ret; 3000 ret.data = i.data + i.rem; 3001 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3002 ret.rem = 0; 3003 return ret; 3004 } 3005 3006 3007 /***************************************************************************** 3008 ** 3009 ** void xcb_input_integer_feedback_state_next 3010 ** 3011 ** @param xcb_input_integer_feedback_state_iterator_t *i 3012 ** @returns void 3013 ** 3014 *****************************************************************************/ 3015 3016 void 3017 xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i /**< */) 3018 { 3019 --i->rem; 3020 ++i->data; 3021 i->index += sizeof(xcb_input_integer_feedback_state_t); 3022 } 3023 3024 3025 /***************************************************************************** 3026 ** 3027 ** xcb_generic_iterator_t xcb_input_integer_feedback_state_end 3028 ** 3029 ** @param xcb_input_integer_feedback_state_iterator_t i 3030 ** @returns xcb_generic_iterator_t 3031 ** 3032 *****************************************************************************/ 3033 3034 xcb_generic_iterator_t 3035 xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i /**< */) 3036 { 3037 xcb_generic_iterator_t ret; 3038 ret.data = i.data + i.rem; 3039 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3040 ret.rem = 0; 3041 return ret; 3042 } 3043 3044 3045 /***************************************************************************** 3046 ** 3047 ** xcb_keysym_t * xcb_input_string_feedback_state_keysyms 3048 ** 3049 ** @param const xcb_input_string_feedback_state_t *R 3050 ** @returns xcb_keysym_t * 3051 ** 3052 *****************************************************************************/ 3053 3054 xcb_keysym_t * 3055 xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R /**< */) 3056 { 3057 return (xcb_keysym_t *) (R + 1); 3058 } 3059 3060 3061 /***************************************************************************** 3062 ** 3063 ** int xcb_input_string_feedback_state_keysyms_length 3064 ** 3065 ** @param const xcb_input_string_feedback_state_t *R 3066 ** @returns int 3067 ** 3068 *****************************************************************************/ 3069 3070 int 3071 xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R /**< */) 3072 { 3073 return R->num_keysyms; 3074 } 3075 3076 3077 /***************************************************************************** 3078 ** 3079 ** xcb_generic_iterator_t xcb_input_string_feedback_state_keysyms_end 3080 ** 3081 ** @param const xcb_input_string_feedback_state_t *R 3082 ** @returns xcb_generic_iterator_t 3083 ** 3084 *****************************************************************************/ 3085 3086 xcb_generic_iterator_t 3087 xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R /**< */) 3088 { 3089 xcb_generic_iterator_t i; 3090 i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); 3091 i.rem = 0; 3092 i.index = (char *) i.data - (char *) R; 3093 return i; 3094 } 3095 3096 3097 /***************************************************************************** 3098 ** 3099 ** void xcb_input_string_feedback_state_next 3100 ** 3101 ** @param xcb_input_string_feedback_state_iterator_t *i 3102 ** @returns void 3103 ** 3104 *****************************************************************************/ 3105 3106 void 3107 xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i /**< */) 3108 { 3109 xcb_input_string_feedback_state_t *R = i->data; 3110 xcb_generic_iterator_t child = xcb_input_string_feedback_state_keysyms_end(R); 3111 --i->rem; 3112 i->data = (xcb_input_string_feedback_state_t *) child.data; 3113 i->index = child.index; 3114 } 3115 3116 3117 /***************************************************************************** 3118 ** 3119 ** xcb_generic_iterator_t xcb_input_string_feedback_state_end 3120 ** 3121 ** @param xcb_input_string_feedback_state_iterator_t i 3122 ** @returns xcb_generic_iterator_t 3123 ** 3124 *****************************************************************************/ 3125 3126 xcb_generic_iterator_t 3127 xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i /**< */) 3128 { 3129 xcb_generic_iterator_t ret; 3130 while(i.rem > 0) 3131 xcb_input_string_feedback_state_next(&i); 3132 ret.data = i.data; 3133 ret.rem = i.rem; 3134 ret.index = i.index; 3135 return ret; 3136 } 3137 3138 3139 /***************************************************************************** 3140 ** 3141 ** void xcb_input_bell_feedback_state_next 3142 ** 3143 ** @param xcb_input_bell_feedback_state_iterator_t *i 3144 ** @returns void 3145 ** 3146 *****************************************************************************/ 3147 3148 void 3149 xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i /**< */) 3150 { 3151 --i->rem; 3152 ++i->data; 3153 i->index += sizeof(xcb_input_bell_feedback_state_t); 3154 } 3155 3156 3157 /***************************************************************************** 3158 ** 3159 ** xcb_generic_iterator_t xcb_input_bell_feedback_state_end 3160 ** 3161 ** @param xcb_input_bell_feedback_state_iterator_t i 3162 ** @returns xcb_generic_iterator_t 3163 ** 3164 *****************************************************************************/ 3165 3166 xcb_generic_iterator_t 3167 xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i /**< */) 3168 { 3169 xcb_generic_iterator_t ret; 3170 ret.data = i.data + i.rem; 3171 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3172 ret.rem = 0; 3173 return ret; 3174 } 3175 3176 3177 /***************************************************************************** 3178 ** 3179 ** void xcb_input_led_feedback_state_next 3180 ** 3181 ** @param xcb_input_led_feedback_state_iterator_t *i 3182 ** @returns void 3183 ** 3184 *****************************************************************************/ 3185 3186 void 3187 xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i /**< */) 3188 { 3189 --i->rem; 3190 ++i->data; 3191 i->index += sizeof(xcb_input_led_feedback_state_t); 3192 } 3193 3194 3195 /***************************************************************************** 3196 ** 3197 ** xcb_generic_iterator_t xcb_input_led_feedback_state_end 3198 ** 3199 ** @param xcb_input_led_feedback_state_iterator_t i 3200 ** @returns xcb_generic_iterator_t 3201 ** 3202 *****************************************************************************/ 3203 3204 xcb_generic_iterator_t 3205 xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i /**< */) 3206 { 3207 xcb_generic_iterator_t ret; 3208 ret.data = i.data + i.rem; 3209 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3210 ret.rem = 0; 3211 return ret; 3212 } 3213 3214 3215 /***************************************************************************** 3216 ** 3217 ** void xcb_input_feedback_ctl_next 3218 ** 3219 ** @param xcb_input_feedback_ctl_iterator_t *i 3220 ** @returns void 3221 ** 3222 *****************************************************************************/ 3223 3224 void 3225 xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i /**< */) 3226 { 3227 --i->rem; 3228 ++i->data; 3229 i->index += sizeof(xcb_input_feedback_ctl_t); 3230 } 3231 3232 3233 /***************************************************************************** 3234 ** 3235 ** xcb_generic_iterator_t xcb_input_feedback_ctl_end 3236 ** 3237 ** @param xcb_input_feedback_ctl_iterator_t i 3238 ** @returns xcb_generic_iterator_t 3239 ** 3240 *****************************************************************************/ 3241 3242 xcb_generic_iterator_t 3243 xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i /**< */) 3244 { 3245 xcb_generic_iterator_t ret; 3246 ret.data = i.data + i.rem; 3247 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3248 ret.rem = 0; 3249 return ret; 3250 } 3251 3252 3253 /***************************************************************************** 3254 ** 3255 ** void xcb_input_kbd_feedback_ctl_next 3256 ** 3257 ** @param xcb_input_kbd_feedback_ctl_iterator_t *i 3258 ** @returns void 3259 ** 3260 *****************************************************************************/ 3261 3262 void 3263 xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i /**< */) 3264 { 3265 --i->rem; 3266 ++i->data; 3267 i->index += sizeof(xcb_input_kbd_feedback_ctl_t); 3268 } 3269 3270 3271 /***************************************************************************** 3272 ** 3273 ** xcb_generic_iterator_t xcb_input_kbd_feedback_ctl_end 3274 ** 3275 ** @param xcb_input_kbd_feedback_ctl_iterator_t i 3276 ** @returns xcb_generic_iterator_t 3277 ** 3278 *****************************************************************************/ 3279 3280 xcb_generic_iterator_t 3281 xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i /**< */) 3282 { 3283 xcb_generic_iterator_t ret; 3284 ret.data = i.data + i.rem; 3285 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3286 ret.rem = 0; 3287 return ret; 3288 } 3289 3290 3291 /***************************************************************************** 3292 ** 3293 ** void xcb_input_ptr_feedback_ctl_next 3294 ** 3295 ** @param xcb_input_ptr_feedback_ctl_iterator_t *i 3296 ** @returns void 3297 ** 3298 *****************************************************************************/ 3299 3300 void 3301 xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i /**< */) 3302 { 3303 --i->rem; 3304 ++i->data; 3305 i->index += sizeof(xcb_input_ptr_feedback_ctl_t); 3306 } 3307 3308 3309 /***************************************************************************** 3310 ** 3311 ** xcb_generic_iterator_t xcb_input_ptr_feedback_ctl_end 3312 ** 3313 ** @param xcb_input_ptr_feedback_ctl_iterator_t i 3314 ** @returns xcb_generic_iterator_t 3315 ** 3316 *****************************************************************************/ 3317 3318 xcb_generic_iterator_t 3319 xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i /**< */) 3320 { 3321 xcb_generic_iterator_t ret; 3322 ret.data = i.data + i.rem; 3323 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3324 ret.rem = 0; 3325 return ret; 3326 } 3327 3328 3329 /***************************************************************************** 3330 ** 3331 ** void xcb_input_integer_feedback_ctl_next 3332 ** 3333 ** @param xcb_input_integer_feedback_ctl_iterator_t *i 3334 ** @returns void 3335 ** 3336 *****************************************************************************/ 3337 3338 void 3339 xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i /**< */) 3340 { 3341 --i->rem; 3342 ++i->data; 3343 i->index += sizeof(xcb_input_integer_feedback_ctl_t); 3344 } 3345 3346 3347 /***************************************************************************** 3348 ** 3349 ** xcb_generic_iterator_t xcb_input_integer_feedback_ctl_end 3350 ** 3351 ** @param xcb_input_integer_feedback_ctl_iterator_t i 3352 ** @returns xcb_generic_iterator_t 3353 ** 3354 *****************************************************************************/ 3355 3356 xcb_generic_iterator_t 3357 xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i /**< */) 3358 { 3359 xcb_generic_iterator_t ret; 3360 ret.data = i.data + i.rem; 3361 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3362 ret.rem = 0; 3363 return ret; 3364 } 3365 3366 3367 /***************************************************************************** 3368 ** 3369 ** xcb_keysym_t * xcb_input_string_feedback_ctl_keysyms 3370 ** 3371 ** @param const xcb_input_string_feedback_ctl_t *R 3372 ** @returns xcb_keysym_t * 3373 ** 3374 *****************************************************************************/ 3375 3376 xcb_keysym_t * 3377 xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R /**< */) 3378 { 3379 return (xcb_keysym_t *) (R + 1); 3380 } 3381 3382 3383 /***************************************************************************** 3384 ** 3385 ** int xcb_input_string_feedback_ctl_keysyms_length 3386 ** 3387 ** @param const xcb_input_string_feedback_ctl_t *R 3388 ** @returns int 3389 ** 3390 *****************************************************************************/ 3391 3392 int 3393 xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R /**< */) 3394 { 3395 return R->num_keysyms; 3396 } 3397 3398 3399 /***************************************************************************** 3400 ** 3401 ** xcb_generic_iterator_t xcb_input_string_feedback_ctl_keysyms_end 3402 ** 3403 ** @param const xcb_input_string_feedback_ctl_t *R 3404 ** @returns xcb_generic_iterator_t 3405 ** 3406 *****************************************************************************/ 3407 3408 xcb_generic_iterator_t 3409 xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R /**< */) 3410 { 3411 xcb_generic_iterator_t i; 3412 i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); 3413 i.rem = 0; 3414 i.index = (char *) i.data - (char *) R; 3415 return i; 3416 } 3417 3418 3419 /***************************************************************************** 3420 ** 3421 ** void xcb_input_string_feedback_ctl_next 3422 ** 3423 ** @param xcb_input_string_feedback_ctl_iterator_t *i 3424 ** @returns void 3425 ** 3426 *****************************************************************************/ 3427 3428 void 3429 xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i /**< */) 3430 { 3431 xcb_input_string_feedback_ctl_t *R = i->data; 3432 xcb_generic_iterator_t child = xcb_input_string_feedback_ctl_keysyms_end(R); 3433 --i->rem; 3434 i->data = (xcb_input_string_feedback_ctl_t *) child.data; 3435 i->index = child.index; 3436 } 3437 3438 3439 /***************************************************************************** 3440 ** 3441 ** xcb_generic_iterator_t xcb_input_string_feedback_ctl_end 3442 ** 3443 ** @param xcb_input_string_feedback_ctl_iterator_t i 3444 ** @returns xcb_generic_iterator_t 3445 ** 3446 *****************************************************************************/ 3447 3448 xcb_generic_iterator_t 3449 xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i /**< */) 3450 { 3451 xcb_generic_iterator_t ret; 3452 while(i.rem > 0) 3453 xcb_input_string_feedback_ctl_next(&i); 3454 ret.data = i.data; 3455 ret.rem = i.rem; 3456 ret.index = i.index; 3457 return ret; 3458 } 3459 3460 3461 /***************************************************************************** 3462 ** 3463 ** void xcb_input_bell_feedback_ctl_next 3464 ** 3465 ** @param xcb_input_bell_feedback_ctl_iterator_t *i 3466 ** @returns void 3467 ** 3468 *****************************************************************************/ 3469 3470 void 3471 xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i /**< */) 3472 { 3473 --i->rem; 3474 ++i->data; 3475 i->index += sizeof(xcb_input_bell_feedback_ctl_t); 3476 } 3477 3478 3479 /***************************************************************************** 3480 ** 3481 ** xcb_generic_iterator_t xcb_input_bell_feedback_ctl_end 3482 ** 3483 ** @param xcb_input_bell_feedback_ctl_iterator_t i 3484 ** @returns xcb_generic_iterator_t 3485 ** 3486 *****************************************************************************/ 3487 3488 xcb_generic_iterator_t 3489 xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i /**< */) 3490 { 3491 xcb_generic_iterator_t ret; 3492 ret.data = i.data + i.rem; 3493 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3494 ret.rem = 0; 3495 return ret; 3496 } 3497 3498 3499 /***************************************************************************** 3500 ** 3501 ** void xcb_input_led_feedback_ctl_next 3502 ** 3503 ** @param xcb_input_led_feedback_ctl_iterator_t *i 3504 ** @returns void 3505 ** 3506 *****************************************************************************/ 3507 3508 void 3509 xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i /**< */) 3510 { 3511 --i->rem; 3512 ++i->data; 3513 i->index += sizeof(xcb_input_led_feedback_ctl_t); 3514 } 3515 3516 3517 /***************************************************************************** 3518 ** 3519 ** xcb_generic_iterator_t xcb_input_led_feedback_ctl_end 3520 ** 3521 ** @param xcb_input_led_feedback_ctl_iterator_t i 3522 ** @returns xcb_generic_iterator_t 3523 ** 3524 *****************************************************************************/ 3525 3526 xcb_generic_iterator_t 3527 xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i /**< */) 3528 { 3529 xcb_generic_iterator_t ret; 3530 ret.data = i.data + i.rem; 3531 ret.index = i.index + ((char *) ret.data - (char *) i.data); 3532 ret.rem = 0; 3533 return ret; 3534 } 3535 3536 3537 /***************************************************************************** 3538 ** 3539 ** xcb_input_get_device_key_mapping_cookie_t xcb_input_get_device_key_mapping 3540 ** 3541 ** @param xcb_connection_t *c 3542 ** @param uint8_t device_id 3543 ** @param xcb_input_key_code_t first_keycode 3544 ** @param uint8_t count 3545 ** @returns xcb_input_get_device_key_mapping_cookie_t 3546 ** 3547 *****************************************************************************/ 3548 3549 xcb_input_get_device_key_mapping_cookie_t 3550 xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, 3551 uint8_t device_id /**< */, 3552 xcb_input_key_code_t first_keycode /**< */, 3553 uint8_t count /**< */) 3554 { 3555 static const xcb_protocol_request_t xcb_req = { 3556 /* count */ 2, 3557 /* ext */ &xcb_input_id, 3558 /* opcode */ XCB_INPUT_GET_DEVICE_KEY_MAPPING, 3559 /* isvoid */ 0 3560 }; 3561 3562 struct iovec xcb_parts[4]; 3563 xcb_input_get_device_key_mapping_cookie_t xcb_ret; 3564 xcb_input_get_device_key_mapping_request_t xcb_out; 3565 3566 xcb_out.device_id = device_id; 3567 xcb_out.first_keycode = first_keycode; 3568 xcb_out.count = count; 3569 3570 xcb_parts[2].iov_base = (char *) &xcb_out; 3571 xcb_parts[2].iov_len = sizeof(xcb_out); 3572 xcb_parts[3].iov_base = 0; 3573 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3574 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3575 return xcb_ret; 3576 } 3577 3578 3579 /***************************************************************************** 3580 ** 3581 ** xcb_input_get_device_key_mapping_cookie_t xcb_input_get_device_key_mapping_unchecked 3582 ** 3583 ** @param xcb_connection_t *c 3584 ** @param uint8_t device_id 3585 ** @param xcb_input_key_code_t first_keycode 3586 ** @param uint8_t count 3587 ** @returns xcb_input_get_device_key_mapping_cookie_t 3588 ** 3589 *****************************************************************************/ 3590 3591 xcb_input_get_device_key_mapping_cookie_t 3592 xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c /**< */, 3593 uint8_t device_id /**< */, 3594 xcb_input_key_code_t first_keycode /**< */, 3595 uint8_t count /**< */) 3596 { 3597 static const xcb_protocol_request_t xcb_req = { 3598 /* count */ 2, 3599 /* ext */ &xcb_input_id, 3600 /* opcode */ XCB_INPUT_GET_DEVICE_KEY_MAPPING, 3601 /* isvoid */ 0 3602 }; 3603 3604 struct iovec xcb_parts[4]; 3605 xcb_input_get_device_key_mapping_cookie_t xcb_ret; 3606 xcb_input_get_device_key_mapping_request_t xcb_out; 3607 3608 xcb_out.device_id = device_id; 3609 xcb_out.first_keycode = first_keycode; 3610 xcb_out.count = count; 3611 3612 xcb_parts[2].iov_base = (char *) &xcb_out; 3613 xcb_parts[2].iov_len = sizeof(xcb_out); 3614 xcb_parts[3].iov_base = 0; 3615 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3616 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3617 return xcb_ret; 3618 } 3619 3620 3621 /***************************************************************************** 3622 ** 3623 ** xcb_keysym_t * xcb_input_get_device_key_mapping_keysyms 3624 ** 3625 ** @param const xcb_input_get_device_key_mapping_reply_t *R 3626 ** @returns xcb_keysym_t * 3627 ** 3628 *****************************************************************************/ 3629 3630 xcb_keysym_t * 3631 xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R /**< */) 3632 { 3633 return (xcb_keysym_t *) (R + 1); 3634 } 3635 3636 3637 /***************************************************************************** 3638 ** 3639 ** int xcb_input_get_device_key_mapping_keysyms_length 3640 ** 3641 ** @param const xcb_input_get_device_key_mapping_reply_t *R 3642 ** @returns int 3643 ** 3644 *****************************************************************************/ 3645 3646 int 3647 xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R /**< */) 3648 { 3649 return R->length; 3650 } 3651 3652 3653 /***************************************************************************** 3654 ** 3655 ** xcb_generic_iterator_t xcb_input_get_device_key_mapping_keysyms_end 3656 ** 3657 ** @param const xcb_input_get_device_key_mapping_reply_t *R 3658 ** @returns xcb_generic_iterator_t 3659 ** 3660 *****************************************************************************/ 3661 3662 xcb_generic_iterator_t 3663 xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R /**< */) 3664 { 3665 xcb_generic_iterator_t i; 3666 i.data = ((xcb_keysym_t *) (R + 1)) + (R->length); 3667 i.rem = 0; 3668 i.index = (char *) i.data - (char *) R; 3669 return i; 3670 } 3671 3672 3673 /***************************************************************************** 3674 ** 3675 ** xcb_input_get_device_key_mapping_reply_t * xcb_input_get_device_key_mapping_reply 3676 ** 3677 ** @param xcb_connection_t *c 3678 ** @param xcb_input_get_device_key_mapping_cookie_t cookie 3679 ** @param xcb_generic_error_t **e 3680 ** @returns xcb_input_get_device_key_mapping_reply_t * 3681 ** 3682 *****************************************************************************/ 3683 3684 xcb_input_get_device_key_mapping_reply_t * 3685 xcb_input_get_device_key_mapping_reply (xcb_connection_t *c /**< */, 3686 xcb_input_get_device_key_mapping_cookie_t cookie /**< */, 3687 xcb_generic_error_t **e /**< */) 3688 { 3689 return (xcb_input_get_device_key_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3690 } 3691 3692 3693 /***************************************************************************** 3694 ** 3695 ** xcb_void_cookie_t xcb_input_change_device_key_mapping_checked 3696 ** 3697 ** @param xcb_connection_t *c 3698 ** @param uint8_t device_id 3699 ** @param xcb_input_key_code_t first_keycode 3700 ** @param uint8_t keysyms_per_keycode 3701 ** @param uint8_t keycode_count 3702 ** @param const xcb_keysym_t *keysyms 3703 ** @returns xcb_void_cookie_t 3704 ** 3705 *****************************************************************************/ 3706 3707 xcb_void_cookie_t 3708 xcb_input_change_device_key_mapping_checked (xcb_connection_t *c /**< */, 3709 uint8_t device_id /**< */, 3710 xcb_input_key_code_t first_keycode /**< */, 3711 uint8_t keysyms_per_keycode /**< */, 3712 uint8_t keycode_count /**< */, 3713 const xcb_keysym_t *keysyms /**< */) 3714 { 3715 static const xcb_protocol_request_t xcb_req = { 3716 /* count */ 4, 3717 /* ext */ &xcb_input_id, 3718 /* opcode */ XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, 3719 /* isvoid */ 1 3720 }; 3721 3722 struct iovec xcb_parts[6]; 3723 xcb_void_cookie_t xcb_ret; 3724 xcb_input_change_device_key_mapping_request_t xcb_out; 3725 3726 xcb_out.device_id = device_id; 3727 xcb_out.first_keycode = first_keycode; 3728 xcb_out.keysyms_per_keycode = keysyms_per_keycode; 3729 xcb_out.keycode_count = keycode_count; 3730 3731 xcb_parts[2].iov_base = (char *) &xcb_out; 3732 xcb_parts[2].iov_len = sizeof(xcb_out); 3733 xcb_parts[3].iov_base = 0; 3734 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3735 xcb_parts[4].iov_base = (char *) keysyms; 3736 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); 3737 xcb_parts[5].iov_base = 0; 3738 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3739 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3740 return xcb_ret; 3741 } 3742 3743 3744 /***************************************************************************** 3745 ** 3746 ** xcb_void_cookie_t xcb_input_change_device_key_mapping 3747 ** 3748 ** @param xcb_connection_t *c 3749 ** @param uint8_t device_id 3750 ** @param xcb_input_key_code_t first_keycode 3751 ** @param uint8_t keysyms_per_keycode 3752 ** @param uint8_t keycode_count 3753 ** @param const xcb_keysym_t *keysyms 3754 ** @returns xcb_void_cookie_t 3755 ** 3756 *****************************************************************************/ 3757 3758 xcb_void_cookie_t 3759 xcb_input_change_device_key_mapping (xcb_connection_t *c /**< */, 3760 uint8_t device_id /**< */, 3761 xcb_input_key_code_t first_keycode /**< */, 3762 uint8_t keysyms_per_keycode /**< */, 3763 uint8_t keycode_count /**< */, 3764 const xcb_keysym_t *keysyms /**< */) 3765 { 3766 static const xcb_protocol_request_t xcb_req = { 3767 /* count */ 4, 3768 /* ext */ &xcb_input_id, 3769 /* opcode */ XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, 3770 /* isvoid */ 1 3771 }; 3772 3773 struct iovec xcb_parts[6]; 3774 xcb_void_cookie_t xcb_ret; 3775 xcb_input_change_device_key_mapping_request_t xcb_out; 3776 3777 xcb_out.device_id = device_id; 3778 xcb_out.first_keycode = first_keycode; 3779 xcb_out.keysyms_per_keycode = keysyms_per_keycode; 3780 xcb_out.keycode_count = keycode_count; 3781 3782 xcb_parts[2].iov_base = (char *) &xcb_out; 3783 xcb_parts[2].iov_len = sizeof(xcb_out); 3784 xcb_parts[3].iov_base = 0; 3785 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3786 xcb_parts[4].iov_base = (char *) keysyms; 3787 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); 3788 xcb_parts[5].iov_base = 0; 3789 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3790 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3791 return xcb_ret; 3792 } 3793 3794 3795 /***************************************************************************** 3796 ** 3797 ** xcb_input_get_device_modifier_mapping_cookie_t xcb_input_get_device_modifier_mapping 3798 ** 3799 ** @param xcb_connection_t *c 3800 ** @param uint8_t device_id 3801 ** @returns xcb_input_get_device_modifier_mapping_cookie_t 3802 ** 3803 *****************************************************************************/ 3804 3805 xcb_input_get_device_modifier_mapping_cookie_t 3806 xcb_input_get_device_modifier_mapping (xcb_connection_t *c /**< */, 3807 uint8_t device_id /**< */) 3808 { 3809 static const xcb_protocol_request_t xcb_req = { 3810 /* count */ 2, 3811 /* ext */ &xcb_input_id, 3812 /* opcode */ XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, 3813 /* isvoid */ 0 3814 }; 3815 3816 struct iovec xcb_parts[4]; 3817 xcb_input_get_device_modifier_mapping_cookie_t xcb_ret; 3818 xcb_input_get_device_modifier_mapping_request_t xcb_out; 3819 3820 xcb_out.device_id = device_id; 3821 memset(xcb_out.pad0, 0, 3); 3822 3823 xcb_parts[2].iov_base = (char *) &xcb_out; 3824 xcb_parts[2].iov_len = sizeof(xcb_out); 3825 xcb_parts[3].iov_base = 0; 3826 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3827 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3828 return xcb_ret; 3829 } 3830 3831 3832 /***************************************************************************** 3833 ** 3834 ** xcb_input_get_device_modifier_mapping_cookie_t xcb_input_get_device_modifier_mapping_unchecked 3835 ** 3836 ** @param xcb_connection_t *c 3837 ** @param uint8_t device_id 3838 ** @returns xcb_input_get_device_modifier_mapping_cookie_t 3839 ** 3840 *****************************************************************************/ 3841 3842 xcb_input_get_device_modifier_mapping_cookie_t 3843 xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, 3844 uint8_t device_id /**< */) 3845 { 3846 static const xcb_protocol_request_t xcb_req = { 3847 /* count */ 2, 3848 /* ext */ &xcb_input_id, 3849 /* opcode */ XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, 3850 /* isvoid */ 0 3851 }; 3852 3853 struct iovec xcb_parts[4]; 3854 xcb_input_get_device_modifier_mapping_cookie_t xcb_ret; 3855 xcb_input_get_device_modifier_mapping_request_t xcb_out; 3856 3857 xcb_out.device_id = device_id; 3858 memset(xcb_out.pad0, 0, 3); 3859 3860 xcb_parts[2].iov_base = (char *) &xcb_out; 3861 xcb_parts[2].iov_len = sizeof(xcb_out); 3862 xcb_parts[3].iov_base = 0; 3863 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3864 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3865 return xcb_ret; 3866 } 3867 3868 3869 /***************************************************************************** 3870 ** 3871 ** uint8_t * xcb_input_get_device_modifier_mapping_keymaps 3872 ** 3873 ** @param const xcb_input_get_device_modifier_mapping_reply_t *R 3874 ** @returns uint8_t * 3875 ** 3876 *****************************************************************************/ 3877 3878 uint8_t * 3879 xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) 3880 { 3881 return (uint8_t *) (R + 1); 3882 } 3883 3884 3885 /***************************************************************************** 3886 ** 3887 ** int xcb_input_get_device_modifier_mapping_keymaps_length 3888 ** 3889 ** @param const xcb_input_get_device_modifier_mapping_reply_t *R 3890 ** @returns int 3891 ** 3892 *****************************************************************************/ 3893 3894 int 3895 xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) 3896 { 3897 return (R->keycodes_per_modifier * 8); 3898 } 3899 3900 3901 /***************************************************************************** 3902 ** 3903 ** xcb_generic_iterator_t xcb_input_get_device_modifier_mapping_keymaps_end 3904 ** 3905 ** @param const xcb_input_get_device_modifier_mapping_reply_t *R 3906 ** @returns xcb_generic_iterator_t 3907 ** 3908 *****************************************************************************/ 3909 3910 xcb_generic_iterator_t 3911 xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) 3912 { 3913 xcb_generic_iterator_t i; 3914 i.data = ((uint8_t *) (R + 1)) + ((R->keycodes_per_modifier * 8)); 3915 i.rem = 0; 3916 i.index = (char *) i.data - (char *) R; 3917 return i; 3918 } 3919 3920 3921 /***************************************************************************** 3922 ** 3923 ** xcb_input_get_device_modifier_mapping_reply_t * xcb_input_get_device_modifier_mapping_reply 3924 ** 3925 ** @param xcb_connection_t *c 3926 ** @param xcb_input_get_device_modifier_mapping_cookie_t cookie 3927 ** @param xcb_generic_error_t **e 3928 ** @returns xcb_input_get_device_modifier_mapping_reply_t * 3929 ** 3930 *****************************************************************************/ 3931 3932 xcb_input_get_device_modifier_mapping_reply_t * 3933 xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c /**< */, 3934 xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */, 3935 xcb_generic_error_t **e /**< */) 3936 { 3937 return (xcb_input_get_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3938 } 3939 3940 3941 /***************************************************************************** 3942 ** 3943 ** xcb_input_set_device_modifier_mapping_cookie_t xcb_input_set_device_modifier_mapping 3944 ** 3945 ** @param xcb_connection_t *c 3946 ** @param uint8_t device_id 3947 ** @param uint8_t keycodes_per_modifier 3948 ** @param const uint8_t *keymaps 3949 ** @returns xcb_input_set_device_modifier_mapping_cookie_t 3950 ** 3951 *****************************************************************************/ 3952 3953 xcb_input_set_device_modifier_mapping_cookie_t 3954 xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, 3955 uint8_t device_id /**< */, 3956 uint8_t keycodes_per_modifier /**< */, 3957 const uint8_t *keymaps /**< */) 3958 { 3959 static const xcb_protocol_request_t xcb_req = { 3960 /* count */ 4, 3961 /* ext */ &xcb_input_id, 3962 /* opcode */ XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, 3963 /* isvoid */ 0 3964 }; 3965 3966 struct iovec xcb_parts[6]; 3967 xcb_input_set_device_modifier_mapping_cookie_t xcb_ret; 3968 xcb_input_set_device_modifier_mapping_request_t xcb_out; 3969 3970 xcb_out.device_id = device_id; 3971 xcb_out.keycodes_per_modifier = keycodes_per_modifier; 3972 xcb_out.pad0 = 0; 3973 3974 xcb_parts[2].iov_base = (char *) &xcb_out; 3975 xcb_parts[2].iov_len = sizeof(xcb_out); 3976 xcb_parts[3].iov_base = 0; 3977 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3978 xcb_parts[4].iov_base = (char *) keymaps; 3979 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); 3980 xcb_parts[5].iov_base = 0; 3981 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3982 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3983 return xcb_ret; 3984 } 3985 3986 3987 /***************************************************************************** 3988 ** 3989 ** xcb_input_set_device_modifier_mapping_cookie_t xcb_input_set_device_modifier_mapping_unchecked 3990 ** 3991 ** @param xcb_connection_t *c 3992 ** @param uint8_t device_id 3993 ** @param uint8_t keycodes_per_modifier 3994 ** @param const uint8_t *keymaps 3995 ** @returns xcb_input_set_device_modifier_mapping_cookie_t 3996 ** 3997 *****************************************************************************/ 3998 3999 xcb_input_set_device_modifier_mapping_cookie_t 4000 xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, 4001 uint8_t device_id /**< */, 4002 uint8_t keycodes_per_modifier /**< */, 4003 const uint8_t *keymaps /**< */) 4004 { 4005 static const xcb_protocol_request_t xcb_req = { 4006 /* count */ 4, 4007 /* ext */ &xcb_input_id, 4008 /* opcode */ XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, 4009 /* isvoid */ 0 4010 }; 4011 4012 struct iovec xcb_parts[6]; 4013 xcb_input_set_device_modifier_mapping_cookie_t xcb_ret; 4014 xcb_input_set_device_modifier_mapping_request_t xcb_out; 4015 4016 xcb_out.device_id = device_id; 4017 xcb_out.keycodes_per_modifier = keycodes_per_modifier; 4018 xcb_out.pad0 = 0; 4019 4020 xcb_parts[2].iov_base = (char *) &xcb_out; 4021 xcb_parts[2].iov_len = sizeof(xcb_out); 4022 xcb_parts[3].iov_base = 0; 4023 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4024 xcb_parts[4].iov_base = (char *) keymaps; 4025 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); 4026 xcb_parts[5].iov_base = 0; 4027 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4028 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4029 return xcb_ret; 4030 } 4031 4032 4033 /***************************************************************************** 4034 ** 4035 ** xcb_input_set_device_modifier_mapping_reply_t * xcb_input_set_device_modifier_mapping_reply 4036 ** 4037 ** @param xcb_connection_t *c 4038 ** @param xcb_input_set_device_modifier_mapping_cookie_t cookie 4039 ** @param xcb_generic_error_t **e 4040 ** @returns xcb_input_set_device_modifier_mapping_reply_t * 4041 ** 4042 *****************************************************************************/ 4043 4044 xcb_input_set_device_modifier_mapping_reply_t * 4045 xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c /**< */, 4046 xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */, 4047 xcb_generic_error_t **e /**< */) 4048 { 4049 return (xcb_input_set_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4050 } 4051 4052 4053 /***************************************************************************** 4054 ** 4055 ** xcb_input_get_device_button_mapping_cookie_t xcb_input_get_device_button_mapping 4056 ** 4057 ** @param xcb_connection_t *c 4058 ** @param uint8_t device_id 4059 ** @returns xcb_input_get_device_button_mapping_cookie_t 4060 ** 4061 *****************************************************************************/ 4062 4063 xcb_input_get_device_button_mapping_cookie_t 4064 xcb_input_get_device_button_mapping (xcb_connection_t *c /**< */, 4065 uint8_t device_id /**< */) 4066 { 4067 static const xcb_protocol_request_t xcb_req = { 4068 /* count */ 2, 4069 /* ext */ &xcb_input_id, 4070 /* opcode */ XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, 4071 /* isvoid */ 0 4072 }; 4073 4074 struct iovec xcb_parts[4]; 4075 xcb_input_get_device_button_mapping_cookie_t xcb_ret; 4076 xcb_input_get_device_button_mapping_request_t xcb_out; 4077 4078 xcb_out.device_id = device_id; 4079 memset(xcb_out.pad0, 0, 3); 4080 4081 xcb_parts[2].iov_base = (char *) &xcb_out; 4082 xcb_parts[2].iov_len = sizeof(xcb_out); 4083 xcb_parts[3].iov_base = 0; 4084 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4085 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4086 return xcb_ret; 4087 } 4088 4089 4090 /***************************************************************************** 4091 ** 4092 ** xcb_input_get_device_button_mapping_cookie_t xcb_input_get_device_button_mapping_unchecked 4093 ** 4094 ** @param xcb_connection_t *c 4095 ** @param uint8_t device_id 4096 ** @returns xcb_input_get_device_button_mapping_cookie_t 4097 ** 4098 *****************************************************************************/ 4099 4100 xcb_input_get_device_button_mapping_cookie_t 4101 xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c /**< */, 4102 uint8_t device_id /**< */) 4103 { 4104 static const xcb_protocol_request_t xcb_req = { 4105 /* count */ 2, 4106 /* ext */ &xcb_input_id, 4107 /* opcode */ XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, 4108 /* isvoid */ 0 4109 }; 4110 4111 struct iovec xcb_parts[4]; 4112 xcb_input_get_device_button_mapping_cookie_t xcb_ret; 4113 xcb_input_get_device_button_mapping_request_t xcb_out; 4114 4115 xcb_out.device_id = device_id; 4116 memset(xcb_out.pad0, 0, 3); 4117 4118 xcb_parts[2].iov_base = (char *) &xcb_out; 4119 xcb_parts[2].iov_len = sizeof(xcb_out); 4120 xcb_parts[3].iov_base = 0; 4121 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4122 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4123 return xcb_ret; 4124 } 4125 4126 4127 /***************************************************************************** 4128 ** 4129 ** uint8_t * xcb_input_get_device_button_mapping_map 4130 ** 4131 ** @param const xcb_input_get_device_button_mapping_reply_t *R 4132 ** @returns uint8_t * 4133 ** 4134 *****************************************************************************/ 4135 4136 uint8_t * 4137 xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R /**< */) 4138 { 4139 return (uint8_t *) (R + 1); 4140 } 4141 4142 4143 /***************************************************************************** 4144 ** 4145 ** int xcb_input_get_device_button_mapping_map_length 4146 ** 4147 ** @param const xcb_input_get_device_button_mapping_reply_t *R 4148 ** @returns int 4149 ** 4150 *****************************************************************************/ 4151 4152 int 4153 xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R /**< */) 4154 { 4155 return R->map_size; 4156 } 4157 4158 4159 /***************************************************************************** 4160 ** 4161 ** xcb_generic_iterator_t xcb_input_get_device_button_mapping_map_end 4162 ** 4163 ** @param const xcb_input_get_device_button_mapping_reply_t *R 4164 ** @returns xcb_generic_iterator_t 4165 ** 4166 *****************************************************************************/ 4167 4168 xcb_generic_iterator_t 4169 xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R /**< */) 4170 { 4171 xcb_generic_iterator_t i; 4172 i.data = ((uint8_t *) (R + 1)) + (R->map_size); 4173 i.rem = 0; 4174 i.index = (char *) i.data - (char *) R; 4175 return i; 4176 } 4177 4178 4179 /***************************************************************************** 4180 ** 4181 ** xcb_input_get_device_button_mapping_reply_t * xcb_input_get_device_button_mapping_reply 4182 ** 4183 ** @param xcb_connection_t *c 4184 ** @param xcb_input_get_device_button_mapping_cookie_t cookie 4185 ** @param xcb_generic_error_t **e 4186 ** @returns xcb_input_get_device_button_mapping_reply_t * 4187 ** 4188 *****************************************************************************/ 4189 4190 xcb_input_get_device_button_mapping_reply_t * 4191 xcb_input_get_device_button_mapping_reply (xcb_connection_t *c /**< */, 4192 xcb_input_get_device_button_mapping_cookie_t cookie /**< */, 4193 xcb_generic_error_t **e /**< */) 4194 { 4195 return (xcb_input_get_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4196 } 4197 4198 4199 /***************************************************************************** 4200 ** 4201 ** xcb_input_set_device_button_mapping_cookie_t xcb_input_set_device_button_mapping 4202 ** 4203 ** @param xcb_connection_t *c 4204 ** @param uint8_t device_id 4205 ** @param uint8_t map_size 4206 ** @param const uint8_t *map 4207 ** @returns xcb_input_set_device_button_mapping_cookie_t 4208 ** 4209 *****************************************************************************/ 4210 4211 xcb_input_set_device_button_mapping_cookie_t 4212 xcb_input_set_device_button_mapping (xcb_connection_t *c /**< */, 4213 uint8_t device_id /**< */, 4214 uint8_t map_size /**< */, 4215 const uint8_t *map /**< */) 4216 { 4217 static const xcb_protocol_request_t xcb_req = { 4218 /* count */ 4, 4219 /* ext */ &xcb_input_id, 4220 /* opcode */ XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, 4221 /* isvoid */ 0 4222 }; 4223 4224 struct iovec xcb_parts[6]; 4225 xcb_input_set_device_button_mapping_cookie_t xcb_ret; 4226 xcb_input_set_device_button_mapping_request_t xcb_out; 4227 4228 xcb_out.device_id = device_id; 4229 xcb_out.map_size = map_size; 4230 memset(xcb_out.pad0, 0, 2); 4231 4232 xcb_parts[2].iov_base = (char *) &xcb_out; 4233 xcb_parts[2].iov_len = sizeof(xcb_out); 4234 xcb_parts[3].iov_base = 0; 4235 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4236 xcb_parts[4].iov_base = (char *) map; 4237 xcb_parts[4].iov_len = map_size * sizeof(uint8_t); 4238 xcb_parts[5].iov_base = 0; 4239 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4240 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4241 return xcb_ret; 4242 } 4243 4244 4245 /***************************************************************************** 4246 ** 4247 ** xcb_input_set_device_button_mapping_cookie_t xcb_input_set_device_button_mapping_unchecked 4248 ** 4249 ** @param xcb_connection_t *c 4250 ** @param uint8_t device_id 4251 ** @param uint8_t map_size 4252 ** @param const uint8_t *map 4253 ** @returns xcb_input_set_device_button_mapping_cookie_t 4254 ** 4255 *****************************************************************************/ 4256 4257 xcb_input_set_device_button_mapping_cookie_t 4258 xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c /**< */, 4259 uint8_t device_id /**< */, 4260 uint8_t map_size /**< */, 4261 const uint8_t *map /**< */) 4262 { 4263 static const xcb_protocol_request_t xcb_req = { 4264 /* count */ 4, 4265 /* ext */ &xcb_input_id, 4266 /* opcode */ XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, 4267 /* isvoid */ 0 4268 }; 4269 4270 struct iovec xcb_parts[6]; 4271 xcb_input_set_device_button_mapping_cookie_t xcb_ret; 4272 xcb_input_set_device_button_mapping_request_t xcb_out; 4273 4274 xcb_out.device_id = device_id; 4275 xcb_out.map_size = map_size; 4276 memset(xcb_out.pad0, 0, 2); 4277 4278 xcb_parts[2].iov_base = (char *) &xcb_out; 4279 xcb_parts[2].iov_len = sizeof(xcb_out); 4280 xcb_parts[3].iov_base = 0; 4281 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4282 xcb_parts[4].iov_base = (char *) map; 4283 xcb_parts[4].iov_len = map_size * sizeof(uint8_t); 4284 xcb_parts[5].iov_base = 0; 4285 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4286 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4287 return xcb_ret; 4288 } 4289 4290 4291 /***************************************************************************** 4292 ** 4293 ** xcb_input_set_device_button_mapping_reply_t * xcb_input_set_device_button_mapping_reply 4294 ** 4295 ** @param xcb_connection_t *c 4296 ** @param xcb_input_set_device_button_mapping_cookie_t cookie 4297 ** @param xcb_generic_error_t **e 4298 ** @returns xcb_input_set_device_button_mapping_reply_t * 4299 ** 4300 *****************************************************************************/ 4301 4302 xcb_input_set_device_button_mapping_reply_t * 4303 xcb_input_set_device_button_mapping_reply (xcb_connection_t *c /**< */, 4304 xcb_input_set_device_button_mapping_cookie_t cookie /**< */, 4305 xcb_generic_error_t **e /**< */) 4306 { 4307 return (xcb_input_set_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4308 } 4309 4310 4311 /***************************************************************************** 4312 ** 4313 ** xcb_input_query_device_state_cookie_t xcb_input_query_device_state 4314 ** 4315 ** @param xcb_connection_t *c 4316 ** @param uint8_t device_id 4317 ** @returns xcb_input_query_device_state_cookie_t 4318 ** 4319 *****************************************************************************/ 4320 4321 xcb_input_query_device_state_cookie_t 4322 xcb_input_query_device_state (xcb_connection_t *c /**< */, 4323 uint8_t device_id /**< */) 4324 { 4325 static const xcb_protocol_request_t xcb_req = { 4326 /* count */ 2, 4327 /* ext */ &xcb_input_id, 4328 /* opcode */ XCB_INPUT_QUERY_DEVICE_STATE, 4329 /* isvoid */ 0 4330 }; 4331 4332 struct iovec xcb_parts[4]; 4333 xcb_input_query_device_state_cookie_t xcb_ret; 4334 xcb_input_query_device_state_request_t xcb_out; 4335 4336 xcb_out.device_id = device_id; 4337 memset(xcb_out.pad0, 0, 3); 4338 4339 xcb_parts[2].iov_base = (char *) &xcb_out; 4340 xcb_parts[2].iov_len = sizeof(xcb_out); 4341 xcb_parts[3].iov_base = 0; 4342 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4343 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4344 return xcb_ret; 4345 } 4346 4347 4348 /***************************************************************************** 4349 ** 4350 ** xcb_input_query_device_state_cookie_t xcb_input_query_device_state_unchecked 4351 ** 4352 ** @param xcb_connection_t *c 4353 ** @param uint8_t device_id 4354 ** @returns xcb_input_query_device_state_cookie_t 4355 ** 4356 *****************************************************************************/ 4357 4358 xcb_input_query_device_state_cookie_t 4359 xcb_input_query_device_state_unchecked (xcb_connection_t *c /**< */, 4360 uint8_t device_id /**< */) 4361 { 4362 static const xcb_protocol_request_t xcb_req = { 4363 /* count */ 2, 4364 /* ext */ &xcb_input_id, 4365 /* opcode */ XCB_INPUT_QUERY_DEVICE_STATE, 4366 /* isvoid */ 0 4367 }; 4368 4369 struct iovec xcb_parts[4]; 4370 xcb_input_query_device_state_cookie_t xcb_ret; 4371 xcb_input_query_device_state_request_t xcb_out; 4372 4373 xcb_out.device_id = device_id; 4374 memset(xcb_out.pad0, 0, 3); 4375 4376 xcb_parts[2].iov_base = (char *) &xcb_out; 4377 xcb_parts[2].iov_len = sizeof(xcb_out); 4378 xcb_parts[3].iov_base = 0; 4379 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4380 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4381 return xcb_ret; 4382 } 4383 4384 4385 /***************************************************************************** 4386 ** 4387 ** xcb_input_query_device_state_reply_t * xcb_input_query_device_state_reply 4388 ** 4389 ** @param xcb_connection_t *c 4390 ** @param xcb_input_query_device_state_cookie_t cookie 4391 ** @param xcb_generic_error_t **e 4392 ** @returns xcb_input_query_device_state_reply_t * 4393 ** 4394 *****************************************************************************/ 4395 4396 xcb_input_query_device_state_reply_t * 4397 xcb_input_query_device_state_reply (xcb_connection_t *c /**< */, 4398 xcb_input_query_device_state_cookie_t cookie /**< */, 4399 xcb_generic_error_t **e /**< */) 4400 { 4401 return (xcb_input_query_device_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4402 } 4403 4404 4405 /***************************************************************************** 4406 ** 4407 ** void xcb_input_input_state_next 4408 ** 4409 ** @param xcb_input_input_state_iterator_t *i 4410 ** @returns void 4411 ** 4412 *****************************************************************************/ 4413 4414 void 4415 xcb_input_input_state_next (xcb_input_input_state_iterator_t *i /**< */) 4416 { 4417 --i->rem; 4418 ++i->data; 4419 i->index += sizeof(xcb_input_input_state_t); 4420 } 4421 4422 4423 /***************************************************************************** 4424 ** 4425 ** xcb_generic_iterator_t xcb_input_input_state_end 4426 ** 4427 ** @param xcb_input_input_state_iterator_t i 4428 ** @returns xcb_generic_iterator_t 4429 ** 4430 *****************************************************************************/ 4431 4432 xcb_generic_iterator_t 4433 xcb_input_input_state_end (xcb_input_input_state_iterator_t i /**< */) 4434 { 4435 xcb_generic_iterator_t ret; 4436 ret.data = i.data + i.rem; 4437 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4438 ret.rem = 0; 4439 return ret; 4440 } 4441 4442 4443 /***************************************************************************** 4444 ** 4445 ** void xcb_input_key_state_next 4446 ** 4447 ** @param xcb_input_key_state_iterator_t *i 4448 ** @returns void 4449 ** 4450 *****************************************************************************/ 4451 4452 void 4453 xcb_input_key_state_next (xcb_input_key_state_iterator_t *i /**< */) 4454 { 4455 --i->rem; 4456 ++i->data; 4457 i->index += sizeof(xcb_input_key_state_t); 4458 } 4459 4460 4461 /***************************************************************************** 4462 ** 4463 ** xcb_generic_iterator_t xcb_input_key_state_end 4464 ** 4465 ** @param xcb_input_key_state_iterator_t i 4466 ** @returns xcb_generic_iterator_t 4467 ** 4468 *****************************************************************************/ 4469 4470 xcb_generic_iterator_t 4471 xcb_input_key_state_end (xcb_input_key_state_iterator_t i /**< */) 4472 { 4473 xcb_generic_iterator_t ret; 4474 ret.data = i.data + i.rem; 4475 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4476 ret.rem = 0; 4477 return ret; 4478 } 4479 4480 4481 /***************************************************************************** 4482 ** 4483 ** void xcb_input_button_state_next 4484 ** 4485 ** @param xcb_input_button_state_iterator_t *i 4486 ** @returns void 4487 ** 4488 *****************************************************************************/ 4489 4490 void 4491 xcb_input_button_state_next (xcb_input_button_state_iterator_t *i /**< */) 4492 { 4493 --i->rem; 4494 ++i->data; 4495 i->index += sizeof(xcb_input_button_state_t); 4496 } 4497 4498 4499 /***************************************************************************** 4500 ** 4501 ** xcb_generic_iterator_t xcb_input_button_state_end 4502 ** 4503 ** @param xcb_input_button_state_iterator_t i 4504 ** @returns xcb_generic_iterator_t 4505 ** 4506 *****************************************************************************/ 4507 4508 xcb_generic_iterator_t 4509 xcb_input_button_state_end (xcb_input_button_state_iterator_t i /**< */) 4510 { 4511 xcb_generic_iterator_t ret; 4512 ret.data = i.data + i.rem; 4513 ret.index = i.index + ((char *) ret.data - (char *) i.data); 4514 ret.rem = 0; 4515 return ret; 4516 } 4517 4518 4519 /***************************************************************************** 4520 ** 4521 ** uint32_t * xcb_input_valuator_state_valuators 4522 ** 4523 ** @param const xcb_input_valuator_state_t *R 4524 ** @returns uint32_t * 4525 ** 4526 *****************************************************************************/ 4527 4528 uint32_t * 4529 xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R /**< */) 4530 { 4531 return (uint32_t *) (R + 1); 4532 } 4533 4534 4535 /***************************************************************************** 4536 ** 4537 ** int xcb_input_valuator_state_valuators_length 4538 ** 4539 ** @param const xcb_input_valuator_state_t *R 4540 ** @returns int 4541 ** 4542 *****************************************************************************/ 4543 4544 int 4545 xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R /**< */) 4546 { 4547 return R->num_valuators; 4548 } 4549 4550 4551 /***************************************************************************** 4552 ** 4553 ** xcb_generic_iterator_t xcb_input_valuator_state_valuators_end 4554 ** 4555 ** @param const xcb_input_valuator_state_t *R 4556 ** @returns xcb_generic_iterator_t 4557 ** 4558 *****************************************************************************/ 4559 4560 xcb_generic_iterator_t 4561 xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R /**< */) 4562 { 4563 xcb_generic_iterator_t i; 4564 i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); 4565 i.rem = 0; 4566 i.index = (char *) i.data - (char *) R; 4567 return i; 4568 } 4569 4570 4571 /***************************************************************************** 4572 ** 4573 ** void xcb_input_valuator_state_next 4574 ** 4575 ** @param xcb_input_valuator_state_iterator_t *i 4576 ** @returns void 4577 ** 4578 *****************************************************************************/ 4579 4580 void 4581 xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i /**< */) 4582 { 4583 xcb_input_valuator_state_t *R = i->data; 4584 xcb_generic_iterator_t child = xcb_input_valuator_state_valuators_end(R); 4585 --i->rem; 4586 i->data = (xcb_input_valuator_state_t *) child.data; 4587 i->index = child.index; 4588 } 4589 4590 4591 /***************************************************************************** 4592 ** 4593 ** xcb_generic_iterator_t xcb_input_valuator_state_end 4594 ** 4595 ** @param xcb_input_valuator_state_iterator_t i 4596 ** @returns xcb_generic_iterator_t 4597 ** 4598 *****************************************************************************/ 4599 4600 xcb_generic_iterator_t 4601 xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i /**< */) 4602 { 4603 xcb_generic_iterator_t ret; 4604 while(i.rem > 0) 4605 xcb_input_valuator_state_next(&i); 4606 ret.data = i.data; 4607 ret.rem = i.rem; 4608 ret.index = i.index; 4609 return ret; 4610 } 4611 4612 4613 /***************************************************************************** 4614 ** 4615 ** xcb_void_cookie_t xcb_input_send_extension_event_checked 4616 ** 4617 ** @param xcb_connection_t *c 4618 ** @param xcb_window_t destination 4619 ** @param uint8_t device_id 4620 ** @param uint8_t propagate 4621 ** @param uint16_t num_classes 4622 ** @param uint8_t num_events 4623 ** @param const char *events 4624 ** @param const xcb_input_event_class_t *classes 4625 ** @returns xcb_void_cookie_t 4626 ** 4627 *****************************************************************************/ 4628 4629 xcb_void_cookie_t 4630 xcb_input_send_extension_event_checked (xcb_connection_t *c /**< */, 4631 xcb_window_t destination /**< */, 4632 uint8_t device_id /**< */, 4633 uint8_t propagate /**< */, 4634 uint16_t num_classes /**< */, 4635 uint8_t num_events /**< */, 4636 const char *events /**< */, 4637 const xcb_input_event_class_t *classes /**< */) 4638 { 4639 static const xcb_protocol_request_t xcb_req = { 4640 /* count */ 6, 4641 /* ext */ &xcb_input_id, 4642 /* opcode */ XCB_INPUT_SEND_EXTENSION_EVENT, 4643 /* isvoid */ 1 4644 }; 4645 4646 struct iovec xcb_parts[8]; 4647 xcb_void_cookie_t xcb_ret; 4648 xcb_input_send_extension_event_request_t xcb_out; 4649 4650 xcb_out.destination = destination; 4651 xcb_out.device_id = device_id; 4652 xcb_out.propagate = propagate; 4653 xcb_out.num_classes = num_classes; 4654 xcb_out.num_events = num_events; 4655 memset(xcb_out.pad0, 0, 3); 4656 4657 xcb_parts[2].iov_base = (char *) &xcb_out; 4658 xcb_parts[2].iov_len = sizeof(xcb_out); 4659 xcb_parts[3].iov_base = 0; 4660 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4661 xcb_parts[4].iov_base = (char *) events; 4662 xcb_parts[4].iov_len = (num_events * 32) * sizeof(char); 4663 xcb_parts[5].iov_base = 0; 4664 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4665 xcb_parts[6].iov_base = (char *) classes; 4666 xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t); 4667 xcb_parts[7].iov_base = 0; 4668 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4669 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4670 return xcb_ret; 4671 } 4672 4673 4674 /***************************************************************************** 4675 ** 4676 ** xcb_void_cookie_t xcb_input_send_extension_event 4677 ** 4678 ** @param xcb_connection_t *c 4679 ** @param xcb_window_t destination 4680 ** @param uint8_t device_id 4681 ** @param uint8_t propagate 4682 ** @param uint16_t num_classes 4683 ** @param uint8_t num_events 4684 ** @param const char *events 4685 ** @param const xcb_input_event_class_t *classes 4686 ** @returns xcb_void_cookie_t 4687 ** 4688 *****************************************************************************/ 4689 4690 xcb_void_cookie_t 4691 xcb_input_send_extension_event (xcb_connection_t *c /**< */, 4692 xcb_window_t destination /**< */, 4693 uint8_t device_id /**< */, 4694 uint8_t propagate /**< */, 4695 uint16_t num_classes /**< */, 4696 uint8_t num_events /**< */, 4697 const char *events /**< */, 4698 const xcb_input_event_class_t *classes /**< */) 4699 { 4700 static const xcb_protocol_request_t xcb_req = { 4701 /* count */ 6, 4702 /* ext */ &xcb_input_id, 4703 /* opcode */ XCB_INPUT_SEND_EXTENSION_EVENT, 4704 /* isvoid */ 1 4705 }; 4706 4707 struct iovec xcb_parts[8]; 4708 xcb_void_cookie_t xcb_ret; 4709 xcb_input_send_extension_event_request_t xcb_out; 4710 4711 xcb_out.destination = destination; 4712 xcb_out.device_id = device_id; 4713 xcb_out.propagate = propagate; 4714 xcb_out.num_classes = num_classes; 4715 xcb_out.num_events = num_events; 4716 memset(xcb_out.pad0, 0, 3); 4717 4718 xcb_parts[2].iov_base = (char *) &xcb_out; 4719 xcb_parts[2].iov_len = sizeof(xcb_out); 4720 xcb_parts[3].iov_base = 0; 4721 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4722 xcb_parts[4].iov_base = (char *) events; 4723 xcb_parts[4].iov_len = (num_events * 32) * sizeof(char); 4724 xcb_parts[5].iov_base = 0; 4725 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4726 xcb_parts[6].iov_base = (char *) classes; 4727 xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t); 4728 xcb_parts[7].iov_base = 0; 4729 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 4730 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4731 return xcb_ret; 4732 } 4733 4734 4735 /***************************************************************************** 4736 ** 4737 ** xcb_void_cookie_t xcb_input_device_bell_checked 4738 ** 4739 ** @param xcb_connection_t *c 4740 ** @param uint8_t device_id 4741 ** @param uint8_t feedback_id 4742 ** @param uint8_t feedback_class 4743 ** @param int8_t percent 4744 ** @returns xcb_void_cookie_t 4745 ** 4746 *****************************************************************************/ 4747 4748 xcb_void_cookie_t 4749 xcb_input_device_bell_checked (xcb_connection_t *c /**< */, 4750 uint8_t device_id /**< */, 4751 uint8_t feedback_id /**< */, 4752 uint8_t feedback_class /**< */, 4753 int8_t percent /**< */) 4754 { 4755 static const xcb_protocol_request_t xcb_req = { 4756 /* count */ 2, 4757 /* ext */ &xcb_input_id, 4758 /* opcode */ XCB_INPUT_DEVICE_BELL, 4759 /* isvoid */ 1 4760 }; 4761 4762 struct iovec xcb_parts[4]; 4763 xcb_void_cookie_t xcb_ret; 4764 xcb_input_device_bell_request_t xcb_out; 4765 4766 xcb_out.device_id = device_id; 4767 xcb_out.feedback_id = feedback_id; 4768 xcb_out.feedback_class = feedback_class; 4769 xcb_out.percent = percent; 4770 4771 xcb_parts[2].iov_base = (char *) &xcb_out; 4772 xcb_parts[2].iov_len = sizeof(xcb_out); 4773 xcb_parts[3].iov_base = 0; 4774 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4775 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4776 return xcb_ret; 4777 } 4778 4779 4780 /***************************************************************************** 4781 ** 4782 ** xcb_void_cookie_t xcb_input_device_bell 4783 ** 4784 ** @param xcb_connection_t *c 4785 ** @param uint8_t device_id 4786 ** @param uint8_t feedback_id 4787 ** @param uint8_t feedback_class 4788 ** @param int8_t percent 4789 ** @returns xcb_void_cookie_t 4790 ** 4791 *****************************************************************************/ 4792 4793 xcb_void_cookie_t 4794 xcb_input_device_bell (xcb_connection_t *c /**< */, 4795 uint8_t device_id /**< */, 4796 uint8_t feedback_id /**< */, 4797 uint8_t feedback_class /**< */, 4798 int8_t percent /**< */) 4799 { 4800 static const xcb_protocol_request_t xcb_req = { 4801 /* count */ 2, 4802 /* ext */ &xcb_input_id, 4803 /* opcode */ XCB_INPUT_DEVICE_BELL, 4804 /* isvoid */ 1 4805 }; 4806 4807 struct iovec xcb_parts[4]; 4808 xcb_void_cookie_t xcb_ret; 4809 xcb_input_device_bell_request_t xcb_out; 4810 4811 xcb_out.device_id = device_id; 4812 xcb_out.feedback_id = feedback_id; 4813 xcb_out.feedback_class = feedback_class; 4814 xcb_out.percent = percent; 4815 4816 xcb_parts[2].iov_base = (char *) &xcb_out; 4817 xcb_parts[2].iov_len = sizeof(xcb_out); 4818 xcb_parts[3].iov_base = 0; 4819 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4820 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4821 return xcb_ret; 4822 } 4823 4824 4825 /***************************************************************************** 4826 ** 4827 ** xcb_input_set_device_valuators_cookie_t xcb_input_set_device_valuators 4828 ** 4829 ** @param xcb_connection_t *c 4830 ** @param uint8_t device_id 4831 ** @param uint8_t first_valuator 4832 ** @param uint8_t num_valuators 4833 ** @param const int32_t *valuators 4834 ** @returns xcb_input_set_device_valuators_cookie_t 4835 ** 4836 *****************************************************************************/ 4837 4838 xcb_input_set_device_valuators_cookie_t 4839 xcb_input_set_device_valuators (xcb_connection_t *c /**< */, 4840 uint8_t device_id /**< */, 4841 uint8_t first_valuator /**< */, 4842 uint8_t num_valuators /**< */, 4843 const int32_t *valuators /**< */) 4844 { 4845 static const xcb_protocol_request_t xcb_req = { 4846 /* count */ 4, 4847 /* ext */ &xcb_input_id, 4848 /* opcode */ XCB_INPUT_SET_DEVICE_VALUATORS, 4849 /* isvoid */ 0 4850 }; 4851 4852 struct iovec xcb_parts[6]; 4853 xcb_input_set_device_valuators_cookie_t xcb_ret; 4854 xcb_input_set_device_valuators_request_t xcb_out; 4855 4856 xcb_out.device_id = device_id; 4857 xcb_out.first_valuator = first_valuator; 4858 xcb_out.num_valuators = num_valuators; 4859 xcb_out.pad0 = 0; 4860 4861 xcb_parts[2].iov_base = (char *) &xcb_out; 4862 xcb_parts[2].iov_len = sizeof(xcb_out); 4863 xcb_parts[3].iov_base = 0; 4864 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4865 xcb_parts[4].iov_base = (char *) valuators; 4866 xcb_parts[4].iov_len = num_valuators * sizeof(int32_t); 4867 xcb_parts[5].iov_base = 0; 4868 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4869 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4870 return xcb_ret; 4871 } 4872 4873 4874 /***************************************************************************** 4875 ** 4876 ** xcb_input_set_device_valuators_cookie_t xcb_input_set_device_valuators_unchecked 4877 ** 4878 ** @param xcb_connection_t *c 4879 ** @param uint8_t device_id 4880 ** @param uint8_t first_valuator 4881 ** @param uint8_t num_valuators 4882 ** @param const int32_t *valuators 4883 ** @returns xcb_input_set_device_valuators_cookie_t 4884 ** 4885 *****************************************************************************/ 4886 4887 xcb_input_set_device_valuators_cookie_t 4888 xcb_input_set_device_valuators_unchecked (xcb_connection_t *c /**< */, 4889 uint8_t device_id /**< */, 4890 uint8_t first_valuator /**< */, 4891 uint8_t num_valuators /**< */, 4892 const int32_t *valuators /**< */) 4893 { 4894 static const xcb_protocol_request_t xcb_req = { 4895 /* count */ 4, 4896 /* ext */ &xcb_input_id, 4897 /* opcode */ XCB_INPUT_SET_DEVICE_VALUATORS, 4898 /* isvoid */ 0 4899 }; 4900 4901 struct iovec xcb_parts[6]; 4902 xcb_input_set_device_valuators_cookie_t xcb_ret; 4903 xcb_input_set_device_valuators_request_t xcb_out; 4904 4905 xcb_out.device_id = device_id; 4906 xcb_out.first_valuator = first_valuator; 4907 xcb_out.num_valuators = num_valuators; 4908 xcb_out.pad0 = 0; 4909 4910 xcb_parts[2].iov_base = (char *) &xcb_out; 4911 xcb_parts[2].iov_len = sizeof(xcb_out); 4912 xcb_parts[3].iov_base = 0; 4913 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4914 xcb_parts[4].iov_base = (char *) valuators; 4915 xcb_parts[4].iov_len = num_valuators * sizeof(int32_t); 4916 xcb_parts[5].iov_base = 0; 4917 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 4918 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4919 return xcb_ret; 4920 } 4921 4922 4923 /***************************************************************************** 4924 ** 4925 ** xcb_input_set_device_valuators_reply_t * xcb_input_set_device_valuators_reply 4926 ** 4927 ** @param xcb_connection_t *c 4928 ** @param xcb_input_set_device_valuators_cookie_t cookie 4929 ** @param xcb_generic_error_t **e 4930 ** @returns xcb_input_set_device_valuators_reply_t * 4931 ** 4932 *****************************************************************************/ 4933 4934 xcb_input_set_device_valuators_reply_t * 4935 xcb_input_set_device_valuators_reply (xcb_connection_t *c /**< */, 4936 xcb_input_set_device_valuators_cookie_t cookie /**< */, 4937 xcb_generic_error_t **e /**< */) 4938 { 4939 return (xcb_input_set_device_valuators_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4940 } 4941 4942 4943 /***************************************************************************** 4944 ** 4945 ** xcb_input_get_device_control_cookie_t xcb_input_get_device_control 4946 ** 4947 ** @param xcb_connection_t *c 4948 ** @param uint16_t control_id 4949 ** @param uint8_t device_id 4950 ** @returns xcb_input_get_device_control_cookie_t 4951 ** 4952 *****************************************************************************/ 4953 4954 xcb_input_get_device_control_cookie_t 4955 xcb_input_get_device_control (xcb_connection_t *c /**< */, 4956 uint16_t control_id /**< */, 4957 uint8_t device_id /**< */) 4958 { 4959 static const xcb_protocol_request_t xcb_req = { 4960 /* count */ 2, 4961 /* ext */ &xcb_input_id, 4962 /* opcode */ XCB_INPUT_GET_DEVICE_CONTROL, 4963 /* isvoid */ 0 4964 }; 4965 4966 struct iovec xcb_parts[4]; 4967 xcb_input_get_device_control_cookie_t xcb_ret; 4968 xcb_input_get_device_control_request_t xcb_out; 4969 4970 xcb_out.control_id = control_id; 4971 xcb_out.device_id = device_id; 4972 xcb_out.pad0 = 0; 4973 4974 xcb_parts[2].iov_base = (char *) &xcb_out; 4975 xcb_parts[2].iov_len = sizeof(xcb_out); 4976 xcb_parts[3].iov_base = 0; 4977 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4978 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4979 return xcb_ret; 4980 } 4981 4982 4983 /***************************************************************************** 4984 ** 4985 ** xcb_input_get_device_control_cookie_t xcb_input_get_device_control_unchecked 4986 ** 4987 ** @param xcb_connection_t *c 4988 ** @param uint16_t control_id 4989 ** @param uint8_t device_id 4990 ** @returns xcb_input_get_device_control_cookie_t 4991 ** 4992 *****************************************************************************/ 4993 4994 xcb_input_get_device_control_cookie_t 4995 xcb_input_get_device_control_unchecked (xcb_connection_t *c /**< */, 4996 uint16_t control_id /**< */, 4997 uint8_t device_id /**< */) 4998 { 4999 static const xcb_protocol_request_t xcb_req = { 5000 /* count */ 2, 5001 /* ext */ &xcb_input_id, 5002 /* opcode */ XCB_INPUT_GET_DEVICE_CONTROL, 5003 /* isvoid */ 0 5004 }; 5005 5006 struct iovec xcb_parts[4]; 5007 xcb_input_get_device_control_cookie_t xcb_ret; 5008 xcb_input_get_device_control_request_t xcb_out; 5009 5010 xcb_out.control_id = control_id; 5011 xcb_out.device_id = device_id; 5012 xcb_out.pad0 = 0; 5013 5014 xcb_parts[2].iov_base = (char *) &xcb_out; 5015 xcb_parts[2].iov_len = sizeof(xcb_out); 5016 xcb_parts[3].iov_base = 0; 5017 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5018 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5019 return xcb_ret; 5020 } 5021 5022 5023 /***************************************************************************** 5024 ** 5025 ** xcb_input_get_device_control_reply_t * xcb_input_get_device_control_reply 5026 ** 5027 ** @param xcb_connection_t *c 5028 ** @param xcb_input_get_device_control_cookie_t cookie 5029 ** @param xcb_generic_error_t **e 5030 ** @returns xcb_input_get_device_control_reply_t * 5031 ** 5032 *****************************************************************************/ 5033 5034 xcb_input_get_device_control_reply_t * 5035 xcb_input_get_device_control_reply (xcb_connection_t *c /**< */, 5036 xcb_input_get_device_control_cookie_t cookie /**< */, 5037 xcb_generic_error_t **e /**< */) 5038 { 5039 return (xcb_input_get_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5040 } 5041 5042 5043 /***************************************************************************** 5044 ** 5045 ** void xcb_input_device_state_next 5046 ** 5047 ** @param xcb_input_device_state_iterator_t *i 5048 ** @returns void 5049 ** 5050 *****************************************************************************/ 5051 5052 void 5053 xcb_input_device_state_next (xcb_input_device_state_iterator_t *i /**< */) 5054 { 5055 --i->rem; 5056 ++i->data; 5057 i->index += sizeof(xcb_input_device_state_t); 5058 } 5059 5060 5061 /***************************************************************************** 5062 ** 5063 ** xcb_generic_iterator_t xcb_input_device_state_end 5064 ** 5065 ** @param xcb_input_device_state_iterator_t i 5066 ** @returns xcb_generic_iterator_t 5067 ** 5068 *****************************************************************************/ 5069 5070 xcb_generic_iterator_t 5071 xcb_input_device_state_end (xcb_input_device_state_iterator_t i /**< */) 5072 { 5073 xcb_generic_iterator_t ret; 5074 ret.data = i.data + i.rem; 5075 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5076 ret.rem = 0; 5077 return ret; 5078 } 5079 5080 5081 /***************************************************************************** 5082 ** 5083 ** uint32_t * xcb_input_device_resolution_state_resolution_values 5084 ** 5085 ** @param const xcb_input_device_resolution_state_t *R 5086 ** @returns uint32_t * 5087 ** 5088 *****************************************************************************/ 5089 5090 uint32_t * 5091 xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R /**< */) 5092 { 5093 return (uint32_t *) (R + 1); 5094 } 5095 5096 5097 /***************************************************************************** 5098 ** 5099 ** int xcb_input_device_resolution_state_resolution_values_length 5100 ** 5101 ** @param const xcb_input_device_resolution_state_t *R 5102 ** @returns int 5103 ** 5104 *****************************************************************************/ 5105 5106 int 5107 xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R /**< */) 5108 { 5109 return R->num_valuators; 5110 } 5111 5112 5113 /***************************************************************************** 5114 ** 5115 ** xcb_generic_iterator_t xcb_input_device_resolution_state_resolution_values_end 5116 ** 5117 ** @param const xcb_input_device_resolution_state_t *R 5118 ** @returns xcb_generic_iterator_t 5119 ** 5120 *****************************************************************************/ 5121 5122 xcb_generic_iterator_t 5123 xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R /**< */) 5124 { 5125 xcb_generic_iterator_t i; 5126 i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); 5127 i.rem = 0; 5128 i.index = (char *) i.data - (char *) R; 5129 return i; 5130 } 5131 5132 5133 /***************************************************************************** 5134 ** 5135 ** uint32_t * xcb_input_device_resolution_state_resolution_min 5136 ** 5137 ** @param const xcb_input_device_resolution_state_t *R 5138 ** @returns uint32_t * 5139 ** 5140 *****************************************************************************/ 5141 5142 uint32_t * 5143 xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R /**< */) 5144 { 5145 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R); 5146 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); 5147 } 5148 5149 5150 /***************************************************************************** 5151 ** 5152 ** int xcb_input_device_resolution_state_resolution_min_length 5153 ** 5154 ** @param const xcb_input_device_resolution_state_t *R 5155 ** @returns int 5156 ** 5157 *****************************************************************************/ 5158 5159 int 5160 xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R /**< */) 5161 { 5162 return R->num_valuators; 5163 } 5164 5165 5166 /***************************************************************************** 5167 ** 5168 ** xcb_generic_iterator_t xcb_input_device_resolution_state_resolution_min_end 5169 ** 5170 ** @param const xcb_input_device_resolution_state_t *R 5171 ** @returns xcb_generic_iterator_t 5172 ** 5173 *****************************************************************************/ 5174 5175 xcb_generic_iterator_t 5176 xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R /**< */) 5177 { 5178 xcb_generic_iterator_t i; 5179 xcb_generic_iterator_t child = xcb_input_device_resolution_state_resolution_values_end(R); 5180 i.data = ((uint32_t *) child.data) + (R->num_valuators); 5181 i.rem = 0; 5182 i.index = (char *) i.data - (char *) R; 5183 return i; 5184 } 5185 5186 5187 /***************************************************************************** 5188 ** 5189 ** uint32_t * xcb_input_device_resolution_state_resolution_max 5190 ** 5191 ** @param const xcb_input_device_resolution_state_t *R 5192 ** @returns uint32_t * 5193 ** 5194 *****************************************************************************/ 5195 5196 uint32_t * 5197 xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R /**< */) 5198 { 5199 xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R); 5200 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); 5201 } 5202 5203 5204 /***************************************************************************** 5205 ** 5206 ** int xcb_input_device_resolution_state_resolution_max_length 5207 ** 5208 ** @param const xcb_input_device_resolution_state_t *R 5209 ** @returns int 5210 ** 5211 *****************************************************************************/ 5212 5213 int 5214 xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R /**< */) 5215 { 5216 return R->num_valuators; 5217 } 5218 5219 5220 /***************************************************************************** 5221 ** 5222 ** xcb_generic_iterator_t xcb_input_device_resolution_state_resolution_max_end 5223 ** 5224 ** @param const xcb_input_device_resolution_state_t *R 5225 ** @returns xcb_generic_iterator_t 5226 ** 5227 *****************************************************************************/ 5228 5229 xcb_generic_iterator_t 5230 xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R /**< */) 5231 { 5232 xcb_generic_iterator_t i; 5233 xcb_generic_iterator_t child = xcb_input_device_resolution_state_resolution_min_end(R); 5234 i.data = ((uint32_t *) child.data) + (R->num_valuators); 5235 i.rem = 0; 5236 i.index = (char *) i.data - (char *) R; 5237 return i; 5238 } 5239 5240 5241 /***************************************************************************** 5242 ** 5243 ** void xcb_input_device_resolution_state_next 5244 ** 5245 ** @param xcb_input_device_resolution_state_iterator_t *i 5246 ** @returns void 5247 ** 5248 *****************************************************************************/ 5249 5250 void 5251 xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i /**< */) 5252 { 5253 xcb_input_device_resolution_state_t *R = i->data; 5254 xcb_generic_iterator_t child = xcb_input_device_resolution_state_resolution_max_end(R); 5255 --i->rem; 5256 i->data = (xcb_input_device_resolution_state_t *) child.data; 5257 i->index = child.index; 5258 } 5259 5260 5261 /***************************************************************************** 5262 ** 5263 ** xcb_generic_iterator_t xcb_input_device_resolution_state_end 5264 ** 5265 ** @param xcb_input_device_resolution_state_iterator_t i 5266 ** @returns xcb_generic_iterator_t 5267 ** 5268 *****************************************************************************/ 5269 5270 xcb_generic_iterator_t 5271 xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i /**< */) 5272 { 5273 xcb_generic_iterator_t ret; 5274 while(i.rem > 0) 5275 xcb_input_device_resolution_state_next(&i); 5276 ret.data = i.data; 5277 ret.rem = i.rem; 5278 ret.index = i.index; 5279 return ret; 5280 } 5281 5282 5283 /***************************************************************************** 5284 ** 5285 ** void xcb_input_device_abs_calib_state_next 5286 ** 5287 ** @param xcb_input_device_abs_calib_state_iterator_t *i 5288 ** @returns void 5289 ** 5290 *****************************************************************************/ 5291 5292 void 5293 xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i /**< */) 5294 { 5295 --i->rem; 5296 ++i->data; 5297 i->index += sizeof(xcb_input_device_abs_calib_state_t); 5298 } 5299 5300 5301 /***************************************************************************** 5302 ** 5303 ** xcb_generic_iterator_t xcb_input_device_abs_calib_state_end 5304 ** 5305 ** @param xcb_input_device_abs_calib_state_iterator_t i 5306 ** @returns xcb_generic_iterator_t 5307 ** 5308 *****************************************************************************/ 5309 5310 xcb_generic_iterator_t 5311 xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i /**< */) 5312 { 5313 xcb_generic_iterator_t ret; 5314 ret.data = i.data + i.rem; 5315 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5316 ret.rem = 0; 5317 return ret; 5318 } 5319 5320 5321 /***************************************************************************** 5322 ** 5323 ** void xcb_input_device_abs_area_state_next 5324 ** 5325 ** @param xcb_input_device_abs_area_state_iterator_t *i 5326 ** @returns void 5327 ** 5328 *****************************************************************************/ 5329 5330 void 5331 xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i /**< */) 5332 { 5333 --i->rem; 5334 ++i->data; 5335 i->index += sizeof(xcb_input_device_abs_area_state_t); 5336 } 5337 5338 5339 /***************************************************************************** 5340 ** 5341 ** xcb_generic_iterator_t xcb_input_device_abs_area_state_end 5342 ** 5343 ** @param xcb_input_device_abs_area_state_iterator_t i 5344 ** @returns xcb_generic_iterator_t 5345 ** 5346 *****************************************************************************/ 5347 5348 xcb_generic_iterator_t 5349 xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i /**< */) 5350 { 5351 xcb_generic_iterator_t ret; 5352 ret.data = i.data + i.rem; 5353 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5354 ret.rem = 0; 5355 return ret; 5356 } 5357 5358 5359 /***************************************************************************** 5360 ** 5361 ** void xcb_input_device_core_state_next 5362 ** 5363 ** @param xcb_input_device_core_state_iterator_t *i 5364 ** @returns void 5365 ** 5366 *****************************************************************************/ 5367 5368 void 5369 xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i /**< */) 5370 { 5371 --i->rem; 5372 ++i->data; 5373 i->index += sizeof(xcb_input_device_core_state_t); 5374 } 5375 5376 5377 /***************************************************************************** 5378 ** 5379 ** xcb_generic_iterator_t xcb_input_device_core_state_end 5380 ** 5381 ** @param xcb_input_device_core_state_iterator_t i 5382 ** @returns xcb_generic_iterator_t 5383 ** 5384 *****************************************************************************/ 5385 5386 xcb_generic_iterator_t 5387 xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i /**< */) 5388 { 5389 xcb_generic_iterator_t ret; 5390 ret.data = i.data + i.rem; 5391 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5392 ret.rem = 0; 5393 return ret; 5394 } 5395 5396 5397 /***************************************************************************** 5398 ** 5399 ** void xcb_input_device_enable_state_next 5400 ** 5401 ** @param xcb_input_device_enable_state_iterator_t *i 5402 ** @returns void 5403 ** 5404 *****************************************************************************/ 5405 5406 void 5407 xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i /**< */) 5408 { 5409 --i->rem; 5410 ++i->data; 5411 i->index += sizeof(xcb_input_device_enable_state_t); 5412 } 5413 5414 5415 /***************************************************************************** 5416 ** 5417 ** xcb_generic_iterator_t xcb_input_device_enable_state_end 5418 ** 5419 ** @param xcb_input_device_enable_state_iterator_t i 5420 ** @returns xcb_generic_iterator_t 5421 ** 5422 *****************************************************************************/ 5423 5424 xcb_generic_iterator_t 5425 xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i /**< */) 5426 { 5427 xcb_generic_iterator_t ret; 5428 ret.data = i.data + i.rem; 5429 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5430 ret.rem = 0; 5431 return ret; 5432 } 5433 5434 5435 /***************************************************************************** 5436 ** 5437 ** void xcb_input_device_ctl_next 5438 ** 5439 ** @param xcb_input_device_ctl_iterator_t *i 5440 ** @returns void 5441 ** 5442 *****************************************************************************/ 5443 5444 void 5445 xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i /**< */) 5446 { 5447 --i->rem; 5448 ++i->data; 5449 i->index += sizeof(xcb_input_device_ctl_t); 5450 } 5451 5452 5453 /***************************************************************************** 5454 ** 5455 ** xcb_generic_iterator_t xcb_input_device_ctl_end 5456 ** 5457 ** @param xcb_input_device_ctl_iterator_t i 5458 ** @returns xcb_generic_iterator_t 5459 ** 5460 *****************************************************************************/ 5461 5462 xcb_generic_iterator_t 5463 xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i /**< */) 5464 { 5465 xcb_generic_iterator_t ret; 5466 ret.data = i.data + i.rem; 5467 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5468 ret.rem = 0; 5469 return ret; 5470 } 5471 5472 5473 /***************************************************************************** 5474 ** 5475 ** uint32_t * xcb_input_device_resolution_ctl_resolution_values 5476 ** 5477 ** @param const xcb_input_device_resolution_ctl_t *R 5478 ** @returns uint32_t * 5479 ** 5480 *****************************************************************************/ 5481 5482 uint32_t * 5483 xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R /**< */) 5484 { 5485 return (uint32_t *) (R + 1); 5486 } 5487 5488 5489 /***************************************************************************** 5490 ** 5491 ** int xcb_input_device_resolution_ctl_resolution_values_length 5492 ** 5493 ** @param const xcb_input_device_resolution_ctl_t *R 5494 ** @returns int 5495 ** 5496 *****************************************************************************/ 5497 5498 int 5499 xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R /**< */) 5500 { 5501 return R->num_valuators; 5502 } 5503 5504 5505 /***************************************************************************** 5506 ** 5507 ** xcb_generic_iterator_t xcb_input_device_resolution_ctl_resolution_values_end 5508 ** 5509 ** @param const xcb_input_device_resolution_ctl_t *R 5510 ** @returns xcb_generic_iterator_t 5511 ** 5512 *****************************************************************************/ 5513 5514 xcb_generic_iterator_t 5515 xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R /**< */) 5516 { 5517 xcb_generic_iterator_t i; 5518 i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); 5519 i.rem = 0; 5520 i.index = (char *) i.data - (char *) R; 5521 return i; 5522 } 5523 5524 5525 /***************************************************************************** 5526 ** 5527 ** void xcb_input_device_resolution_ctl_next 5528 ** 5529 ** @param xcb_input_device_resolution_ctl_iterator_t *i 5530 ** @returns void 5531 ** 5532 *****************************************************************************/ 5533 5534 void 5535 xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i /**< */) 5536 { 5537 xcb_input_device_resolution_ctl_t *R = i->data; 5538 xcb_generic_iterator_t child = xcb_input_device_resolution_ctl_resolution_values_end(R); 5539 --i->rem; 5540 i->data = (xcb_input_device_resolution_ctl_t *) child.data; 5541 i->index = child.index; 5542 } 5543 5544 5545 /***************************************************************************** 5546 ** 5547 ** xcb_generic_iterator_t xcb_input_device_resolution_ctl_end 5548 ** 5549 ** @param xcb_input_device_resolution_ctl_iterator_t i 5550 ** @returns xcb_generic_iterator_t 5551 ** 5552 *****************************************************************************/ 5553 5554 xcb_generic_iterator_t 5555 xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i /**< */) 5556 { 5557 xcb_generic_iterator_t ret; 5558 while(i.rem > 0) 5559 xcb_input_device_resolution_ctl_next(&i); 5560 ret.data = i.data; 5561 ret.rem = i.rem; 5562 ret.index = i.index; 5563 return ret; 5564 } 5565 5566 5567 /***************************************************************************** 5568 ** 5569 ** void xcb_input_device_abs_calib_ctl_next 5570 ** 5571 ** @param xcb_input_device_abs_calib_ctl_iterator_t *i 5572 ** @returns void 5573 ** 5574 *****************************************************************************/ 5575 5576 void 5577 xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i /**< */) 5578 { 5579 --i->rem; 5580 ++i->data; 5581 i->index += sizeof(xcb_input_device_abs_calib_ctl_t); 5582 } 5583 5584 5585 /***************************************************************************** 5586 ** 5587 ** xcb_generic_iterator_t xcb_input_device_abs_calib_ctl_end 5588 ** 5589 ** @param xcb_input_device_abs_calib_ctl_iterator_t i 5590 ** @returns xcb_generic_iterator_t 5591 ** 5592 *****************************************************************************/ 5593 5594 xcb_generic_iterator_t 5595 xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i /**< */) 5596 { 5597 xcb_generic_iterator_t ret; 5598 ret.data = i.data + i.rem; 5599 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5600 ret.rem = 0; 5601 return ret; 5602 } 5603 5604 5605 /***************************************************************************** 5606 ** 5607 ** void xcb_input_device_abs_area_ctrl_next 5608 ** 5609 ** @param xcb_input_device_abs_area_ctrl_iterator_t *i 5610 ** @returns void 5611 ** 5612 *****************************************************************************/ 5613 5614 void 5615 xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i /**< */) 5616 { 5617 --i->rem; 5618 ++i->data; 5619 i->index += sizeof(xcb_input_device_abs_area_ctrl_t); 5620 } 5621 5622 5623 /***************************************************************************** 5624 ** 5625 ** xcb_generic_iterator_t xcb_input_device_abs_area_ctrl_end 5626 ** 5627 ** @param xcb_input_device_abs_area_ctrl_iterator_t i 5628 ** @returns xcb_generic_iterator_t 5629 ** 5630 *****************************************************************************/ 5631 5632 xcb_generic_iterator_t 5633 xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i /**< */) 5634 { 5635 xcb_generic_iterator_t ret; 5636 ret.data = i.data + i.rem; 5637 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5638 ret.rem = 0; 5639 return ret; 5640 } 5641 5642 5643 /***************************************************************************** 5644 ** 5645 ** void xcb_input_device_core_ctrl_next 5646 ** 5647 ** @param xcb_input_device_core_ctrl_iterator_t *i 5648 ** @returns void 5649 ** 5650 *****************************************************************************/ 5651 5652 void 5653 xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i /**< */) 5654 { 5655 --i->rem; 5656 ++i->data; 5657 i->index += sizeof(xcb_input_device_core_ctrl_t); 5658 } 5659 5660 5661 /***************************************************************************** 5662 ** 5663 ** xcb_generic_iterator_t xcb_input_device_core_ctrl_end 5664 ** 5665 ** @param xcb_input_device_core_ctrl_iterator_t i 5666 ** @returns xcb_generic_iterator_t 5667 ** 5668 *****************************************************************************/ 5669 5670 xcb_generic_iterator_t 5671 xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i /**< */) 5672 { 5673 xcb_generic_iterator_t ret; 5674 ret.data = i.data + i.rem; 5675 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5676 ret.rem = 0; 5677 return ret; 5678 } 5679 5680 5681 /***************************************************************************** 5682 ** 5683 ** void xcb_input_device_enable_ctrl_next 5684 ** 5685 ** @param xcb_input_device_enable_ctrl_iterator_t *i 5686 ** @returns void 5687 ** 5688 *****************************************************************************/ 5689 5690 void 5691 xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i /**< */) 5692 { 5693 --i->rem; 5694 ++i->data; 5695 i->index += sizeof(xcb_input_device_enable_ctrl_t); 5696 } 5697 5698 5699 /***************************************************************************** 5700 ** 5701 ** xcb_generic_iterator_t xcb_input_device_enable_ctrl_end 5702 ** 5703 ** @param xcb_input_device_enable_ctrl_iterator_t i 5704 ** @returns xcb_generic_iterator_t 5705 ** 5706 *****************************************************************************/ 5707 5708 xcb_generic_iterator_t 5709 xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i /**< */) 5710 { 5711 xcb_generic_iterator_t ret; 5712 ret.data = i.data + i.rem; 5713 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5714 ret.rem = 0; 5715 return ret; 5716 } 5717 5718