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 12xcb_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 24void 25xcb_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 42xcb_generic_iterator_t 43xcb_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 62void 63xcb_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 80xcb_generic_iterator_t 81xcb_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 102xcb_input_get_extension_version_cookie_t 103xcb_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 145xcb_input_get_extension_version_cookie_t 146xcb_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 188xcb_input_get_extension_version_reply_t * 189xcb_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 206void 207xcb_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 224xcb_generic_iterator_t 225xcb_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 244xcb_input_list_input_devices_cookie_t 245xcb_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 277xcb_input_list_input_devices_cookie_t 278xcb_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 310xcb_input_device_info_t * 311xcb_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 326int 327xcb_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 342xcb_input_device_info_iterator_t 343xcb_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 364xcb_input_list_input_devices_reply_t * 365xcb_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 382void 383xcb_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 400xcb_generic_iterator_t 401xcb_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 420void 421xcb_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 438xcb_generic_iterator_t 439xcb_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 458void 459xcb_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 476xcb_generic_iterator_t 477xcb_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 496void 497xcb_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 514xcb_generic_iterator_t 515xcb_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 534xcb_input_axis_info_t * 535xcb_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 550int 551xcb_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 566xcb_input_axis_info_iterator_t 567xcb_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 586void 587xcb_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 606xcb_generic_iterator_t 607xcb_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 628void 629xcb_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 646xcb_generic_iterator_t 647xcb_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 667xcb_input_open_device_cookie_t 668xcb_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 704xcb_input_open_device_cookie_t 705xcb_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 740xcb_input_input_class_info_t * 741xcb_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 756int 757xcb_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 772xcb_input_input_class_info_iterator_t 773xcb_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 794xcb_input_open_device_reply_t * 795xcb_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 813xcb_void_cookie_t 814xcb_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 850xcb_void_cookie_t 851xcb_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 888xcb_input_set_device_mode_cookie_t 889xcb_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 928xcb_input_set_device_mode_cookie_t 929xcb_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 968xcb_input_set_device_mode_reply_t * 969xcb_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 989xcb_void_cookie_t 990xcb_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 1035xcb_void_cookie_t 1036xcb_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 1079xcb_input_get_selected_extension_events_cookie_t 1080xcb_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 1115xcb_input_get_selected_extension_events_cookie_t 1116xcb_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 1150xcb_input_event_class_t * 1151xcb_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 1166int 1167xcb_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 1182xcb_generic_iterator_t 1183xcb_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 1202xcb_input_event_class_t * 1203xcb_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 1219int 1220xcb_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 1235xcb_generic_iterator_t 1236xcb_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 1258xcb_input_get_selected_extension_events_reply_t * 1259xcb_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 1280xcb_void_cookie_t 1281xcb_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 1329xcb_void_cookie_t 1330xcb_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 1375xcb_input_get_device_dont_propagate_list_cookie_t 1376xcb_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 1411xcb_input_get_device_dont_propagate_list_cookie_t 1412xcb_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 1446xcb_input_event_class_t * 1447xcb_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 1462int 1463xcb_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 1478xcb_generic_iterator_t 1479xcb_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 1500xcb_input_get_device_dont_propagate_list_reply_t * 1501xcb_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 1521xcb_input_get_device_motion_events_cookie_t 1522xcb_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 1563xcb_input_get_device_motion_events_cookie_t 1564xcb_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 1604xcb_input_get_device_motion_events_reply_t * 1605xcb_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 1622void 1623xcb_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 1640xcb_generic_iterator_t 1641xcb_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 1661xcb_input_change_keyboard_device_cookie_t 1662xcb_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 1698xcb_input_change_keyboard_device_cookie_t 1699xcb_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 1736xcb_input_change_keyboard_device_reply_t * 1737xcb_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 1757xcb_input_change_pointer_device_cookie_t 1758xcb_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 1800xcb_input_change_pointer_device_cookie_t 1801xcb_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 1842xcb_input_change_pointer_device_reply_t * 1843xcb_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 1868xcb_input_grab_device_cookie_t 1869xcb_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 1929xcb_input_grab_device_cookie_t 1930xcb_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 1984xcb_input_grab_device_reply_t * 1985xcb_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 2004xcb_void_cookie_t 2005xcb_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 2043xcb_void_cookie_t 2044xcb_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 2090xcb_void_cookie_t 2091xcb_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 2157xcb_void_cookie_t 2158xcb_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 2219xcb_void_cookie_t 2220xcb_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 2267xcb_void_cookie_t 2268xcb_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 2320xcb_void_cookie_t 2321xcb_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 2387xcb_void_cookie_t 2388xcb_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 2449xcb_void_cookie_t 2450xcb_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 2497xcb_void_cookie_t 2498xcb_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 2543xcb_void_cookie_t 2544xcb_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 2585xcb_void_cookie_t 2586xcb_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 2625xcb_input_get_device_focus_cookie_t 2626xcb_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 2662xcb_input_get_device_focus_cookie_t 2663xcb_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 2700xcb_input_get_device_focus_reply_t * 2701xcb_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 2722xcb_void_cookie_t 2723xcb_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 2767xcb_void_cookie_t 2768xcb_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 2809xcb_input_get_feedback_control_cookie_t 2810xcb_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 2846xcb_input_get_feedback_control_cookie_t 2847xcb_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 2884xcb_input_get_feedback_control_reply_t * 2885xcb_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 2902void 2903xcb_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 2920xcb_generic_iterator_t 2921xcb_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 2940void 2941xcb_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 2958xcb_generic_iterator_t 2959xcb_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 2978void 2979xcb_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 2996xcb_generic_iterator_t 2997xcb_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 3016void 3017xcb_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 3034xcb_generic_iterator_t 3035xcb_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 3054xcb_keysym_t * 3055xcb_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 3070int 3071xcb_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 3086xcb_generic_iterator_t 3087xcb_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 3106void 3107xcb_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 3126xcb_generic_iterator_t 3127xcb_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 3148void 3149xcb_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 3166xcb_generic_iterator_t 3167xcb_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 3186void 3187xcb_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 3204xcb_generic_iterator_t 3205xcb_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 3224void 3225xcb_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 3242xcb_generic_iterator_t 3243xcb_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 3262void 3263xcb_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 3280xcb_generic_iterator_t 3281xcb_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 3300void 3301xcb_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 3318xcb_generic_iterator_t 3319xcb_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 3338void 3339xcb_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 3356xcb_generic_iterator_t 3357xcb_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 3376xcb_keysym_t * 3377xcb_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 3392int 3393xcb_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 3408xcb_generic_iterator_t 3409xcb_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 3428void 3429xcb_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 3448xcb_generic_iterator_t 3449xcb_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 3470void 3471xcb_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 3488xcb_generic_iterator_t 3489xcb_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 3508void 3509xcb_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 3526xcb_generic_iterator_t 3527xcb_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 3549xcb_input_get_device_key_mapping_cookie_t 3550xcb_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 3591xcb_input_get_device_key_mapping_cookie_t 3592xcb_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 3630xcb_keysym_t * 3631xcb_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 3646int 3647xcb_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 3662xcb_generic_iterator_t 3663xcb_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 3684xcb_input_get_device_key_mapping_reply_t * 3685xcb_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 3707xcb_void_cookie_t 3708xcb_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 3758xcb_void_cookie_t 3759xcb_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 3805xcb_input_get_device_modifier_mapping_cookie_t 3806xcb_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 3842xcb_input_get_device_modifier_mapping_cookie_t 3843xcb_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 3878uint8_t * 3879xcb_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 3894int 3895xcb_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 3910xcb_generic_iterator_t 3911xcb_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 3932xcb_input_get_device_modifier_mapping_reply_t * 3933xcb_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 3953xcb_input_set_device_modifier_mapping_cookie_t 3954xcb_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 3999xcb_input_set_device_modifier_mapping_cookie_t 4000xcb_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 4044xcb_input_set_device_modifier_mapping_reply_t * 4045xcb_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 4063xcb_input_get_device_button_mapping_cookie_t 4064xcb_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 4100xcb_input_get_device_button_mapping_cookie_t 4101xcb_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 4136uint8_t * 4137xcb_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 4152int 4153xcb_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 4168xcb_generic_iterator_t 4169xcb_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 4190xcb_input_get_device_button_mapping_reply_t * 4191xcb_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 4211xcb_input_set_device_button_mapping_cookie_t 4212xcb_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 4257xcb_input_set_device_button_mapping_cookie_t 4258xcb_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 4302xcb_input_set_device_button_mapping_reply_t * 4303xcb_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 4321xcb_input_query_device_state_cookie_t 4322xcb_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 4358xcb_input_query_device_state_cookie_t 4359xcb_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 4396xcb_input_query_device_state_reply_t * 4397xcb_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 4414void 4415xcb_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 4432xcb_generic_iterator_t 4433xcb_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 4452void 4453xcb_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 4470xcb_generic_iterator_t 4471xcb_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 4490void 4491xcb_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 4508xcb_generic_iterator_t 4509xcb_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 4528uint32_t * 4529xcb_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 4544int 4545xcb_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 4560xcb_generic_iterator_t 4561xcb_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 4580void 4581xcb_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 4600xcb_generic_iterator_t 4601xcb_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 4629xcb_void_cookie_t 4630xcb_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 4690xcb_void_cookie_t 4691xcb_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 4748xcb_void_cookie_t 4749xcb_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 4793xcb_void_cookie_t 4794xcb_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 4838xcb_input_set_device_valuators_cookie_t 4839xcb_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 4887xcb_input_set_device_valuators_cookie_t 4888xcb_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 4934xcb_input_set_device_valuators_reply_t * 4935xcb_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 4954xcb_input_get_device_control_cookie_t 4955xcb_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 4994xcb_input_get_device_control_cookie_t 4995xcb_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 5034xcb_input_get_device_control_reply_t * 5035xcb_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 5052void 5053xcb_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 5070xcb_generic_iterator_t 5071xcb_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 5090uint32_t * 5091xcb_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 5106int 5107xcb_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 5122xcb_generic_iterator_t 5123xcb_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 5142uint32_t * 5143xcb_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 5159int 5160xcb_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 5175xcb_generic_iterator_t 5176xcb_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 5196uint32_t * 5197xcb_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 5213int 5214xcb_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 5229xcb_generic_iterator_t 5230xcb_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 5250void 5251xcb_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 5270xcb_generic_iterator_t 5271xcb_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 5292void 5293xcb_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 5310xcb_generic_iterator_t 5311xcb_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 5330void 5331xcb_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 5348xcb_generic_iterator_t 5349xcb_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 5368void 5369xcb_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 5386xcb_generic_iterator_t 5387xcb_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 5406void 5407xcb_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 5424xcb_generic_iterator_t 5425xcb_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 5444void 5445xcb_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 5462xcb_generic_iterator_t 5463xcb_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 5482uint32_t * 5483xcb_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 5498int 5499xcb_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 5514xcb_generic_iterator_t 5515xcb_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 5534void 5535xcb_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 5554xcb_generic_iterator_t 5555xcb_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 5576void 5577xcb_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 5594xcb_generic_iterator_t 5595xcb_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 5614void 5615xcb_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 5632xcb_generic_iterator_t 5633xcb_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 5652void 5653xcb_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 5670xcb_generic_iterator_t 5671xcb_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 5690void 5691xcb_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 5708xcb_generic_iterator_t 5709xcb_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